imgutils.c 11.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * misc image utilities
 */

24
#include "avassert.h"
25
#include "common.h"
26
#include "imgutils.h"
27
#include "internal.h"
28
#include "intreadwrite.h"
29
#include "log.h"
30
#include "pixdesc.h"
31

32
void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
                                const AVPixFmtDescriptor *pixdesc)
{
    int i;
    memset(max_pixsteps, 0, 4*sizeof(max_pixsteps[0]));
    if (max_pixstep_comps)
        memset(max_pixstep_comps, 0, 4*sizeof(max_pixstep_comps[0]));

    for (i = 0; i < 4; i++) {
        const AVComponentDescriptor *comp = &(pixdesc->comp[i]);
        if ((comp->step_minus1+1) > max_pixsteps[comp->plane]) {
            max_pixsteps[comp->plane] = comp->step_minus1+1;
            if (max_pixstep_comps)
                max_pixstep_comps[comp->plane] = i;
        }
    }
}

50 51 52 53 54 55 56
static inline
int image_get_linesize(int width, int plane,
                       int max_step, int max_step_comp,
                       const AVPixFmtDescriptor *desc)
{
    int s, shifted_w, linesize;

57 58 59
    if (!desc)
        return AVERROR(EINVAL);

60 61 62 63 64 65 66
    if (width < 0)
        return AVERROR(EINVAL);
    s = (max_step_comp == 1 || max_step_comp == 2) ? desc->log2_chroma_w : 0;
    shifted_w = ((width + (1 << s) - 1)) >> s;
    if (shifted_w && max_step > INT_MAX / shifted_w)
        return AVERROR(EINVAL);
    linesize = max_step * shifted_w;
67

68
    if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)
69 70 71 72
        linesize = (linesize + 7) >> 3;
    return linesize;
}

73
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
74
{
75
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
76 77 78
    int max_step     [4];       /* max pixel step for each plane */
    int max_step_comp[4];       /* the component for each plane which has the max pixel step */

79
    if ((unsigned)pix_fmt >= AV_PIX_FMT_NB || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
80 81
        return AVERROR(EINVAL);

82
    av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
83
    return image_get_linesize(width, plane, max_step[plane], max_step_comp[plane], desc);
84 85
}

86
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
87
{
88
    int i, ret;
89
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
90 91
    int max_step     [4];       /* max pixel step for each plane */
    int max_step_comp[4];       /* the component for each plane which has the max pixel step */
92

93
    memset(linesizes, 0, 4*sizeof(linesizes[0]));
94

95
    if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
96
        return AVERROR(EINVAL);
97

98
    av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
99
    for (i = 0; i < 4; i++) {
100 101 102
        if ((ret = image_get_linesize(width, i, max_step[i], max_step_comp[i], desc)) < 0)
            return ret;
        linesizes[i] = ret;
103 104 105 106 107
    }

    return 0;
}

108
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height,
109
                           uint8_t *ptr, const int linesizes[4])
110
{
111
    int i, total_size, size[4] = { 0 }, has_plane[4] = { 0 };
112

113
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
114 115
    memset(data     , 0, sizeof(data[0])*4);

116
    if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
117 118 119
        return AVERROR(EINVAL);

    data[0] = ptr;
120 121
    if (linesizes[0] > (INT_MAX - 1024) / height)
        return AVERROR(EINVAL);
122
    size[0] = linesizes[0] * height;
123

124 125
    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
        desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
126 127 128
        size[0] = (size[0] + 3) & ~3;
        data[1] = ptr + size[0]; /* palette is stored here as 256 32 bits words */
        return size[0] + 256 * 4;
129
    }
130 131 132 133 134

    for (i = 0; i < 4; i++)
        has_plane[desc->comp[i].plane] = 1;

    total_size = size[0];
