Mercurial > libavcodec.hg
annotate imgconvert_template.h @ 4102:8b1819f82c4a libavcodec
Fix compilation with PIC enabled, BRANCHLESS_GET_CABAC is defined under
!PIC but gets used without a check for !PIC.
author | diego |
---|---|
date | Sun, 29 Oct 2006 13:14:37 +0000 |
parents | c8c591fe26f8 |
children | 23da44e8fd05 |
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; |
32 uint8_t *cm = cropTbl + MAX_NEG_CROP; | |
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; |
126 uint8_t *cm = cropTbl + MAX_NEG_CROP; | |
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 | |
413 #if !defined(FMT_RGBA32) && defined(RGBA_OUT) | |
414 /* alpha support */ | |
415 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
416 static void glue(rgba32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 417 int width, int height) |
418 { | |
419 const uint8_t *s; | |
420 uint8_t *d; | |
421 int src_wrap, dst_wrap, j, y; | |
422 unsigned int v, r, g, b, a; | |
423 | |
424 s = src->data[0]; | |
425 src_wrap = src->linesize[0] - width * 4; | |
426 | |
427 d = dst->data[0]; | |
428 dst_wrap = dst->linesize[0] - width * BPP; | |
429 | |
430 for(y=0;y<height;y++) { | |
431 for(j = 0;j < width; j++) { | |
432 v = ((const uint32_t *)(s))[0]; | |
433 a = (v >> 24) & 0xff; | |
434 r = (v >> 16) & 0xff; | |
435 g = (v >> 8) & 0xff; | |
436 b = v & 0xff; | |
437 RGBA_OUT(d, r, g, b, a); | |
438 s += 4; | |
439 d += BPP; | |
440 } | |
441 s += src_wrap; | |
442 d += dst_wrap; | |
443 } | |
444 } | |
445 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
446 static void glue(RGB_NAME, _to_rgba32)(AVPicture *dst, const AVPicture *src, |
1204 | 447 int width, int height) |
448 { | |
449 const uint8_t *s; | |
450 uint8_t *d; | |
451 int src_wrap, dst_wrap, j, y; | |
452 unsigned int r, g, b, a; | |
453 | |
454 s = src->data[0]; | |
455 src_wrap = src->linesize[0] - width * BPP; | |
456 | |
457 d = dst->data[0]; | |
458 dst_wrap = dst->linesize[0] - width * 4; | |
459 | |
460 for(y=0;y<height;y++) { | |
461 for(j = 0;j < width; j++) { | |
462 RGBA_IN(r, g, b, a, s); | |
463 ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b; | |
464 d += 4; | |
465 s += BPP; | |
466 } | |
467 s += src_wrap; | |
468 d += dst_wrap; | |
469 } | |
470 } | |
471 | |
472 #endif /* !defined(FMT_RGBA32) && defined(RGBA_IN) */ | |
473 | |
474 #ifndef FMT_RGB24 | |
475 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
476 static void glue(rgb24_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
1204 | 477 int width, int height) |
478 { | |
479 const uint8_t *s; | |
480 uint8_t *d; | |
481 int src_wrap, dst_wrap, j, y; | |
482 unsigned int r, g, b; | |
483 | |
484 s = src->data[0]; | |
485 src_wrap = src->linesize[0] - width * 3; | |
486 | |
487 d = dst->data[0]; | |
488 dst_wrap = dst->linesize[0] - width * BPP; | |
489 | |
490 for(y=0;y<height;y++) { | |
491 for(j = 0;j < width; j++) { | |
492 r = s[0]; | |
493 g = s[1]; | |
494 b = s[2]; | |
495 RGB_OUT(d, r, g, b); | |
496 s += 3; | |
497 d += BPP; | |
498 } | |
499 s += src_wrap; | |
500 d += dst_wrap; | |
501 } | |
502 } | |
503 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
504 static void glue(RGB_NAME, _to_rgb24)(AVPicture *dst, const AVPicture *src, |
1204 | 505 int width, int height) |
506 { | |
507 const uint8_t *s; | |
508 uint8_t *d; | |
509 int src_wrap, dst_wrap, j, y; | |
510 unsigned int r, g , b; | |
511 | |
512 s = src->data[0]; | |
513 src_wrap = src->linesize[0] - width * BPP; | |
514 | |
515 d = dst->data[0]; | |
516 dst_wrap = dst->linesize[0] - width * 3; | |
517 | |
518 for(y=0;y<height;y++) { | |
519 for(j = 0;j < width; j++) { | |
520 RGB_IN(r, g, b, s) | |
521 d[0] = r; | |
522 d[1] = g; | |
523 d[2] = b; | |
524 d += 3; | |
525 s += BPP; | |
526 } | |
527 s += src_wrap; | |
528 d += dst_wrap; | |
529 } | |
530 } | |
531 | |
532 #endif /* !FMT_RGB24 */ | |
533 | |
534 #ifdef FMT_RGB24 | |
535 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
536 static void yuv444p_to_rgb24(AVPicture *dst, const AVPicture *src, |
1204 | 537 int width, int height) |
538 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
539 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
|
540 uint8_t *d, *d1; |
1204 | 541 int w, y, cb, cr, r_add, g_add, b_add; |
542 uint8_t *cm = cropTbl + MAX_NEG_CROP; | |
543 unsigned int r, g, b; | |
544 | |
545 d = dst->data[0]; | |
546 y1_ptr = src->data[0]; | |
547 cb_ptr = src->data[1]; | |
548 cr_ptr = src->data[2]; | |
549 for(;height > 0; height --) { | |
550 d1 = d; | |
551 for(w = width; w > 0; w--) { | |
552 YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); | |
553 | |
554 YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); | |
555 RGB_OUT(d1, r, g, b); | |
556 d1 += BPP; | |
557 | |
558 y1_ptr++; | |
559 cb_ptr++; | |
560 cr_ptr++; | |
561 } | |
562 d += dst->linesize[0]; | |
563 y1_ptr += src->linesize[0] - width; | |
564 cb_ptr += src->linesize[1] - width; | |
565 cr_ptr += src->linesize[2] - width; | |
566 } | |
567 } | |
568 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
569 static void yuvj444p_to_rgb24(AVPicture *dst, const AVPicture *src, |
1204 | 570 int width, int height) |
571 { | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
572 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
|
573 uint8_t *d, *d1; |
1204 | 574 int w, y, cb, cr, r_add, g_add, b_add; |
575 uint8_t *cm = cropTbl + MAX_NEG_CROP; | |
576 unsigned int r, g, b; | |
577 | |
578 d = dst->data[0]; | |
579 y1_ptr = src->data[0]; | |
580 cb_ptr = src->data[1]; | |
581 cr_ptr = src->data[2]; | |
582 for(;height > 0; height --) { | |
583 d1 = d; | |
584 for(w = width; w > 0; w--) { | |
585 YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); | |
586 | |
587 YUV_TO_RGB2(r, g, b, y1_ptr[0]); | |
588 RGB_OUT(d1, r, g, b); | |
589 d1 += BPP; | |
590 | |
591 y1_ptr++; | |
592 cb_ptr++; | |
593 cr_ptr++; | |
594 } | |
595 d += dst->linesize[0]; | |
596 y1_ptr += src->linesize[0] - width; | |
597 cb_ptr += src->linesize[1] - width; | |
598 cr_ptr += src->linesize[2] - width; | |
599 } | |
600 } | |
601 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
602 static void rgb24_to_yuv444p(AVPicture *dst, const AVPicture *src, |
1204 | 603 int width, int height) |
604 { | |
605 int src_wrap, x, y; | |
606 int r, g, b; | |
607 uint8_t *lum, *cb, *cr; | |
608 const uint8_t *p; | |
609 | |
610 lum = dst->data[0]; | |
611 cb = dst->data[1]; | |
612 cr = dst->data[2]; | |
613 | |
614 src_wrap = src->linesize[0] - width * BPP; | |
615 p = src->data[0]; | |
616 for(y=0;y<height;y++) { | |
617 for(x=0;x<width;x++) { | |
618 RGB_IN(r, g, b, p); | |
619 lum[0] = RGB_TO_Y_CCIR(r, g, b); | |
620 cb[0] = RGB_TO_U_CCIR(r, g, b, 0); | |
621 cr[0] = RGB_TO_V_CCIR(r, g, b, 0); | |
622 p += BPP; | |
623 cb++; | |
624 cr++; | |
625 lum++; | |
626 } | |
627 p += src_wrap; | |
628 lum += dst->linesize[0] - width; | |
629 cb += dst->linesize[1] - width; | |
630 cr += dst->linesize[2] - width; | |
631 } | |
632 } | |
633 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
634 static void rgb24_to_yuvj420p(AVPicture *dst, const AVPicture *src, |
1204 | 635 int width, int height) |
636 { | |
637 int wrap, wrap3, width2; | |
638 int r, g, b, r1, g1, b1, w; | |
639 uint8_t *lum, *cb, *cr; | |
640 const uint8_t *p; | |
641 | |
642 lum = dst->data[0]; | |
643 cb = dst->data[1]; | |
644 cr = dst->data[2]; | |
645 | |
646 width2 = (width + 1) >> 1; | |
647 wrap = dst->linesize[0]; | |
648 wrap3 = src->linesize[0]; | |
649 p = src->data[0]; | |
650 for(;height>=2;height -= 2) { | |
651 for(w = width; w >= 2; w -= 2) { | |
652 RGB_IN(r, g, b, p); | |
653 r1 = r; | |
654 g1 = g; | |
655 b1 = b; | |
656 lum[0] = RGB_TO_Y(r, g, b); | |
657 | |
658 RGB_IN(r, g, b, p + BPP); | |
659 r1 += r; | |
660 g1 += g; | |
661 b1 += b; | |
662 lum[1] = RGB_TO_Y(r, g, b); | |
663 p += wrap3; | |
664 lum += wrap; | |
665 | |
666 RGB_IN(r, g, b, p); | |
667 r1 += r; | |
668 g1 += g; | |
669 b1 += b; | |
670 lum[0] = RGB_TO_Y(r, g, b); | |
671 | |
672 RGB_IN(r, g, b, p + BPP); | |
673 r1 += r; | |
674 g1 += g; | |
675 b1 += b; | |
676 lum[1] = RGB_TO_Y(r, g, b); | |
677 | |
678 cb[0] = RGB_TO_U(r1, g1, b1, 2); | |
679 cr[0] = RGB_TO_V(r1, g1, b1, 2); | |
680 | |
681 cb++; | |
682 cr++; | |
683 p += -wrap3 + 2 * BPP; | |
684 lum += -wrap + 2; | |
685 } | |
686 if (w) { | |
687 RGB_IN(r, g, b, p); | |
688 r1 = r; | |
689 g1 = g; | |
690 b1 = b; | |
691 lum[0] = RGB_TO_Y(r, g, b); | |
692 p += wrap3; | |
693 lum += wrap; | |
694 RGB_IN(r, g, b, p); | |
695 r1 += r; | |
696 g1 += g; | |
697 b1 += b; | |
698 lum[0] = RGB_TO_Y(r, g, b); | |
699 cb[0] = RGB_TO_U(r1, g1, b1, 1); | |
700 cr[0] = RGB_TO_V(r1, g1, b1, 1); | |
701 cb++; | |
702 cr++; | |
703 p += -wrap3 + BPP; | |
704 lum += -wrap + 1; | |
705 } | |
706 p += wrap3 + (wrap3 - width * BPP); | |
707 lum += wrap + (wrap - width); | |
708 cb += dst->linesize[1] - width2; | |
709 cr += dst->linesize[2] - width2; | |
710 } | |
711 /* handle odd height */ | |
712 if (height) { | |
713 for(w = width; w >= 2; w -= 2) { | |
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 | |
720 RGB_IN(r, g, b, p + BPP); | |
721 r1 += r; | |
722 g1 += g; | |
723 b1 += b; | |
724 lum[1] = RGB_TO_Y(r, g, b); | |
725 cb[0] = RGB_TO_U(r1, g1, b1, 1); | |
726 cr[0] = RGB_TO_V(r1, g1, b1, 1); | |
727 cb++; | |
728 cr++; | |
729 p += 2 * BPP; | |
730 lum += 2; | |
731 } | |
732 if (w) { | |
733 RGB_IN(r, g, b, p); | |
734 lum[0] = RGB_TO_Y(r, g, b); | |
735 cb[0] = RGB_TO_U(r, g, b, 0); | |
736 cr[0] = RGB_TO_V(r, g, b, 0); | |
737 } | |
738 } | |
739 } | |
740 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
741 static void rgb24_to_yuvj444p(AVPicture *dst, const AVPicture *src, |
1204 | 742 int width, int height) |
743 { | |
744 int src_wrap, x, y; | |
745 int r, g, b; | |
746 uint8_t *lum, *cb, *cr; | |
747 const uint8_t *p; | |
748 | |
749 lum = dst->data[0]; | |
750 cb = dst->data[1]; | |
751 cr = dst->data[2]; | |
752 | |
753 src_wrap = src->linesize[0] - width * BPP; | |
754 p = src->data[0]; | |
755 for(y=0;y<height;y++) { | |
756 for(x=0;x<width;x++) { | |
757 RGB_IN(r, g, b, p); | |
758 lum[0] = RGB_TO_Y(r, g, b); | |
759 cb[0] = RGB_TO_U(r, g, b, 0); | |
760 cr[0] = RGB_TO_V(r, g, b, 0); | |
761 p += BPP; | |
762 cb++; | |
763 cr++; | |
764 lum++; | |
765 } | |
766 p += src_wrap; | |
767 lum += dst->linesize[0] - width; | |
768 cb += dst->linesize[1] - width; | |
769 cr += dst->linesize[2] - width; | |
770 } | |
771 } | |
772 | |
773 #endif /* FMT_RGB24 */ | |
774 | |
775 #if defined(FMT_RGB24) || defined(FMT_RGBA32) | |
776 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
777 static void glue(RGB_NAME, _to_pal8)(AVPicture *dst, const AVPicture *src, |
1204 | 778 int width, int height) |
779 { | |
780 const unsigned char *p; | |
781 unsigned char *q; | |
782 int dst_wrap, src_wrap; | |
783 int x, y, has_alpha; | |
784 unsigned int r, g, b; | |
785 | |
786 p = src->data[0]; | |
787 src_wrap = src->linesize[0] - BPP * width; | |
788 | |
789 q = dst->data[0]; | |
790 dst_wrap = dst->linesize[0] - width; | |
791 has_alpha = 0; | |
2967 | 792 |
1204 | 793 for(y=0;y<height;y++) { |
794 for(x=0;x<width;x++) { | |
795 #ifdef RGBA_IN | |
796 { | |
797 unsigned int a; | |
798 RGBA_IN(r, g, b, a, p); | |
799 /* crude approximation for alpha ! */ | |
800 if (a < 0x80) { | |
801 has_alpha = 1; | |
802 q[0] = TRANSP_INDEX; | |
803 } else { | |
804 q[0] = gif_clut_index(r, g, b); | |
805 } | |
806 } | |
807 #else | |
808 RGB_IN(r, g, b, p); | |
809 q[0] = gif_clut_index(r, g, b); | |
810 #endif | |
811 q++; | |
812 p += BPP; | |
813 } | |
814 p += src_wrap; | |
815 q += dst_wrap; | |
816 } | |
817 | |
818 build_rgb_palette(dst->data[1], has_alpha); | |
819 } | |
820 | |
821 #endif /* defined(FMT_RGB24) || defined(FMT_RGBA32) */ | |
2967 | 822 |
1208 | 823 #ifdef RGBA_IN |
824 | |
1488
766a2f4edbea
avcodec const correctness patch by (Drew Hess <dhess at ilm dot com>)
michaelni
parents:
1208
diff
changeset
|
825 static int glue(get_alpha_info_, RGB_NAME)(const AVPicture *src, |
2979 | 826 int width, int height) |
1208 | 827 { |
828 const unsigned char *p; | |
829 int src_wrap, ret, x, y; | |
830 unsigned int r, g, b, a; | |
831 | |
832 p = src->data[0]; | |
833 src_wrap = src->linesize[0] - BPP * width; | |
834 ret = 0; | |
835 for(y=0;y<height;y++) { | |
836 for(x=0;x<width;x++) { | |
837 RGBA_IN(r, g, b, a, p); | |
838 if (a == 0x00) { | |
839 ret |= FF_ALPHA_TRANSP; | |
840 } else if (a != 0xff) { | |
841 ret |= FF_ALPHA_SEMI_TRANSP; | |
842 } | |
843 p += BPP; | |
844 } | |
845 p += src_wrap; | |
846 } | |
847 return ret; | |
848 } | |
849 | |
850 #endif /* RGBA_IN */ | |
851 | |
1204 | 852 #undef RGB_IN |
853 #undef RGBA_IN | |
854 #undef RGB_OUT | |
855 #undef RGBA_OUT | |
856 #undef BPP | |
857 #undef RGB_NAME | |
858 #undef FMT_RGB24 | |
859 #undef FMT_RGBA32 |