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