Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavutil / imgutils.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "imgutils.h"
25 #include "internal.h"
26 #include "log.h"
27 #include "pixdesc.h"
28
29 void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
30                                 const AVPixFmtDescriptor *pixdesc)
31 {
32     int i;
33     memset(max_pixsteps, 0, 4*sizeof(max_pixsteps[0]));
34     if (max_pixstep_comps)
35         memset(max_pixstep_comps, 0, 4*sizeof(max_pixstep_comps[0]));
36
37     for (i = 0; i < 4; i++) {
38         const AVComponentDescriptor *comp = &(pixdesc->comp[i]);
39         if ((comp->step_minus1+1) > max_pixsteps[comp->plane]) {
40             max_pixsteps[comp->plane] = comp->step_minus1+1;
41             if (max_pixstep_comps)
42                 max_pixstep_comps[comp->plane] = i;
43         }
44     }
45 }
46
47 static inline
48 int image_get_linesize(int width, int plane,
49                        int max_step, int max_step_comp,
50                        const AVPixFmtDescriptor *desc)
51 {
52     int s, shifted_w, linesize;
53
54     if (width < 0)
55         return AVERROR(EINVAL);
56     s = (max_step_comp == 1 || max_step_comp == 2) ? desc->log2_chroma_w : 0;
57     shifted_w = ((width + (1 << s) - 1)) >> s;
58     if (shifted_w && max_step > INT_MAX / shifted_w)
59         return AVERROR(EINVAL);
60     linesize = max_step * shifted_w;
61     if (desc->flags & PIX_FMT_BITSTREAM)
62         linesize = (linesize + 7) >> 3;
63     return linesize;
64 }
65
66 int av_image_get_linesize(enum PixelFormat pix_fmt, int width, int plane)
67 {
68     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
69     int max_step     [4];       /* max pixel step for each plane */
70     int max_step_comp[4];       /* the component for each plane which has the max pixel step */
71
72     if ((unsigned)pix_fmt >= PIX_FMT_NB || desc->flags & PIX_FMT_HWACCEL)
73         return AVERROR(EINVAL);
74
75     av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
76     return image_get_linesize(width, plane, max_step[plane], max_step_comp[plane], desc);
77 }
78
79 int av_image_fill_linesizes(int linesizes[4], enum PixelFormat pix_fmt, int width)
80 {
81     int i, ret;
82     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
83     int max_step     [4];       /* max pixel step for each plane */
84     int max_step_comp[4];       /* the component for each plane which has the max pixel step */
85
86     memset(linesizes, 0, 4*sizeof(linesizes[0]));
87
88     if ((unsigned)pix_fmt >= PIX_FMT_NB || desc->flags & PIX_FMT_HWACCEL)
89         return AVERROR(EINVAL);
90
91     av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
92     for (i = 0; i < 4; i++) {
93         if ((ret = image_get_linesize(width, i, max_step[i], max_step_comp[i], desc)) < 0)
94             return ret;
95         linesizes[i] = ret;
96     }
97
98     return 0;
99 }
100
101 int av_image_fill_pointers(uint8_t *data[4], enum PixelFormat pix_fmt, int height,
102                            uint8_t *ptr, const int linesizes[4])
103 {
104     int i, total_size, size[4], has_plane[4];
105
106     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
107     memset(data     , 0, sizeof(data[0])*4);
108     memset(size     , 0, sizeof(size));
109     memset(has_plane, 0, sizeof(has_plane));
110
111     if ((unsigned)pix_fmt >= PIX_FMT_NB || desc->flags & PIX_FMT_HWACCEL)
112         return AVERROR(EINVAL);
113
114     data[0] = ptr;
115     if (linesizes[0] > (INT_MAX - 1024) / height)
116         return AVERROR(EINVAL);
117     size[0] = linesizes[0] * height;
118
119     if (desc->flags & PIX_FMT_PAL) {
120         size[0] = (size[0] + 3) & ~3;
121         data[1] = ptr + size[0]; /* palette is stored here as 256 32 bits words */
122         return size[0] + 256 * 4;
123     }
124
125     for (i = 0; i < 4; i++)
126         has_plane[desc->comp[i].plane] = 1;
127
128     total_size = size[0];
129     for (i = 1; i < 4 && has_plane[i]; i++) {
130         int h, s = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
131         data[i] = data[i-1] + size[i-1];
132         h = (height + (1 << s) - 1) >> s;
133         if (linesizes[i] > INT_MAX / h)
134             return AVERROR(EINVAL);
135         size[i] = h * linesizes[i];
136         if (total_size > INT_MAX - size[i])
137             return AVERROR(EINVAL);
138         total_size += size[i];
139     }
140
141     return total_size;
142 }
143
144 int ff_set_systematic_pal2(uint32_t pal[256], enum PixelFormat pix_fmt)
145 {
146     int i;
147
148     for (i = 0; i < 256; i++) {
149         int r, g, b;
150
151         switch (pix_fmt) {
152         case PIX_FMT_RGB8:
153             r = (i>>5    )*36;
154             g = ((i>>2)&7)*36;
155             b = (i&3     )*85;
156             break;
157         case PIX_FMT_BGR8:
158             b = (i>>6    )*85;
159             g = ((i>>3)&7)*36;
160             r = (i&7     )*36;
161             break;
162         case PIX_FMT_RGB4_BYTE:
163             r = (i>>3    )*255;
164             g = ((i>>1)&3)*85;
165             b = (i&1     )*255;
166             break;
167         case PIX_FMT_BGR4_BYTE:
168             b = (i>>3    )*255;
169             g = ((i>>1)&3)*85;
170             r = (i&1     )*255;
171             break;
172         case PIX_FMT_GRAY8:
173             r = b = g = i;
174             break;
175         default:
176             return AVERROR(EINVAL);
177         }
178         pal[i] = b + (g<<8) + (r<<16);
179     }
180
181     return 0;
182 }
183
184 int av_image_alloc(uint8_t *pointers[4], int linesizes[4],
185                    int w, int h, enum PixelFormat pix_fmt, int align)
186 {
187     int i, ret;
188     uint8_t *buf;
189
190     if ((ret = av_image_check_size(w, h, 0, NULL)) < 0)
191         return ret;
192     if ((ret = av_image_fill_linesizes(linesizes, pix_fmt, w)) < 0)
193         return ret;
194
195     for (i = 0; i < 4; i++)
196         linesizes[i] = FFALIGN(linesizes[i], align);
197
198     if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, NULL, linesizes)) < 0)
199         return ret;
200     buf = av_malloc(ret + align);
201     if (!buf)
202         return AVERROR(ENOMEM);
203     if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, buf, linesizes)) < 0) {
204         av_free(buf);
205         return ret;
206     }
207     if (av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_PAL)
208         ff_set_systematic_pal2((uint32_t*)pointers[1], pix_fmt);
209
210     return ret;
211 }
212
213 typedef struct ImgUtils {
214     const AVClass *class;
215     int   log_offset;
216     void *log_ctx;
217 } ImgUtils;
218
219 static const AVClass imgutils_class = { "IMGUTILS", av_default_item_name, NULL, LIBAVUTIL_VERSION_INT, offsetof(ImgUtils, log_offset), offsetof(ImgUtils, log_ctx) };
220
221 int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
222 {
223     ImgUtils imgutils = { &imgutils_class, log_offset, log_ctx };
224
225     if ((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/8)
226         return 0;
227
228     av_log(&imgutils, AV_LOG_ERROR, "Picture size %ux%u is invalid\n", w, h);
229     return AVERROR(EINVAL);
230 }
231
232 void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
233                          const uint8_t *src, int src_linesize,
234                          int bytewidth, int height)
235 {
236     if (!dst || !src)
237         return;
238     for (;height > 0; height--) {
239         memcpy(dst, src, bytewidth);
240         dst += dst_linesize;
241         src += src_linesize;
242     }
243 }
244
245 void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
246                    const uint8_t *src_data[4], const int src_linesizes[4],
247                    enum PixelFormat pix_fmt, int width, int height)
248 {
249     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
250
251     if (desc->flags & PIX_FMT_HWACCEL)
252         return;
253
254     if (desc->flags & PIX_FMT_PAL) {
255         av_image_copy_plane(dst_data[0], dst_linesizes[0],
256                             src_data[0], src_linesizes[0],
257                             width, height);
258         /* copy the palette */
259         memcpy(dst_data[1], src_data[1], 4*256);
260     } else {
261         int i, planes_nb = 0;
262
263         for (i = 0; i < desc->nb_components; i++)
264             planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
265
266         for (i = 0; i < planes_nb; i++) {
267             int h = height;
268             int bwidth = av_image_get_linesize(pix_fmt, width, i);
269             if (i == 1 || i == 2) {
270                 h= -((-height)>>desc->log2_chroma_h);
271             }
272             av_image_copy_plane(dst_data[i], dst_linesizes[i],
273                                 src_data[i], src_linesizes[i],
274                                 bwidth, h);
275         }
276     }
277 }