Mercurial > libavcodec.hg
annotate imgconvert_template.h @ 4391:20944c70a3c0 libavcodec
fix segfault with darkkben.free.fr/corrupted_h264.mp4
author | michael |
---|---|
date | Tue, 23 Jan 2007 19:32:26 +0000 |
parents | 58412faefb46 |
children | a2b14c6fccfd |
rev | line source |
---|---|
1204 | 1 /* |
2 * Templates for image convertion routines | |
3 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard. | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1204 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1204 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1204 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1204 | 20 */ |
21 | |
22 #ifndef RGB_OUT | |
23 #define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xff) | |
24 #endif | |
25 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
26 static void glue(yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 27 int width, int height) |
28 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
29 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr; |
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
30 uint8_t *d, *d1, *d2; |
1204 | 31 int w, y, cb, cr, r_add, g_add, b_add, width2; |
4176 | 32 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1204 | 33 unsigned int r, g, b; |
34 | |
35 d = dst->data[0]; | |
36 y1_ptr = src->data[0]; | |
37 cb_ptr = src->data[1]; | |
38 cr_ptr = src->data[2]; | |
39 width2 = (width + 1) >> 1; | |
40 for(;height >= 2; height -= 2) { | |
41 d1 = d; | |
42 d2 = d + dst->linesize[0]; | |
43 y2_ptr = y1_ptr + src->linesize[0]; | |
44 for(w = width; w >= 2; w -= 2) { | |
45 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); | |
46 /* output 4 pixels */ | |
47 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); | |
48 RGB_OUT(d1, r, g, b); | |
49 | |
50 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]); | |
51 RGB_OUT(d1 + BPP, r, g, b); | |
52 | |
53 YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]); | |
54 RGB_OUT(d2, r, g, b); | |
55 | |
56 YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[1]); | |
57 RGB_OUT(d2 + BPP, r, g, b); | |
58 | |
59 d1 += 2 * BPP; | |
60 d2 += 2 * BPP; | |
61 | |
62 y1_ptr += 2; | |
63 y2_ptr += 2; | |
64 cb_ptr++; | |
65 cr_ptr++; | |
66 } | |
67 /* handle odd width */ | |
68 if (w) { | |
69 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); | |
70 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); | |
71 RGB_OUT(d1, r, g, b); | |
72 | |
73 YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]); | |
74 RGB_OUT(d2, r, g, b); | |
75 d1 += BPP; | |
76 d2 += BPP; | |
77 y1_ptr++; | |
78 y2_ptr++; | |
79 cb_ptr++; | |
80 cr_ptr++; | |
81 } | |
82 d += 2 * dst->linesize[0]; | |
83 y1_ptr += 2 * src->linesize[0] - width; | |
84 cb_ptr += src->linesize[1] - width2; | |
85 cr_ptr += src->linesize[2] - width2; | |
86 } | |
87 /* handle odd height */ | |
88 if (height) { | |
89 d1 = d; | |
90 for(w = width; w >= 2; w -= 2) { | |
91 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); | |
92 /* output 2 pixels */ | |
93 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); | |
94 RGB_OUT(d1, r, g, b); | |
95 | |
96 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]); | |
97 RGB_OUT(d1 + BPP, r, g, b); | |
98 | |
99 d1 += 2 * BPP; | |
100 | |
101 y1_ptr += 2; | |
102 cb_ptr++; | |
103 cr_ptr++; | |
104 } | |
105 /* handle width */ | |
106 if (w) { | |
107 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); | |
108 /* output 2 pixels */ | |
109 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); | |
110 RGB_OUT(d1, r, g, b); | |
111 d1 += BPP; | |
112 | |
113 y1_ptr++; | |
114 cb_ptr++; | |
115 cr_ptr++; | |
116 } | |
117 } | |
118 } | |
119 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
120 static void glue(yuvj420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 121 int width, int height) |
122 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
123 const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr; |
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
124 uint8_t *d, *d1, *d2; |
1204 | 125 int w, y, cb, cr, r_add, g_add, b_add, width2; |
4176 | 126 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1204 | 127 unsigned int r, g, b; |
128 | |
129 d = dst->data[0]; | |
130 y1_ptr = src->data[0]; | |
131 cb_ptr = src->data[1]; | |
132 cr_ptr = src->data[2]; | |
133 width2 = (width + 1) >> 1; | |
134 for(;height >= 2; height -= 2) { | |
135 d1 = d; | |
136 d2 = d + dst->linesize[0]; | |
137 y2_ptr = y1_ptr + src->linesize[0]; | |
138 for(w = width; w >= 2; w -= 2) { | |
139 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); | |
140 /* output 4 pixels */ | |
141 YUV_TO_RGB2(r, g, b, y1_ptr[0]); | |
142 RGB_OUT(d1, r, g, b); | |
143 | |
144 YUV_TO_RGB2(r, g, b, y1_ptr[1]); | |
145 RGB_OUT(d1 + BPP, r, g, b); | |
146 | |
147 YUV_TO_RGB2(r, g, b, y2_ptr[0]); | |
148 RGB_OUT(d2, r, g, b); | |
149 | |
150 YUV_TO_RGB2(r, g, b, y2_ptr[1]); | |
151 RGB_OUT(d2 + BPP, r, g, b); | |
152 | |
153 d1 += 2 * BPP; | |
154 d2 += 2 * BPP; | |
155 | |
156 y1_ptr += 2; | |
157 y2_ptr += 2; | |
158 cb_ptr++; | |
159 cr_ptr++; | |
160 } | |
161 /* handle odd width */ | |
162 if (w) { | |
163 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); | |
164 YUV_TO_RGB2(r, g, b, y1_ptr[0]); | |
165 RGB_OUT(d1, r, g, b); | |
166 | |
167 YUV_TO_RGB2(r, g, b, y2_ptr[0]); | |
168 RGB_OUT(d2, r, g, b); | |
169 d1 += BPP; | |
170 d2 += BPP; | |
171 y1_ptr++; | |
172 y2_ptr++; | |
173 cb_ptr++; | |
174 cr_ptr++; | |
175 } | |
176 d += 2 * dst->linesize[0]; | |
177 y1_ptr += 2 * src->linesize[0] - width; | |
178 cb_ptr += src->linesize[1] - width2; | |
179 cr_ptr += src->linesize[2] - width2; | |
180 } | |
181 /* handle odd height */ | |
182 if (height) { | |
183 d1 = d; | |
184 for(w = width; w >= 2; w -= 2) { | |
185 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); | |
186 /* output 2 pixels */ | |
187 YUV_TO_RGB2(r, g, b, y1_ptr[0]); | |
188 RGB_OUT(d1, r, g, b); | |
189 | |
190 YUV_TO_RGB2(r, g, b, y1_ptr[1]); | |
191 RGB_OUT(d1 + BPP, r, g, b); | |
192 | |
193 d1 += 2 * BPP; | |
194 | |
195 y1_ptr += 2; | |
196 cb_ptr++; | |
197 cr_ptr++; | |
198 } | |
199 /* handle width */ | |
200 if (w) { | |
201 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); | |
202 /* output 2 pixels */ | |
203 YUV_TO_RGB2(r, g, b, y1_ptr[0]); | |
204 RGB_OUT(d1, r, g, b); | |
205 d1 += BPP; | |
206 | |
207 y1_ptr++; | |
208 cb_ptr++; | |
209 cr_ptr++; | |
210 } | |
211 } | |
212 } | |
213 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
214 static void glue(RGB_NAME, _to_yuv420p)(AVPicture *dst, const AVPicture *src, |
1204 | 215 int width, int height) |
216 { | |
217 int wrap, wrap3, width2; | |
218 int r, g, b, r1, g1, b1, w; | |
219 uint8_t *lum, *cb, *cr; | |
220 const uint8_t *p; | |
221 | |
222 lum = dst->data[0]; | |
223 cb = dst->data[1]; | |
224 cr = dst->data[2]; | |
225 | |
226 width2 = (width + 1) >> 1; | |
227 wrap = dst->linesize[0]; | |
228 wrap3 = src->linesize[0]; | |
229 p = src->data[0]; | |
230 for(;height>=2;height -= 2) { | |
231 for(w = width; w >= 2; w -= 2) { | |
232 RGB_IN(r, g, b, p); | |
233 r1 = r; | |
234 g1 = g; | |
235 b1 = b; | |
236 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
237 | |
238 RGB_IN(r, g, b, p + BPP); | |
239 r1 += r; | |
240 g1 += g; | |
241 b1 += b; | |
242 lum[1] = RGB_TO_Y_CCIR(r, g, b); | |
243 p += wrap3; | |
244 lum += wrap; | |
245 | |
246 RGB_IN(r, g, b, p); | |
247 r1 += r; | |
248 g1 += g; | |
249 b1 += b; | |
250 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
251 | |
252 RGB_IN(r, g, b, p + BPP); | |
253 r1 += r; | |
254 g1 += g; | |
255 b1 += b; | |
256 lum[1] = RGB_TO_Y_CCIR(r, g, b); | |
257 | |
258 cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 2); | |
259 cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 2); | |
260 | |
261 cb++; | |
262 cr++; | |
263 p += -wrap3 + 2 * BPP; | |
264 lum += -wrap + 2; | |
265 } | |
266 if (w) { | |
267 RGB_IN(r, g, b, p); | |
268 r1 = r; | |
269 g1 = g; | |
270 b1 = b; | |
271 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
272 p += wrap3; | |
273 lum += wrap; | |
274 RGB_IN(r, g, b, p); | |
275 r1 += r; | |
276 g1 += g; | |
277 b1 += b; | |
278 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
279 cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1); | |
280 cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1); | |
281 cb++; | |
282 cr++; | |
283 p += -wrap3 + BPP; | |
284 lum += -wrap + 1; | |
285 } | |
286 p += wrap3 + (wrap3 - width * BPP); | |
287 lum += wrap + (wrap - width); | |
288 cb += dst->linesize[1] - width2; | |
289 cr += dst->linesize[2] - width2; | |
290 } | |
291 /* handle odd height */ | |
292 if (height) { | |
293 for(w = width; w >= 2; w -= 2) { | |
294 RGB_IN(r, g, b, p); | |
295 r1 = r; | |
296 g1 = g; | |
297 b1 = b; | |
298 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
299 | |
300 RGB_IN(r, g, b, p + BPP); | |
301 r1 += r; | |
302 g1 += g; | |
303 b1 += b; | |
304 lum[1] = RGB_TO_Y_CCIR(r, g, b); | |
305 cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1); | |
306 cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1); | |
307 cb++; | |
308 cr++; | |
309 p += 2 * BPP; | |
310 lum += 2; | |
311 } | |
312 if (w) { | |
313 RGB_IN(r, g, b, p); | |
314 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
315 cb[0] = RGB_TO_U_CCIR(r, g, b, 0); | |
316 cr[0] = RGB_TO_V_CCIR(r, g, b, 0); | |
317 } | |
318 } | |
319 } | |
320 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
321 static void glue(RGB_NAME, _to_gray)(AVPicture *dst, const AVPicture *src, |
1204 | 322 int width, int height) |
323 { | |
324 const unsigned char *p; | |
325 unsigned char *q; | |
326 int r, g, b, dst_wrap, src_wrap; | |
327 int x, y; | |
328 | |
329 p = src->data[0]; | |
330 src_wrap = src->linesize[0] - BPP * width; | |
331 | |
332 q = dst->data[0]; | |
333 dst_wrap = dst->linesize[0] - width; | |
334 | |
335 for(y=0;y<height;y++) { | |
336 for(x=0;x<width;x++) { | |
337 RGB_IN(r, g, b, p); | |
338 q[0] = RGB_TO_Y(r, g, b); | |
339 q++; | |
340 p += BPP; | |
341 } | |
342 p += src_wrap; | |
343 q += dst_wrap; | |
344 } | |
345 } | |
346 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
347 static void glue(gray_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 348 int width, int height) |
349 { | |
350 const unsigned char *p; | |
351 unsigned char *q; | |
352 int r, dst_wrap, src_wrap; | |
353 int x, y; | |
354 | |
355 p = src->data[0]; | |
356 src_wrap = src->linesize[0] - width; | |
357 | |
358 q = dst->data[0]; | |
359 dst_wrap = dst->linesize[0] - BPP * width; | |
360 | |
361 for(y=0;y<height;y++) { | |
362 for(x=0;x<width;x++) { | |
363 r = p[0]; | |
364 RGB_OUT(q, r, r, r); | |
365 q += BPP; | |
366 p ++; | |
367 } | |
368 p += src_wrap; | |
369 q += dst_wrap; | |
370 } | |
371 } | |
372 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
373 static void glue(pal8_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 374 int width, int height) |
375 { | |
376 const unsigned char *p; | |
377 unsigned char *q; | |
378 int r, g, b, dst_wrap, src_wrap; | |
379 int x, y; | |
380 uint32_t v; | |
381 const uint32_t *palette; | |
382 | |
383 p = src->data[0]; | |
384 src_wrap = src->linesize[0] - width; | |
385 palette = (uint32_t *)src->data[1]; | |
386 | |
387 q = dst->data[0]; | |
388 dst_wrap = dst->linesize[0] - BPP * width; | |
389 | |
390 for(y=0;y<height;y++) { | |
391 for(x=0;x<width;x++) { | |
392 v = palette[p[0]]; | |
393 r = (v >> 16) & 0xff; | |
394 g = (v >> 8) & 0xff; | |
395 b = (v) & 0xff; | |
396 #ifdef RGBA_OUT | |
397 { | |
398 int a; | |
399 a = (v >> 24) & 0xff; | |
400 RGBA_OUT(q, r, g, b, a); | |
401 } | |
402 #else | |
403 RGB_OUT(q, r, g, b); | |
404 #endif | |
405 q += BPP; | |
406 p ++; | |
407 } | |
408 p += src_wrap; | |
409 q += dst_wrap; | |
410 } | |
411 } | |
412 | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
413 // RGB24 has optimised routines |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
414 #if !defined(FMT_RGBA32) && !defined(FMT_RGB24) |
1204 | 415 /* alpha support */ |
416 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
417 static void glue(rgba32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 418 int width, int height) |
419 { | |
420 const uint8_t *s; | |
421 uint8_t *d; | |
422 int src_wrap, dst_wrap, j, y; | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
423 unsigned int v, r, g, b; |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
424 #ifdef RGBA_OUT |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
425 unsigned int a; |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
426 #endif |
1204 | 427 |
428 s = src->data[0]; | |
429 src_wrap = src->linesize[0] - width * 4; | |
430 | |
431 d = dst->data[0]; | |
432 dst_wrap = dst->linesize[0] - width * BPP; | |
433 | |
434 for(y=0;y<height;y++) { | |
435 for(j = 0;j < width; j++) { | |
436 v = ((const uint32_t *)(s))[0]; | |
437 r = (v >> 16) & 0xff; | |
438 g = (v >> 8) & 0xff; | |
439 b = v & 0xff; | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
440 #ifdef RGBA_OUT |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
441 a = (v >> 24) & 0xff; |
1204 | 442 RGBA_OUT(d, r, g, b, a); |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
443 #else |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
444 RGB_OUT(d, r, g, b); |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
445 #endif |
1204 | 446 s += 4; |
447 d += BPP; | |
448 } | |
449 s += src_wrap; | |
450 d += dst_wrap; | |
451 } | |
452 } | |
453 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
454 static void glue(RGB_NAME, _to_rgba32)(AVPicture *dst, const AVPicture *src, |
1204 | 455 int width, int height) |
456 { | |
457 const uint8_t *s; | |
458 uint8_t *d; | |
459 int src_wrap, dst_wrap, j, y; | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
460 unsigned int r, g, b; |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
461 #ifdef RGBA_IN |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
462 unsigned int a; |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
463 #endif |
1204 | 464 |
465 s = src->data[0]; | |
466 src_wrap = src->linesize[0] - width * BPP; | |
467 | |
468 d = dst->data[0]; | |
469 dst_wrap = dst->linesize[0] - width * 4; | |
470 | |
471 for(y=0;y<height;y++) { | |
472 for(j = 0;j < width; j++) { | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
473 #ifdef RGBA_IN |
1204 | 474 RGBA_IN(r, g, b, a, s); |
475 ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b; | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
476 #else |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
477 RGB_IN(r, g, b, s); |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
478 ((uint32_t *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b; |
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
479 #endif |
1204 | 480 d += 4; |
481 s += BPP; | |
482 } | |
483 s += src_wrap; | |
484 d += dst_wrap; | |
485 } | |
486 } | |
487 | |
4200
58412faefb46
changed rgba32_to routines to support both alpha and non-alpha formats
alex
parents:
4176
diff
changeset
|
488 #endif /* !defined(FMT_RGBA32) */ |
1204 | 489 |
490 #ifndef FMT_RGB24 | |
491 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
492 static void glue(rgb24_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 493 int width, int height) |
494 { | |
495 const uint8_t *s; | |
496 uint8_t *d; | |
497 int src_wrap, dst_wrap, j, y; | |
498 unsigned int r, g, b; | |
499 | |
500 s = src->data[0]; | |
501 src_wrap = src->linesize[0] - width * 3; | |
502 | |
503 d = dst->data[0]; | |
504 dst_wrap = dst->linesize[0] - width * BPP; | |
505 | |
506 for(y=0;y<height;y++) { | |
507 for(j = 0;j < width; j++) { | |
508 r = s[0]; | |
509 g = s[1]; | |
510 b = s[2]; | |
511 RGB_OUT(d, r, g, b); | |
512 s += 3; | |
513 d += BPP; | |
514 } | |
515 s += src_wrap; | |
516 d += dst_wrap; | |
517 } | |
518 } | |
519 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
520 static void glue(RGB_NAME, _to_rgb24)(AVPicture *dst, const AVPicture *src, |
1204 | 521 int width, int height) |
522 { | |
523 const uint8_t *s; | |
524 uint8_t *d; | |
525 int src_wrap, dst_wrap, j, y; | |
526 unsigned int r, g , b; | |
527 | |
528 s = src->data[0]; | |
529 src_wrap = src->linesize[0] - width * BPP; | |
530 | |
531 d = dst->data[0]; | |
532 dst_wrap = dst->linesize[0] - width * 3; | |
533 | |
534 for(y=0;y<height;y++) { | |
535 for(j = 0;j < width; j++) { | |
536 RGB_IN(r, g, b, s) | |
537 d[0] = r; | |
538 d[1] = g; | |
539 d[2] = b; | |
540 d += 3; | |
541 s += BPP; | |
542 } | |
543 s += src_wrap; | |
544 d += dst_wrap; | |
545 } | |
546 } | |
547 | |
548 #endif /* !FMT_RGB24 */ | |
549 | |
550 #ifdef FMT_RGB24 | |
551 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
552 static void yuv444p_to_rgb24(AVPicture *dst, const AVPicture *src, |
1204 | 553 int width, int height) |
554 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
555 const uint8_t *y1_ptr, *cb_ptr, *cr_ptr; |
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
556 uint8_t *d, *d1; |
1204 | 557 int w, y, cb, cr, r_add, g_add, b_add; |
4176 | 558 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1204 | 559 unsigned int r, g, b; |
560 | |
561 d = dst->data[0]; | |
562 y1_ptr = src->data[0]; | |
563 cb_ptr = src->data[1]; | |
564 cr_ptr = src->data[2]; | |
565 for(;height > 0; height --) { | |
566 d1 = d; | |
567 for(w = width; w > 0; w--) { | |
568 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); | |
569 | |
570 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); | |
571 RGB_OUT(d1, r, g, b); | |
572 d1 += BPP; | |
573 | |
574 y1_ptr++; | |
575 cb_ptr++; | |
576 cr_ptr++; | |
577 } | |
578 d += dst->linesize[0]; | |
579 y1_ptr += src->linesize[0] - width; | |
580 cb_ptr += src->linesize[1] - width; | |
581 cr_ptr += src->linesize[2] - width; | |
582 } | |
583 } | |
584 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
585 static void yuvj444p_to_rgb24(AVPicture *dst, const AVPicture *src, |
1204 | 586 int width, int height) |
587 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
588 const uint8_t *y1_ptr, *cb_ptr, *cr_ptr; |
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
589 uint8_t *d, *d1; |
1204 | 590 int w, y, cb, cr, r_add, g_add, b_add; |
4176 | 591 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1204 | 592 unsigned int r, g, b; |
593 | |
594 d = dst->data[0]; | |
595 y1_ptr = src->data[0]; | |
596 cb_ptr = src->data[1]; | |
597 cr_ptr = src->data[2]; | |
598 for(;height > 0; height --) { | |
599 d1 = d; | |
600 for(w = width; w > 0; w--) { | |
601 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); | |
602 | |
603 YUV_TO_RGB2(r, g, b, y1_ptr[0]); | |
604 RGB_OUT(d1, r, g, b); | |
605 d1 += BPP; | |
606 | |
607 y1_ptr++; | |
608 cb_ptr++; | |
609 cr_ptr++; | |
610 } | |
611 d += dst->linesize[0]; | |
612 y1_ptr += src->linesize[0] - width; | |
613 cb_ptr += src->linesize[1] - width; | |
614 cr_ptr += src->linesize[2] - width; | |
615 } | |
616 } | |
617 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
618 static void rgb24_to_yuv444p(AVPicture *dst, const AVPicture *src, |
1204 | 619 int width, int height) |
620 { | |
621 int src_wrap, x, y; | |
622 int r, g, b; | |
623 uint8_t *lum, *cb, *cr; | |
624 const uint8_t *p; | |
625 | |
626 lum = dst->data[0]; | |
627 cb = dst->data[1]; | |
628 cr = dst->data[2]; | |
629 | |
630 src_wrap = src->linesize[0] - width * BPP; | |
631 p = src->data[0]; | |
632 for(y=0;y<height;y++) { | |
633 for(x=0;x<width;x++) { | |
634 RGB_IN(r, g, b, p); | |
635 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
636 cb[0] = RGB_TO_U_CCIR(r, g, b, 0); | |
637 cr[0] = RGB_TO_V_CCIR(r, g, b, 0); | |
638 p += BPP; | |
639 cb++; | |
640 cr++; | |
641 lum++; | |
642 } | |
643 p += src_wrap; | |
644 lum += dst->linesize[0] - width; | |
645 cb += dst->linesize[1] - width; | |
646 cr += dst->linesize[2] - width; | |
647 } | |
648 } | |
649 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
650 static void rgb24_to_yuvj420p(AVPicture *dst, const AVPicture *src, |
1204 | 651 int width, int height) |
652 { | |
653 int wrap, wrap3, width2; | |
654 int r, g, b, r1, g1, b1, w; | |
655 uint8_t *lum, *cb, *cr; | |
656 const uint8_t *p; | |
657 | |
658 lum = dst->data[0]; | |
659 cb = dst->data[1]; | |
660 cr = dst->data[2]; | |
661 | |
662 width2 = (width + 1) >> 1; | |
663 wrap = dst->linesize[0]; | |
664 wrap3 = src->linesize[0]; | |
665 p = src->data[0]; | |
666 for(;height>=2;height -= 2) { | |
667 for(w = width; w >= 2; w -= 2) { | |
668 RGB_IN(r, g, b, p); | |
669 r1 = r; | |
670 g1 = g; | |
671 b1 = b; | |
672 lum[0] = RGB_TO_Y(r, g, b); | |
673 | |
674 RGB_IN(r, g, b, p + BPP); | |
675 r1 += r; | |
676 g1 += g; | |
677 b1 += b; | |
678 lum[1] = RGB_TO_Y(r, g, b); | |
679 p += wrap3; | |
680 lum += wrap; | |
681 | |
682 RGB_IN(r, g, b, p); | |
683 r1 += r; | |
684 g1 += g; | |
685 b1 += b; | |
686 lum[0] = RGB_TO_Y(r, g, b); | |
687 | |
688 RGB_IN(r, g, b, p + BPP); | |
689 r1 += r; | |
690 g1 += g; | |
691 b1 += b; | |
692 lum[1] = RGB_TO_Y(r, g, b); | |
693 | |
694 cb[0] = RGB_TO_U(r1, g1, b1, 2); | |
695 cr[0] = RGB_TO_V(r1, g1, b1, 2); | |
696 | |
697 cb++; | |
698 cr++; | |
699 p += -wrap3 + 2 * BPP; | |
700 lum += -wrap + 2; | |
701 } | |
702 if (w) { | |
703 RGB_IN(r, g, b, p); | |
704 r1 = r; | |
705 g1 = g; | |
706 b1 = b; | |
707 lum[0] = RGB_TO_Y(r, g, b); | |
708 p += wrap3; | |
709 lum += wrap; | |
710 RGB_IN(r, g, b, p); | |
711 r1 += r; | |
712 g1 += g; | |
713 b1 += b; | |
714 lum[0] = RGB_TO_Y(r, g, b); | |
715 cb[0] = RGB_TO_U(r1, g1, b1, 1); | |
716 cr[0] = RGB_TO_V(r1, g1, b1, 1); | |
717 cb++; | |
718 cr++; | |
719 p += -wrap3 + BPP; | |
720 lum += -wrap + 1; | |
721 } | |
722 p += wrap3 + (wrap3 - width * BPP); | |
723 lum += wrap + (wrap - width); | |
724 cb += dst->linesize[1] - width2; | |
725 cr += dst->linesize[2] - width2; | |
726 } | |
727 /* handle odd height */ | |
728 if (height) { | |
729 for(w = width; w >= 2; w -= 2) { | |
730 RGB_IN(r, g, b, p); | |
731 r1 = r; | |
732 g1 = g; | |
733 b1 = b; | |
734 lum[0] = RGB_TO_Y(r, g, b); | |
735 | |
736 RGB_IN(r, g, b, p + BPP); | |
737 r1 += r; | |
738 g1 += g; | |
739 b1 += b; | |
740 lum[1] = RGB_TO_Y(r, g, b); | |
741 cb[0] = RGB_TO_U(r1, g1, b1, 1); | |
742 cr[0] = RGB_TO_V(r1, g1, b1, 1); | |
743 cb++; | |
744 cr++; | |
745 p += 2 * BPP; | |
746 lum += 2; | |
747 } | |
748 if (w) { | |
749 RGB_IN(r, g, b, p); | |
750 lum[0] = RGB_TO_Y(r, g, b); | |
751 cb[0] = RGB_TO_U(r, g, b, 0); | |
752 cr[0] = RGB_TO_V(r, g, b, 0); | |
753 } | |
754 } | |
755 } | |
756 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
757 static void rgb24_to_yuvj444p(AVPicture *dst, const AVPicture *src, |
1204 | 758 int width, int height) |
759 { | |
760 int src_wrap, x, y; | |
761 int r, g, b; | |
762 uint8_t *lum, *cb, *cr; | |
763 const uint8_t *p; | |
764 | |
765 lum = dst->data[0]; | |
766 cb = dst->data[1]; | |
767 cr = dst->data[2]; | |
768 | |
769 src_wrap = src->linesize[0] - width * BPP; | |
770 p = src->data[0]; | |
771 for(y=0;y<height;y++) { | |
772 for(x=0;x<width;x++) { | |
773 RGB_IN(r, g, b, p); | |
774 lum[0] = RGB_TO_Y(r, g, b); | |
775 cb[0] = RGB_TO_U(r, g, b, 0); | |
776 cr[0] = RGB_TO_V(r, g, b, 0); | |
777 p += BPP; | |
778 cb++; | |
779 cr++; | |
780 lum++; | |
781 } | |
782 p += src_wrap; | |
783 lum += dst->linesize[0] - width; | |
784 cb += dst->linesize[1] - width; | |
785 cr += dst->linesize[2] - width; | |
786 } | |
787 } | |
788 | |
789 #endif /* FMT_RGB24 */ | |
790 | |
791 #if defined(FMT_RGB24) || defined(FMT_RGBA32) | |
792 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
793 static void glue(RGB_NAME, _to_pal8)(AVPicture *dst, const AVPicture *src, |
1204 | 794 int width, int height) |
795 { | |
796 const unsigned char *p; | |
797 unsigned char *q; | |
798 int dst_wrap, src_wrap; | |
799 int x, y, has_alpha; | |
800 unsigned int r, g, b; | |
801 | |
802 p = src->data[0]; | |
803 src_wrap = src->linesize[0] - BPP * width; | |
804 | |
805 q = dst->data[0]; | |
806 dst_wrap = dst->linesize[0] - width; | |
807 has_alpha = 0; | |
2967 | 808 |
1204 | 809 for(y=0;y<height;y++) { |
810 for(x=0;x<width;x++) { | |
811 #ifdef RGBA_IN | |
812 { | |
813 unsigned int a; | |
814 RGBA_IN(r, g, b, a, p); | |
815 /* crude approximation for alpha ! */ | |
816 if (a < 0x80) { | |
817 has_alpha = 1; | |
818 q[0] = TRANSP_INDEX; | |
819 } else { | |
820 q[0] = gif_clut_index(r, g, b); | |
821 } | |
822 } | |
823 #else | |
824 RGB_IN(r, g, b, p); | |
825 q[0] = gif_clut_index(r, g, b); | |
826 #endif | |
827 q++; | |
828 p += BPP; | |
829 } | |
830 p += src_wrap; | |
831 q += dst_wrap; | |
832 } | |
833 | |
834 build_rgb_palette(dst->data[1], has_alpha); | |
835 } | |
836 | |
837 #endif /* defined(FMT_RGB24) || defined(FMT_RGBA32) */ | |
2967 | 838 |
1208 | 839 #ifdef RGBA_IN |
840 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
841 static int glue(get_alpha_info_, RGB_NAME)(const AVPicture *src, |
2979 | 842 int width, int height) |
1208 | 843 { |
844 const unsigned char *p; | |
845 int src_wrap, ret, x, y; | |
846 unsigned int r, g, b, a; | |
847 | |
848 p = src->data[0]; | |
849 src_wrap = src->linesize[0] - BPP * width; | |
850 ret = 0; | |
851 for(y=0;y<height;y++) { | |
852 for(x=0;x<width;x++) { | |
853 RGBA_IN(r, g, b, a, p); | |
854 if (a == 0x00) { | |
855 ret |= FF_ALPHA_TRANSP; | |
856 } else if (a != 0xff) { | |
857 ret |= FF_ALPHA_SEMI_TRANSP; | |
858 } | |
859 p += BPP; | |
860 } | |
861 p += src_wrap; | |
862 } | |
863 return ret; | |
864 } | |
865 | |
866 #endif /* RGBA_IN */ | |
867 | |
1204 | 868 #undef RGB_IN |
869 #undef RGBA_IN | |
870 #undef RGB_OUT | |
871 #undef RGBA_OUT | |
872 #undef BPP | |
873 #undef RGB_NAME | |
874 #undef FMT_RGB24 | |
875 #undef FMT_RGBA32 |