135
    for (i = 1; i < 4 && has_plane[i]; i++) {
136 137 138
        int h, s = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
        data[i] = data[i-1] + size[i-1];
        h = (height + (1 << s) - 1) >> s;
139 140
        if (linesizes[i] > INT_MAX / h)
            return AVERROR(EINVAL);
141
        size[i] = h * linesizes[i];
142 143
        if (total_size > INT_MAX - size[i])
            return AVERROR(EINVAL);
144 145 146 147
        total_size += size[i];
    }

    return total_size;
148
}
149

150
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
151 152 153 154 155 156 157
{
    int i;

    for (i = 0; i < 256; i++) {
        int r, g, b;

        switch (pix_fmt) {
158
        case AV_PIX_FMT_RGB8:
159 160 161 162
            r = (i>>5    )*36;
            g = ((i>>2)&7)*36;
            b = (i&3     )*85;
            break;
163
        case AV_PIX_FMT_BGR8:
164 165 166 167
            b = (i>>6    )*85;
            g = ((i>>3)&7)*36;
            r = (i&7     )*36;
            break;
168
        case AV_PIX_FMT_RGB4_BYTE:
169 170 171 172
            r = (i>>3    )*255;
            g = ((i>>1)&3)*85;
            b = (i&1     )*255;
            break;
173
        case AV_PIX_FMT_BGR4_BYTE:
174 175 176 177
            b = (i>>3    )*255;
            g = ((i>>1)&3)*85;
            r = (i&1     )*255;
            break;
178
        case AV_PIX_FMT_GRAY8:
179 180 181 182 183
            r = b = g = i;
            break;
        default:
            return AVERROR(EINVAL);
        }
184
        pal[i] = b + (g<<8) + (r<<16) + (0xFFU<<24);
185 186 187 188 189
    }

    return 0;
}

190
int av_image_alloc(uint8_t *pointers[4], int linesizes[4],
191
                   int w, int h, enum AVPixelFormat pix_fmt, int align)
192
{
193
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
194 195 196
    int i, ret;
    uint8_t *buf;

197 198 199
    if (!desc)
        return AVERROR(EINVAL);

200 201
    if ((ret = av_image_check_size(w, h, 0, NULL)) < 0)
        return ret;
202
    if ((ret = av_image_fill_linesizes(linesizes, pix_fmt, align>7 ? FFALIGN(w, 8) : w)) < 0)
203 204 205 206 207 208 209 210 211 212 213 214 215 216
        return ret;

    for (i = 0; i < 4; i++)
        linesizes[i] = FFALIGN(linesizes[i], align);

    if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, NULL, linesizes)) < 0)
        return ret;
    buf = av_malloc(ret + align);
    if (!buf)
        return AVERROR(ENOMEM);
    if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, buf, linesizes)) < 0) {
        av_free(buf);
        return ret;
    }
217
    if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
218
        avpriv_set_systematic_pal2((uint32_t*)pointers[1], pix_fmt);
219 220 221 222

    return ret;
}

223 224 225 226 227 228 229 230
typedef struct ImgUtils {
    const AVClass *class;
    int   log_offset;
    void *log_ctx;
} ImgUtils;

static const AVClass imgutils_class = { "IMGUTILS", av_default_item_name, NULL, LIBAVUTIL_VERSION_INT, offsetof(ImgUtils, log_offset), offsetof(ImgUtils, log_ctx) };

231
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
232 233 234
{
    ImgUtils imgutils = { &imgutils_class, log_offset, log_ctx };

235
    if ((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/8)
236 237
        return 0;

238
    av_log(&imgutils, AV_LOG_ERROR, "Picture size %ux%u is invalid\n", w, h);
239 240
    return AVERROR(EINVAL);
}
241

242 243 244 245 246 247
void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
                         const uint8_t *src, int src_linesize,
                         int bytewidth, int height)
{
    if (!dst || !src)
        return;
248 249
    av_assert0(abs(src_linesize) >= bytewidth);
    av_assert0(abs(dst_linesize) >= bytewidth);
250 251 252 253 254 255 256
    for (;height > 0; height--) {
        memcpy(dst, src, bytewidth);
        dst += dst_linesize;
        src += src_linesize;
    }
}

