Mercurial > libavcodec.hg
annotate imgconvert_template.h @ 7351:1502ba3beb72 libavcodec
The codebook generator algorithm involves picking three
different codebook centroids ("high utility", "low
utility" and "closest to the low utility one"). This
change avoid the corner case of choosing two times the
same centroid.
author | vitor |
---|---|
date | Wed, 23 Jul 2008 03:54:31 +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 |