20d06ec1759e9b846d721f1cc5d6ea58b2e40a35
[ffmpeg.git] / libavutil / imgutils.c
1 /*
2  * This file is part of Libav.
3  *
4  * Libav is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * Libav is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with Libav; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 /**
20  * @file
21  * misc image utilities
22  */
23
24 #include "common.h"
25 #include "imgutils.h"
26 #include "imgutils_internal.h"
27 #include "internal.h"
28 #include "intreadwrite.h"
29 #include "log.h"
30 #include "mathematics.h"
31 #include "pixdesc.h"
32 #include "rational.h"
33
34 void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
35                                 const AVPixFmtDescriptor *pixdesc)
36 {
37     int i;
38     memset(max_pixsteps, 0, 4*sizeof(max_pixsteps[0]));
39     if (max_pixstep_comps)
40         memset(max_pixstep_comps, 0, 4*sizeof(max_pixstep_comps[0]));
41
42     for (i = 0; i < 4; i++) {
43         const AVComponentDescriptor *comp = &(pixdesc->comp[i]);
44         if (comp->step > max_pixsteps[comp->plane]) {
45             max_pixsteps[comp->plane] = comp->step;
46             if (max_pixstep_comps)
47                 max_pixstep_comps[comp->plane] = i;
48         }
49     }
50 }
51
52 int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
53 {
54     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
55     int max_step     [4];       /* max pixel step for each plane */
56     int max_step_comp[4];       /* the component for each plane which has the max pixel step */
57     int s;
58
59     if (!desc)
60         return AVERROR(EINVAL);
61
62     if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)
63         return (width * desc->comp[0].step + 7) >> 3;
64
65     av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
66     s = (max_step_comp[plane] == 1 || max_step_comp[plane] == 2) ? desc->log2_chroma_w : 0;
67     return max_step[plane] * (((width + (1 << s) - 1)) >> s);
68 }
69
70 int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
71 {
72     int i;
73     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
74     int max_step     [4];       /* max pixel step for each plane */
75     int max_step_comp[4];       /* the component for each plane which has the max pixel step */
76
77     memset(linesizes, 0, 4*sizeof(linesizes[0]));
78
79     if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
80         return AVERROR(EINVAL);
81
82     if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) {
83         if (width > (INT_MAX - 7) / desc->comp[0].step)
84             return AVERROR(EINVAL);
85         linesizes[0] = (width * desc->comp[0].step + 7) >> 3;
86         return 0;
87     }
88
89     av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
90     for (i = 0; i < 4; i++) {
91         int s = (max_step_comp[i] == 1 || max_step_comp[i] == 2) ? desc->log2_chroma_w : 0;
92         int shifted_w = ((width + (1 << s) - 1)) >> s;
93         if (max_step[i] > INT_MAX / shifted_w)
94             return AVERROR(EINVAL);
95         linesizes[i] = max_step[i] * shifted_w;
96     }
97
98     return 0;
99 }
100
101 int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height,
102                            uint8_t *ptr, const int linesizes[4])
103 {
104     int i, total_size, size[4] = { 0 }, has_plane[4] = { 0 };
105
106     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
107     memset(data     , 0, sizeof(data[0])*4);
108
109     if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
110         return AVERROR(EINVAL);
111
112     data[0] = ptr;
113     if (linesizes[0] > (INT_MAX - 1024) / height)
114         return AVERROR(EINVAL);
115     size[0] = linesizes[0] * height;
116
117     if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
118         desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
119         size[0] = (size[0] + 3) & ~3;
120         data[1] = ptr + size[0]; /* palette is stored here as 256 32 bits words */
121         return size[0] + 256 * 4;
122     }
123
124     for (i = 0; i < 4; i++)
125         has_plane[desc->comp[i].plane] = 1;
126
127     total_size = size[0];
128     for (i = 1; i < 4 && has_plane[i]; i++) {
129         int h, s = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
130         data[i] = data[i-1] + size[i-1];
131         h = (height + (1 << s) - 1) >> s;
132         if (linesizes[i] > INT_MAX / h)
133             return AVERROR(EINVAL);
134         size[i] = h * linesizes[i];
135         if (total_size > INT_MAX - size[i])
136             return AVERROR(EINVAL);
137         total_size += size[i];
138     }
139
140     return total_size;
141 }
142
143 int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
144 {
145     int i;
146
147     for (i = 0; i < 256; i++) {
148         int r, g, b;
149
150         switch (pix_fmt) {
151         case AV_PIX_FMT_RGB8:
152             r = (i>>5    )*36;
153             g = ((i>>2)&7)*36;
154             b = (i&3     )*85;
155             break;
156         case AV_PIX_FMT_BGR8:
157             b = (i>>6    )*85;
158             g = ((i>>3)&7)*36;
159             r = (i&7     )*36;
160             break;
161         case AV_PIX_FMT_RGB4_BYTE:
162             r = (i>>3    )*255;
163             g = ((i>>1)&3)*85;
164             b = (i&1     )*255;
165             break;
166         case AV_PIX_FMT_BGR4_BYTE:
167             b = (i>>3    )*255;
168             g = ((i>>1)&3)*85;
169             r = (i&1     )*255;
170             break;
171         case AV_PIX_FMT_GRAY8:
172             r = b = g = i;
173             break;
174         default:
175             return AVERROR(EINVAL);
176         }
177         pal[i] = b + (g << 8) + (r << 16) + (0xFFU << 24);
178     }
179
180     return 0;
181 }
182
183 int av_image_alloc(uint8_t *pointers[4], int linesizes[4],
184                    int w, int h, enum AVPixelFormat pix_fmt, int align)
185 {
186     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
187     int i, ret;
188     uint8_t *buf;
189
190     if (!desc)
191         return AVERROR(EINVAL);
192
193     if ((ret = av_image_check_size(w, h, 0, NULL)) < 0)
194         return ret;
195     if ((ret = av_image_fill_linesizes(linesizes, pix_fmt, w)) < 0)
196         return ret;
197
198     for (i = 0; i < 4; i++)
199         linesizes[i] = FFALIGN(linesizes[i], align);
200
201     if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, NULL, linesizes)) < 0)
202         return ret;
203     buf = av_malloc(ret + align);
204     if (!buf)
205         return AVERROR(ENOMEM);
206     if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, buf, linesizes)) < 0) {
207         av_free(buf);
208         return ret;
209     }
210     if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
211         avpriv_set_systematic_pal2((uint32_t*)pointers[1], pix_fmt);
212
213     return ret;
214 }
215
216 typedef struct ImgUtils {
217     const AVClass *class;
218     int   log_offset;
219     void *log_ctx;
220 } ImgUtils;
221
222 static const AVClass imgutils_class = { "IMGUTILS", av_default_item_name, NULL, LIBAVUTIL_VERSION_INT, offsetof(ImgUtils, log_offset), offsetof(ImgUtils, log_ctx) };
223
224 int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
225 {
226     ImgUtils imgutils = { &imgutils_class, log_offset, log_ctx };
227
228     if ((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/8)
229         return 0;
230
231     av_log(&imgutils, AV_LOG_ERROR, "Picture size %ux%u is invalid\n", w, h);
232     return AVERROR(EINVAL);
233 }
234
235 int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
236 {
237     int64_t scaled_dim;
238
239     if (!sar.den)
240         return AVERROR(EINVAL);
241
242     if (!sar.num || sar.num == sar.den)
243         return 0;
244
245     if (sar.num < sar.den)
246         scaled_dim = av_rescale_rnd(w, sar.num, sar.den, AV_ROUND_ZERO);
247     else
248         scaled_dim = av_rescale_rnd(h, sar.den, sar.num, AV_ROUND_ZERO);
249
250     if (scaled_dim > 0)
251         return 0;
252
253     return AVERROR(EINVAL);
254 }
255
256 static void image_copy_plane(uint8_t       *dst, ptrdiff_t dst_linesize,
257                              const uint8_t *src, ptrdiff_t src_linesize,
258                              ptrdiff_t bytewidth, int height)
259 {
260     if (!dst || !src)
261         return;
262     for (;height > 0; height--) {
263         memcpy(dst, src, bytewidth);
264         dst += dst_linesize;
265         src += src_linesize;
266     }
267 }
268
269 static void image_copy_plane_uc_from(uint8_t       *dst, ptrdiff_t dst_linesize,
270                                      const uint8_t *src, ptrdiff_t src_linesize,
271                                      ptrdiff_t bytewidth, int height)
272 {
273     int ret = -1;
274
275 #if ARCH_X86
276     ret = ff_image_copy_plane_uc_from_x86(dst, dst_linesize, src, src_linesize,
277                                           bytewidth, height);
278 #endif
279
280     if (ret < 0)
281         image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);
282 }
283
284 void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
285                          const uint8_t *src, int src_linesize,
286                          int bytewidth, int height)
287 {
288     image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);
289 }
290
291 static void image_copy(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4],
292                        const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],
293                        enum AVPixelFormat pix_fmt, int width, int height,
294                        void (*copy_plane)(uint8_t *, ptrdiff_t, const uint8_t *,
295                                           ptrdiff_t, ptrdiff_t, int))
296 {
297     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
298
299     if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
300         return;
301
302     if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
303         desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
304         copy_plane(dst_data[0], dst_linesizes[0],
305                    src_data[0], src_linesizes[0],
306                    width, height);
307         /* copy the palette */
308         memcpy(dst_data[1], src_data[1], 4*256);
309     } else {
310         int i, planes_nb = 0;
311
312         for (i = 0; i < desc->nb_components; i++)
313             planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
314
315         for (i = 0; i < planes_nb; i++) {
316             int h = height;
317             ptrdiff_t bwidth = av_image_get_linesize(pix_fmt, width, i);
318             if (i == 1 || i == 2) {
319                 h = AV_CEIL_RSHIFT(height, desc->log2_chroma_h);
320             }
321             copy_plane(dst_data[i], dst_linesizes[i],
322                        src_data[i], src_linesizes[i],
323                        bwidth, h);
324         }
325     }
326 }
327
328 void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
329                    const uint8_t *src_data[4], const int src_linesizes[4],
330                    enum AVPixelFormat pix_fmt, int width, int height)
331 {
332     ptrdiff_t dst_linesizes1[4], src_linesizes1[4];
333     int i;
334
335     for (i = 0; i < 4; i++) {
336         dst_linesizes1[i] = dst_linesizes[i];
337         src_linesizes1[i] = src_linesizes[i];
338     }
339
340     image_copy(dst_data, dst_linesizes1, src_data, src_linesizes1, pix_fmt,
341                width, height, image_copy_plane);
342 }
343
344 void av_image_copy_uc_from(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4],
345                            const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],
346                            enum AVPixelFormat pix_fmt, int width, int height)
347 {
348     image_copy(dst_data, dst_linesizes, src_data, src_linesizes, pix_fmt,
349                width, height, image_copy_plane_uc_from);
350 }
351
352 int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
353                          const uint8_t *src, enum AVPixelFormat pix_fmt,
354                          int width, int height, int align)
355 {
356     int ret, i;
357
358     ret = av_image_check_size(width, height, 0, NULL);
359     if (ret < 0)
360         return ret;
361
362     ret = av_image_fill_linesizes(dst_linesize, pix_fmt, width);
363     if (ret < 0)
364         return ret;
365
366     for (i = 0; i < 4; i++)
367         dst_linesize[i] = FFALIGN(dst_linesize[i], align);
368
369     return av_image_fill_pointers(dst_data, pix_fmt, height, src, dst_linesize);
370 }
371
372 int av_image_get_buffer_size(enum AVPixelFormat pix_fmt,
373                              int width, int height, int align)
374 {
375     uint8_t *data[4];
376     int linesize[4];
377     int ret;
378     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
379     if (!desc)
380         return AVERROR_BUG;
381
382     ret = av_image_check_size(width, height, 0, NULL);
383     if (ret < 0)
384         return ret;
385
386     // do not include palette for these pseudo-paletted formats
387     if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
388         return width * height;
389
390     return av_image_fill_arrays(data, linesize, NULL, pix_fmt,
391                                 width, height, align);
392 }
393
394 int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
395                             const uint8_t * const src_data[4],
396                             const int src_linesize[4],
397                             enum AVPixelFormat pix_fmt,
398                             int width, int height, int align)
399 {
400     int i, j, nb_planes = 0, linesize[4];
401     int size = av_image_get_buffer_size(pix_fmt, width, height, align);
402     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
403
404     if (size > dst_size || size < 0 || !desc)
405         return AVERROR(EINVAL);
406
407     for (i = 0; i < desc->nb_components; i++)
408         nb_planes = FFMAX(desc->comp[i].plane, nb_planes);
409
410     nb_planes++;
411
412     av_image_fill_linesizes(linesize, pix_fmt, width);
413     for (i = 0; i < nb_planes; i++) {
414         int h, shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
415         const uint8_t *src = src_data[i];
416         h = (height + (1 << shift) - 1) >> shift;
417
418         for (j = 0; j < h; j++) {
419             memcpy(dst, src, linesize[i]);
420             dst += FFALIGN(linesize[i], align);
421             src += src_linesize[i];
422         }
423     }
424
425     if (desc->flags & AV_PIX_FMT_FLAG_PAL)
426         memcpy((unsigned char *)(((size_t)dst + 3) & ~3),
427                src_data[1], 256 * 4);
428
429     return size;
430 }