257 258
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
                   const uint8_t *src_data[4], const int src_linesizes[4],
259
                   enum AVPixelFormat pix_fmt, int width, int height)
260
{
261
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
262

263
    if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
264 265
        return;

266 267
    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
        desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
268 269
        av_image_copy_plane(dst_data[0], dst_linesizes[0],
                            src_data[0], src_linesizes[0],
270 271 272 273 274 275 276 277 278 279 280 281
                            width, height);
        /* copy the palette */
        memcpy(dst_data[1], src_data[1], 4*256);
    } else {
        int i, planes_nb = 0;

        for (i = 0; i < desc->nb_components; i++)
            planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);

        for (i = 0; i < planes_nb; i++) {
            int h = height;
            int bwidth = av_image_get_linesize(pix_fmt, width, i);
282
            if (bwidth < 0) {
283
                av_log(NULL, AV_LOG_ERROR, "av_image_get_linesize failed\n");
284 285
                return;
            }
286
            if (i == 1 || i == 2) {
287
                h = FF_CEIL_RSHIFT(height, desc->log2_chroma_h);
288
            }
289 290
            av_image_copy_plane(dst_data[i], dst_linesizes[i],
                                src_data[i], src_linesizes[i],
291 292 293 294
                                bwidth, h);
        }
    }
}
295 296 297

int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
                         const uint8_t *src,
298
                         enum AVPixelFormat pix_fmt, int width, int height, int align)
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
{
    int ret, i;

    if ((ret = av_image_check_size(width, height, 0, NULL)) < 0)
        return ret;

    if ((ret = av_image_fill_linesizes(dst_linesize, pix_fmt, width)) < 0)
        return ret;

    for (i = 0; i < 4; i++)
        dst_linesize[i] = FFALIGN(dst_linesize[i], align);

    if ((ret = av_image_fill_pointers(dst_data, pix_fmt, width, NULL, dst_linesize)) < 0)
        return ret;

314
    return av_image_fill_pointers(dst_data, pix_fmt, height, (uint8_t *)src, dst_linesize);
315 316
}

317
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
318
{
319
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
320 321
    uint8_t *data[4];
    int linesize[4];
322 323 324

    if (!desc)
        return AVERROR(EINVAL);
325 326
    if (av_image_check_size(width, height, 0, NULL) < 0)
        return AVERROR(EINVAL);
327
    if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
328 329 330 331 332 333 334
        // do not include palette for these pseudo-paletted formats
        return width * height;
    return av_image_fill_arrays(data, linesize, NULL, pix_fmt, width, height, align);
}

int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
                            const uint8_t * const src_data[4], const int src_linesize[4],
335
                            enum AVPixelFormat pix_fmt, int width, int height, int align)
336 337
{
    int i, j, nb_planes = 0, linesize[4];
338
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
    int size = av_image_get_buffer_size(pix_fmt, width, height, align);

    if (size > dst_size || size < 0)
        return AVERROR(EINVAL);

    for (i = 0; i < desc->nb_components; i++)
        nb_planes = FFMAX(desc->comp[i].plane, nb_planes);
    nb_planes++;

    av_image_fill_linesizes(linesize, pix_fmt, width);
    for (i = 0; i < nb_planes; i++) {
        int h, shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
        const uint8_t *src = src_data[i];
        h = (height + (1 << shift) - 1) >> shift;

        for (j = 0; j < h; j++) {
            memcpy(dst, src, linesize[i]);
            dst += FFALIGN(linesize[i], align);
            src += src_linesize[i];
        }
    }

361
    if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
362
        uint32_t *d32 = (uint32_t *)(((size_t)dst + 3) & ~3);
363 364 365 366 367 368
        for (i = 0; i<256; i++)
            AV_WL32(d32 + i, AV_RN32(src_data[1] + 4*i));
    }

    return size;
}