Mercurial > mplayer.hg
annotate libswscale/yuv2rgb.c @ 23028:57f56d8e182e
Add shift_[xy] (vector that is added to the glyph before transformation) to
bitmap glyph key. Result of rotation depends on them because of perspective
transformation. They are only set when some rotation take place.
author | eugeni |
---|---|
date | Fri, 20 Apr 2007 23:19:23 +0000 |
parents | f37a3ef2685e |
children | 9528d1ebe68f |
rev | line source |
---|---|
18861 | 1 /* |
2 * yuv2rgb.c, Software YUV to RGB coverter | |
3 * | |
4 * Copyright (C) 1999, Aaron Holtzman <aholtzma@ess.engr.uvic.ca> | |
5 * All Rights Reserved. | |
6 * | |
7 * Functions broken out from display_x11.c and several new modes | |
8 * added by Håkan Hjort <d95hjort@dtek.chalmers.se> | |
9 * | |
10 * 15 & 16 bpp support by Franck Sicard <Franck.Sicard@solsoft.fr> | |
11 * | |
12 * This file is part of mpeg2dec, a free MPEG-2 video decoder | |
13 * | |
14 * mpeg2dec is free software; you can redistribute it and/or modify | |
15 * it under the terms of the GNU General Public License as published by | |
16 * the Free Software Foundation; either version 2, or (at your option) | |
17 * any later version. | |
18 * | |
19 * mpeg2dec is distributed in the hope that it will be useful, | |
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
22 * GNU General Public License for more details. | |
23 * | |
24 * You should have received a copy of the GNU General Public License | |
21976 | 25 * along with mpeg2dec; if not, write to the Free Software |
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
18861 | 27 * |
28 * MMX/MMX2 Template stuff from Michael Niedermayer (michaelni@gmx.at) (needed for fast movntq support) | |
29 * 1,4,8bpp support by Michael Niedermayer (michaelni@gmx.at) | |
30 * context / deglobalize stuff by Michael Niedermayer | |
31 */ | |
32 | |
33 #include <stdio.h> | |
34 #include <stdlib.h> | |
35 #include <inttypes.h> | |
36 #include <assert.h> | |
37 | |
38 #include "config.h" | |
39 #include "rgb2rgb.h" | |
40 #include "swscale.h" | |
41 #include "swscale_internal.h" | |
42 | |
43 #ifdef HAVE_MLIB | |
44 #include "yuv2rgb_mlib.c" | |
45 #endif | |
46 | |
47 #define DITHER1XBPP // only for mmx | |
48 | |
49 const uint8_t __attribute__((aligned(8))) dither_2x2_4[2][8]={ | |
50 { 1, 3, 1, 3, 1, 3, 1, 3, }, | |
51 { 2, 0, 2, 0, 2, 0, 2, 0, }, | |
52 }; | |
53 | |
54 const uint8_t __attribute__((aligned(8))) dither_2x2_8[2][8]={ | |
55 { 6, 2, 6, 2, 6, 2, 6, 2, }, | |
56 { 0, 4, 0, 4, 0, 4, 0, 4, }, | |
57 }; | |
58 | |
59 const uint8_t __attribute__((aligned(8))) dither_8x8_32[8][8]={ | |
60 { 17, 9, 23, 15, 16, 8, 22, 14, }, | |
61 { 5, 29, 3, 27, 4, 28, 2, 26, }, | |
62 { 21, 13, 19, 11, 20, 12, 18, 10, }, | |
63 { 0, 24, 6, 30, 1, 25, 7, 31, }, | |
64 { 16, 8, 22, 14, 17, 9, 23, 15, }, | |
65 { 4, 28, 2, 26, 5, 29, 3, 27, }, | |
66 { 20, 12, 18, 10, 21, 13, 19, 11, }, | |
67 { 1, 25, 7, 31, 0, 24, 6, 30, }, | |
68 }; | |
69 | |
70 #if 0 | |
71 const uint8_t __attribute__((aligned(8))) dither_8x8_64[8][8]={ | |
72 { 0, 48, 12, 60, 3, 51, 15, 63, }, | |
73 { 32, 16, 44, 28, 35, 19, 47, 31, }, | |
74 { 8, 56, 4, 52, 11, 59, 7, 55, }, | |
75 { 40, 24, 36, 20, 43, 27, 39, 23, }, | |
76 { 2, 50, 14, 62, 1, 49, 13, 61, }, | |
77 { 34, 18, 46, 30, 33, 17, 45, 29, }, | |
78 { 10, 58, 6, 54, 9, 57, 5, 53, }, | |
79 { 42, 26, 38, 22, 41, 25, 37, 21, }, | |
80 }; | |
81 #endif | |
82 | |
83 const uint8_t __attribute__((aligned(8))) dither_8x8_73[8][8]={ | |
84 { 0, 55, 14, 68, 3, 58, 17, 72, }, | |
85 { 37, 18, 50, 32, 40, 22, 54, 35, }, | |
86 { 9, 64, 5, 59, 13, 67, 8, 63, }, | |
87 { 46, 27, 41, 23, 49, 31, 44, 26, }, | |
88 { 2, 57, 16, 71, 1, 56, 15, 70, }, | |
89 { 39, 21, 52, 34, 38, 19, 51, 33, }, | |
90 { 11, 66, 7, 62, 10, 65, 6, 60, }, | |
91 { 48, 30, 43, 25, 47, 29, 42, 24, }, | |
92 }; | |
93 | |
94 #if 0 | |
95 const uint8_t __attribute__((aligned(8))) dither_8x8_128[8][8]={ | |
96 { 68, 36, 92, 60, 66, 34, 90, 58, }, | |
97 { 20, 116, 12, 108, 18, 114, 10, 106, }, | |
98 { 84, 52, 76, 44, 82, 50, 74, 42, }, | |
99 { 0, 96, 24, 120, 6, 102, 30, 126, }, | |
100 { 64, 32, 88, 56, 70, 38, 94, 62, }, | |
101 { 16, 112, 8, 104, 22, 118, 14, 110, }, | |
102 { 80, 48, 72, 40, 86, 54, 78, 46, }, | |
103 { 4, 100, 28, 124, 2, 98, 26, 122, }, | |
104 }; | |
105 #endif | |
106 | |
107 #if 1 | |
108 const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={ | |
109 {117, 62, 158, 103, 113, 58, 155, 100, }, | |
110 { 34, 199, 21, 186, 31, 196, 17, 182, }, | |
111 {144, 89, 131, 76, 141, 86, 127, 72, }, | |
112 { 0, 165, 41, 206, 10, 175, 52, 217, }, | |
113 {110, 55, 151, 96, 120, 65, 162, 107, }, | |
114 { 28, 193, 14, 179, 38, 203, 24, 189, }, | |
115 {138, 83, 124, 69, 148, 93, 134, 79, }, | |
116 { 7, 172, 48, 213, 3, 168, 45, 210, }, | |
117 }; | |
118 #elif 1 | |
119 // tries to correct a gamma of 1.5 | |
120 const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={ | |
121 { 0, 143, 18, 200, 2, 156, 25, 215, }, | |
122 { 78, 28, 125, 64, 89, 36, 138, 74, }, | |
123 { 10, 180, 3, 161, 16, 195, 8, 175, }, | |
124 {109, 51, 93, 38, 121, 60, 105, 47, }, | |
125 { 1, 152, 23, 210, 0, 147, 20, 205, }, | |
126 { 85, 33, 134, 71, 81, 30, 130, 67, }, | |
127 { 14, 190, 6, 171, 12, 185, 5, 166, }, | |
128 {117, 57, 101, 44, 113, 54, 97, 41, }, | |
129 }; | |
130 #elif 1 | |
131 // tries to correct a gamma of 2.0 | |
132 const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={ | |
133 { 0, 124, 8, 193, 0, 140, 12, 213, }, | |
134 { 55, 14, 104, 42, 66, 19, 119, 52, }, | |
135 { 3, 168, 1, 145, 6, 187, 3, 162, }, | |
136 { 86, 31, 70, 21, 99, 39, 82, 28, }, | |
137 { 0, 134, 11, 206, 0, 129, 9, 200, }, | |
138 { 62, 17, 114, 48, 58, 16, 109, 45, }, | |
139 { 5, 181, 2, 157, 4, 175, 1, 151, }, | |
140 { 95, 36, 78, 26, 90, 34, 74, 24, }, | |
141 }; | |
142 #else | |
143 // tries to correct a gamma of 2.5 | |
144 const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={ | |
145 { 0, 107, 3, 187, 0, 125, 6, 212, }, | |
146 { 39, 7, 86, 28, 49, 11, 102, 36, }, | |
147 { 1, 158, 0, 131, 3, 180, 1, 151, }, | |
148 { 68, 19, 52, 12, 81, 25, 64, 17, }, | |
149 { 0, 119, 5, 203, 0, 113, 4, 195, }, | |
150 { 45, 9, 96, 33, 42, 8, 91, 30, }, | |
151 { 2, 172, 1, 144, 2, 165, 0, 137, }, | |
152 { 77, 23, 60, 15, 72, 21, 56, 14, }, | |
153 }; | |
154 #endif | |
155 | |
19333
4f5e2e0529b1
Do not assemble MMX, MMX2 or 3DNOW code unconditionally on X86 and X86_64.
diego
parents:
19206
diff
changeset
|
156 #ifdef HAVE_MMX |
18861 | 157 |
158 /* hope these constant values are cache line aligned */ | |
20018
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
159 static uint64_t attribute_used __attribute__((aligned(8))) mmx_00ffw = 0x00ff00ff00ff00ffULL; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
160 static uint64_t attribute_used __attribute__((aligned(8))) mmx_redmask = 0xf8f8f8f8f8f8f8f8ULL; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
161 static uint64_t attribute_used __attribute__((aligned(8))) mmx_grnmask = 0xfcfcfcfcfcfcfcfcULL; |
18861 | 162 |
20018
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
163 static uint64_t attribute_used __attribute__((aligned(8))) M24A= 0x00FF0000FF0000FFULL; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
164 static uint64_t attribute_used __attribute__((aligned(8))) M24B= 0xFF0000FF0000FF00ULL; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
165 static uint64_t attribute_used __attribute__((aligned(8))) M24C= 0x0000FF0000FF0000ULL; |
18861 | 166 |
167 // the volatile is required because gcc otherwise optimizes some writes away not knowing that these | |
168 // are read in the asm block | |
20018
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
169 static volatile uint64_t attribute_used __attribute__((aligned(8))) b5Dither; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
170 static volatile uint64_t attribute_used __attribute__((aligned(8))) g5Dither; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
171 static volatile uint64_t attribute_used __attribute__((aligned(8))) g6Dither; |
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
172 static volatile uint64_t attribute_used __attribute__((aligned(8))) r5Dither; |
18861 | 173 |
20018
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
174 static uint64_t __attribute__((aligned(8))) dither4[2]={ |
18861 | 175 0x0103010301030103LL, |
176 0x0200020002000200LL,}; | |
177 | |
20018
aa6cb6610d74
make some global var static (fix a build failure with shared lib on x86_64)
aurel
parents:
19872
diff
changeset
|
178 static uint64_t __attribute__((aligned(8))) dither8[2]={ |
18861 | 179 0x0602060206020602LL, |
180 0x0004000400040004LL,}; | |
181 | |
182 #undef HAVE_MMX | |
183 | |
184 //MMX versions | |
185 #undef RENAME | |
186 #define HAVE_MMX | |
187 #undef HAVE_MMX2 | |
188 #undef HAVE_3DNOW | |
189 #define RENAME(a) a ## _MMX | |
190 #include "yuv2rgb_template.c" | |
191 | |
192 //MMX2 versions | |
193 #undef RENAME | |
194 #define HAVE_MMX | |
195 #define HAVE_MMX2 | |
196 #undef HAVE_3DNOW | |
197 #define RENAME(a) a ## _MMX2 | |
198 #include "yuv2rgb_template.c" | |
199 | |
20576 | 200 #endif /* defined(ARCH_X86) */ |
18861 | 201 |
202 const int32_t Inverse_Table_6_9[8][4] = { | |
203 {117504, 138453, 13954, 34903}, /* no sequence_display_extension */ | |
204 {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */ | |
205 {104597, 132201, 25675, 53279}, /* unspecified */ | |
206 {104597, 132201, 25675, 53279}, /* reserved */ | |
207 {104448, 132798, 24759, 53109}, /* FCC */ | |
208 {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */ | |
209 {104597, 132201, 25675, 53279}, /* SMPTE 170M */ | |
210 {117579, 136230, 16907, 35559} /* SMPTE 240M (1987) */ | |
211 }; | |
212 | |
213 #define RGB(i) \ | |
214 U = pu[i]; \ | |
215 V = pv[i]; \ | |
21758
bb3212f8b1fe
Add some explicit casts to avoid "assignment from incompatible pointer type"
lucabe
parents:
21757
diff
changeset
|
216 r = (void *)c->table_rV[V]; \ |
bb3212f8b1fe
Add some explicit casts to avoid "assignment from incompatible pointer type"
lucabe
parents:
21757
diff
changeset
|
217 g = (void *)(c->table_gU[U] + c->table_gV[V]); \ |
bb3212f8b1fe
Add some explicit casts to avoid "assignment from incompatible pointer type"
lucabe
parents:
21757
diff
changeset
|
218 b = (void *)c->table_bU[U]; |
18861 | 219 |
220 #define DST1(i) \ | |
221 Y = py_1[2*i]; \ | |
222 dst_1[2*i] = r[Y] + g[Y] + b[Y]; \ | |
223 Y = py_1[2*i+1]; \ | |
224 dst_1[2*i+1] = r[Y] + g[Y] + b[Y]; | |
225 | |
226 #define DST2(i) \ | |
227 Y = py_2[2*i]; \ | |
228 dst_2[2*i] = r[Y] + g[Y] + b[Y]; \ | |
229 Y = py_2[2*i+1]; \ | |
230 dst_2[2*i+1] = r[Y] + g[Y] + b[Y]; | |
231 | |
232 #define DST1RGB(i) \ | |
233 Y = py_1[2*i]; \ | |
234 dst_1[6*i] = r[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = b[Y]; \ | |
235 Y = py_1[2*i+1]; \ | |
236 dst_1[6*i+3] = r[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = b[Y]; | |
237 | |
238 #define DST2RGB(i) \ | |
239 Y = py_2[2*i]; \ | |
240 dst_2[6*i] = r[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = b[Y]; \ | |
241 Y = py_2[2*i+1]; \ | |
242 dst_2[6*i+3] = r[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = b[Y]; | |
243 | |
244 #define DST1BGR(i) \ | |
245 Y = py_1[2*i]; \ | |
246 dst_1[6*i] = b[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = r[Y]; \ | |
247 Y = py_1[2*i+1]; \ | |
248 dst_1[6*i+3] = b[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = r[Y]; | |
249 | |
250 #define DST2BGR(i) \ | |
251 Y = py_2[2*i]; \ | |
252 dst_2[6*i] = b[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = r[Y]; \ | |
253 Y = py_2[2*i+1]; \ | |
254 dst_2[6*i+3] = b[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = r[Y]; | |
255 | |
256 #define PROLOG(func_name, dst_type) \ | |
257 static int func_name(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY, \ | |
258 int srcSliceH, uint8_t* dst[], int dstStride[]){\ | |
259 int y;\ | |
260 \ | |
19872
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
261 if(c->srcFormat == PIX_FMT_YUV422P){\ |
18861 | 262 srcStride[1] *= 2;\ |
263 srcStride[2] *= 2;\ | |
264 }\ | |
265 for(y=0; y<srcSliceH; y+=2){\ | |
266 dst_type *dst_1= (dst_type*)(dst[0] + (y+srcSliceY )*dstStride[0]);\ | |
267 dst_type *dst_2= (dst_type*)(dst[0] + (y+srcSliceY+1)*dstStride[0]);\ | |
21759
8e1f3387d864
Mark some variables as possibly unused to avoid warnings
lucabe
parents:
21758
diff
changeset
|
268 dst_type attribute_unused *r, *b;\ |
8e1f3387d864
Mark some variables as possibly unused to avoid warnings
lucabe
parents:
21758
diff
changeset
|
269 dst_type *g;\ |
18861 | 270 uint8_t *py_1= src[0] + y*srcStride[0];\ |
271 uint8_t *py_2= py_1 + srcStride[0];\ | |
272 uint8_t *pu= src[1] + (y>>1)*srcStride[1];\ | |
273 uint8_t *pv= src[2] + (y>>1)*srcStride[2];\ | |
274 unsigned int h_size= c->dstW>>3;\ | |
275 while (h_size--) {\ | |
21759
8e1f3387d864
Mark some variables as possibly unused to avoid warnings
lucabe
parents:
21758
diff
changeset
|
276 int attribute_unused U, V;\ |
8e1f3387d864
Mark some variables as possibly unused to avoid warnings
lucabe
parents:
21758
diff
changeset
|
277 int Y;\ |
18861 | 278 |
279 #define EPILOG(dst_delta)\ | |
280 pu += 4;\ | |
281 pv += 4;\ | |
282 py_1 += 8;\ | |
283 py_2 += 8;\ | |
284 dst_1 += dst_delta;\ | |
285 dst_2 += dst_delta;\ | |
286 }\ | |
287 }\ | |
288 return srcSliceH;\ | |
289 } | |
290 | |
291 PROLOG(yuv2rgb_c_32, uint32_t) | |
292 RGB(0); | |
293 DST1(0); | |
294 DST2(0); | |
295 | |
296 RGB(1); | |
297 DST2(1); | |
298 DST1(1); | |
299 | |
300 RGB(2); | |
301 DST1(2); | |
302 DST2(2); | |
303 | |
304 RGB(3); | |
305 DST2(3); | |
306 DST1(3); | |
307 EPILOG(8) | |
308 | |
309 PROLOG(yuv2rgb_c_24_rgb, uint8_t) | |
310 RGB(0); | |
311 DST1RGB(0); | |
312 DST2RGB(0); | |
313 | |
314 RGB(1); | |
315 DST2RGB(1); | |
316 DST1RGB(1); | |
317 | |
318 RGB(2); | |
319 DST1RGB(2); | |
320 DST2RGB(2); | |
321 | |
322 RGB(3); | |
323 DST2RGB(3); | |
324 DST1RGB(3); | |
325 EPILOG(24) | |
326 | |
327 // only trivial mods from yuv2rgb_c_24_rgb | |
328 PROLOG(yuv2rgb_c_24_bgr, uint8_t) | |
329 RGB(0); | |
330 DST1BGR(0); | |
331 DST2BGR(0); | |
332 | |
333 RGB(1); | |
334 DST2BGR(1); | |
335 DST1BGR(1); | |
336 | |
337 RGB(2); | |
338 DST1BGR(2); | |
339 DST2BGR(2); | |
340 | |
341 RGB(3); | |
342 DST2BGR(3); | |
343 DST1BGR(3); | |
344 EPILOG(24) | |
345 | |
346 // This is exactly the same code as yuv2rgb_c_32 except for the types of | |
347 // r, g, b, dst_1, dst_2 | |
348 PROLOG(yuv2rgb_c_16, uint16_t) | |
349 RGB(0); | |
350 DST1(0); | |
351 DST2(0); | |
352 | |
353 RGB(1); | |
354 DST2(1); | |
355 DST1(1); | |
356 | |
357 RGB(2); | |
358 DST1(2); | |
359 DST2(2); | |
360 | |
361 RGB(3); | |
362 DST2(3); | |
363 DST1(3); | |
364 EPILOG(8) | |
365 | |
366 // This is exactly the same code as yuv2rgb_c_32 except for the types of | |
367 // r, g, b, dst_1, dst_2 | |
368 PROLOG(yuv2rgb_c_8, uint8_t) | |
369 RGB(0); | |
370 DST1(0); | |
371 DST2(0); | |
372 | |
373 RGB(1); | |
374 DST2(1); | |
375 DST1(1); | |
376 | |
377 RGB(2); | |
378 DST1(2); | |
379 DST2(2); | |
380 | |
381 RGB(3); | |
382 DST2(3); | |
383 DST1(3); | |
384 EPILOG(8) | |
385 | |
386 // r, g, b, dst_1, dst_2 | |
387 PROLOG(yuv2rgb_c_8_ordered_dither, uint8_t) | |
388 const uint8_t *d32= dither_8x8_32[y&7]; | |
389 const uint8_t *d64= dither_8x8_73[y&7]; | |
390 #define DST1bpp8(i,o) \ | |
391 Y = py_1[2*i]; \ | |
392 dst_1[2*i] = r[Y+d32[0+o]] + g[Y+d32[0+o]] + b[Y+d64[0+o]]; \ | |
393 Y = py_1[2*i+1]; \ | |
394 dst_1[2*i+1] = r[Y+d32[1+o]] + g[Y+d32[1+o]] + b[Y+d64[1+o]]; | |
395 | |
396 #define DST2bpp8(i,o) \ | |
397 Y = py_2[2*i]; \ | |
398 dst_2[2*i] = r[Y+d32[8+o]] + g[Y+d32[8+o]] + b[Y+d64[8+o]]; \ | |
399 Y = py_2[2*i+1]; \ | |
400 dst_2[2*i+1] = r[Y+d32[9+o]] + g[Y+d32[9+o]] + b[Y+d64[9+o]]; | |
401 | |
402 | |
403 RGB(0); | |
404 DST1bpp8(0,0); | |
405 DST2bpp8(0,0); | |
406 | |
407 RGB(1); | |
408 DST2bpp8(1,2); | |
409 DST1bpp8(1,2); | |
410 | |
411 RGB(2); | |
412 DST1bpp8(2,4); | |
413 DST2bpp8(2,4); | |
414 | |
415 RGB(3); | |
416 DST2bpp8(3,6); | |
417 DST1bpp8(3,6); | |
418 EPILOG(8) | |
419 | |
420 | |
421 // This is exactly the same code as yuv2rgb_c_32 except for the types of | |
422 // r, g, b, dst_1, dst_2 | |
423 PROLOG(yuv2rgb_c_4, uint8_t) | |
424 int acc; | |
425 #define DST1_4(i) \ | |
426 Y = py_1[2*i]; \ | |
427 acc = r[Y] + g[Y] + b[Y]; \ | |
428 Y = py_1[2*i+1]; \ | |
429 acc |= (r[Y] + g[Y] + b[Y])<<4;\ | |
430 dst_1[i] = acc; | |
431 | |
432 #define DST2_4(i) \ | |
433 Y = py_2[2*i]; \ | |
434 acc = r[Y] + g[Y] + b[Y]; \ | |
435 Y = py_2[2*i+1]; \ | |
436 acc |= (r[Y] + g[Y] + b[Y])<<4;\ | |
437 dst_2[i] = acc; | |
438 | |
439 RGB(0); | |
440 DST1_4(0); | |
441 DST2_4(0); | |
442 | |
443 RGB(1); | |
444 DST2_4(1); | |
445 DST1_4(1); | |
446 | |
447 RGB(2); | |
448 DST1_4(2); | |
449 DST2_4(2); | |
450 | |
451 RGB(3); | |
452 DST2_4(3); | |
453 DST1_4(3); | |
454 EPILOG(4) | |
455 | |
456 PROLOG(yuv2rgb_c_4_ordered_dither, uint8_t) | |
457 const uint8_t *d64= dither_8x8_73[y&7]; | |
458 const uint8_t *d128=dither_8x8_220[y&7]; | |
459 int acc; | |
460 | |
461 #define DST1bpp4(i,o) \ | |
462 Y = py_1[2*i]; \ | |
463 acc = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]]; \ | |
464 Y = py_1[2*i+1]; \ | |
465 acc |= (r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]])<<4;\ | |
466 dst_1[i]= acc; | |
467 | |
468 #define DST2bpp4(i,o) \ | |
469 Y = py_2[2*i]; \ | |
470 acc = r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]]; \ | |
471 Y = py_2[2*i+1]; \ | |
472 acc |= (r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]])<<4;\ | |
473 dst_2[i]= acc; | |
474 | |
475 | |
476 RGB(0); | |
477 DST1bpp4(0,0); | |
478 DST2bpp4(0,0); | |
479 | |
480 RGB(1); | |
481 DST2bpp4(1,2); | |
482 DST1bpp4(1,2); | |
483 | |
484 RGB(2); | |
485 DST1bpp4(2,4); | |
486 DST2bpp4(2,4); | |
487 | |
488 RGB(3); | |
489 DST2bpp4(3,6); | |
490 DST1bpp4(3,6); | |
491 EPILOG(4) | |
492 | |
493 // This is exactly the same code as yuv2rgb_c_32 except for the types of | |
494 // r, g, b, dst_1, dst_2 | |
495 PROLOG(yuv2rgb_c_4b, uint8_t) | |
496 RGB(0); | |
497 DST1(0); | |
498 DST2(0); | |
499 | |
500 RGB(1); | |
501 DST2(1); | |
502 DST1(1); | |
503 | |
504 RGB(2); | |
505 DST1(2); | |
506 DST2(2); | |
507 | |
508 RGB(3); | |
509 DST2(3); | |
510 DST1(3); | |
511 EPILOG(8) | |
512 | |
513 PROLOG(yuv2rgb_c_4b_ordered_dither, uint8_t) | |
514 const uint8_t *d64= dither_8x8_73[y&7]; | |
515 const uint8_t *d128=dither_8x8_220[y&7]; | |
516 | |
517 #define DST1bpp4b(i,o) \ | |
518 Y = py_1[2*i]; \ | |
519 dst_1[2*i] = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]]; \ | |
520 Y = py_1[2*i+1]; \ | |
521 dst_1[2*i+1] = r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]]; | |
522 | |
523 #define DST2bpp4b(i,o) \ | |
524 Y = py_2[2*i]; \ | |
525 dst_2[2*i] = r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]]; \ | |
526 Y = py_2[2*i+1]; \ | |
527 dst_2[2*i+1] = r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]]; | |
528 | |
529 | |
530 RGB(0); | |
531 DST1bpp4b(0,0); | |
532 DST2bpp4b(0,0); | |
533 | |
534 RGB(1); | |
535 DST2bpp4b(1,2); | |
536 DST1bpp4b(1,2); | |
537 | |
538 RGB(2); | |
539 DST1bpp4b(2,4); | |
540 DST2bpp4b(2,4); | |
541 | |
542 RGB(3); | |
543 DST2bpp4b(3,6); | |
544 DST1bpp4b(3,6); | |
545 EPILOG(8) | |
546 | |
547 PROLOG(yuv2rgb_c_1_ordered_dither, uint8_t) | |
548 const uint8_t *d128=dither_8x8_220[y&7]; | |
549 char out_1=0, out_2=0; | |
550 g= c->table_gU[128] + c->table_gV[128]; | |
551 | |
552 #define DST1bpp1(i,o) \ | |
553 Y = py_1[2*i]; \ | |
554 out_1+= out_1 + g[Y+d128[0+o]]; \ | |
555 Y = py_1[2*i+1]; \ | |
556 out_1+= out_1 + g[Y+d128[1+o]]; | |
557 | |
558 #define DST2bpp1(i,o) \ | |
559 Y = py_2[2*i]; \ | |
560 out_2+= out_2 + g[Y+d128[8+o]]; \ | |
561 Y = py_2[2*i+1]; \ | |
562 out_2+= out_2 + g[Y+d128[9+o]]; | |
563 | |
564 DST1bpp1(0,0); | |
565 DST2bpp1(0,0); | |
566 | |
567 DST2bpp1(1,2); | |
568 DST1bpp1(1,2); | |
569 | |
570 DST1bpp1(2,4); | |
571 DST2bpp1(2,4); | |
572 | |
573 DST2bpp1(3,6); | |
574 DST1bpp1(3,6); | |
575 | |
576 dst_1[0]= out_1; | |
577 dst_2[0]= out_2; | |
578 EPILOG(1) | |
579 | |
580 SwsFunc yuv2rgb_get_func_ptr (SwsContext *c) | |
581 { | |
19333
4f5e2e0529b1
Do not assemble MMX, MMX2 or 3DNOW code unconditionally on X86 and X86_64.
diego
parents:
19206
diff
changeset
|
582 #if defined(HAVE_MMX2) || defined(HAVE_MMX) |
18861 | 583 if(c->flags & SWS_CPU_CAPS_MMX2){ |
584 switch(c->dstFormat){ | |
19872
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
585 case PIX_FMT_RGB32: return yuv420_rgb32_MMX2; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
586 case PIX_FMT_BGR24: return yuv420_rgb24_MMX2; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
587 case PIX_FMT_BGR565: return yuv420_rgb16_MMX2; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
588 case PIX_FMT_BGR555: return yuv420_rgb15_MMX2; |
18861 | 589 } |
590 } | |
591 if(c->flags & SWS_CPU_CAPS_MMX){ | |
592 switch(c->dstFormat){ | |
19872
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
593 case PIX_FMT_RGB32: return yuv420_rgb32_MMX; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
594 case PIX_FMT_BGR24: return yuv420_rgb24_MMX; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
595 case PIX_FMT_BGR565: return yuv420_rgb16_MMX; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
596 case PIX_FMT_BGR555: return yuv420_rgb15_MMX; |
18861 | 597 } |
598 } | |
599 #endif | |
600 #ifdef HAVE_MLIB | |
601 { | |
602 SwsFunc t= yuv2rgb_init_mlib(c); | |
603 if(t) return t; | |
604 } | |
605 #endif | |
606 #ifdef HAVE_ALTIVEC | |
607 if (c->flags & SWS_CPU_CAPS_ALTIVEC) | |
608 { | |
609 SwsFunc t = yuv2rgb_init_altivec(c); | |
610 if(t) return t; | |
611 } | |
612 #endif | |
613 | |
21981 | 614 av_log(c, AV_LOG_WARNING, "No accelerated colorspace conversion found\n"); |
18861 | 615 |
616 switch(c->dstFormat){ | |
19872
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
617 case PIX_FMT_BGR32: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
618 case PIX_FMT_RGB32: return yuv2rgb_c_32; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
619 case PIX_FMT_RGB24: return yuv2rgb_c_24_rgb; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
620 case PIX_FMT_BGR24: return yuv2rgb_c_24_bgr; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
621 case PIX_FMT_RGB565: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
622 case PIX_FMT_BGR565: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
623 case PIX_FMT_RGB555: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
624 case PIX_FMT_BGR555: return yuv2rgb_c_16; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
625 case PIX_FMT_RGB8: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
626 case PIX_FMT_BGR8: return yuv2rgb_c_8_ordered_dither; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
627 case PIX_FMT_RGB4: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
628 case PIX_FMT_BGR4: return yuv2rgb_c_4_ordered_dither; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
629 case PIX_FMT_RGB4_BYTE: |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
630 case PIX_FMT_BGR4_BYTE: return yuv2rgb_c_4b_ordered_dither; |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
631 case PIX_FMT_MONOBLACK: return yuv2rgb_c_1_ordered_dither; |
18861 | 632 default: |
633 assert(0); | |
634 } | |
635 return NULL; | |
636 } | |
637 | |
638 static int div_round (int dividend, int divisor) | |
639 { | |
640 if (dividend > 0) | |
641 return (dividend + (divisor>>1)) / divisor; | |
642 else | |
643 return -((-dividend + (divisor>>1)) / divisor); | |
644 } | |
645 | |
646 int yuv2rgb_c_init_tables (SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation) | |
647 { | |
19872
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
648 const int isRgb = isBGR(c->dstFormat); |
8e50cba9fe03
Remove the dependency of libswscale on img_format.h
lucabe
parents:
19431
diff
changeset
|
649 const int bpp = fmt_depth(c->dstFormat); |
18861 | 650 int i; |
651 uint8_t table_Y[1024]; | |
652 uint32_t *table_32 = 0; | |
653 uint16_t *table_16 = 0; | |
654 uint8_t *table_8 = 0; | |
655 uint8_t *table_332 = 0; | |
656 uint8_t *table_121 = 0; | |
657 uint8_t *table_1 = 0; | |
658 int entry_size = 0; | |
659 void *table_r = 0, *table_g = 0, *table_b = 0; | |
660 void *table_start; | |
661 | |
662 int64_t crv = inv_table[0]; | |
663 int64_t cbu = inv_table[1]; | |
664 int64_t cgu = -inv_table[2]; | |
665 int64_t cgv = -inv_table[3]; | |
666 int64_t cy = 1<<16; | |
667 int64_t oy = 0; | |
668 | |
669 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv); | |
670 if(!fullRange){ | |
671 cy= (cy*255) / 219; | |
672 oy= 16<<16; | |
22695 | 673 }else{ |
674 crv= (crv*224) / 255; | |
675 cbu= (cbu*224) / 255; | |
676 cgu= (cgu*224) / 255; | |
677 cgv= (cgv*224) / 255; | |
18861 | 678 } |
679 | |
680 cy = (cy *contrast )>>16; | |
681 crv= (crv*contrast * saturation)>>32; | |
682 cbu= (cbu*contrast * saturation)>>32; | |
683 cgu= (cgu*contrast * saturation)>>32; | |
684 cgv= (cgv*contrast * saturation)>>32; | |
685 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv); | |
686 oy -= 256*brightness; | |
687 | |
688 for (i = 0; i < 1024; i++) { | |
689 int j; | |
690 | |
691 j= (cy*(((i - 384)<<16) - oy) + (1<<31))>>32; | |
692 j = (j < 0) ? 0 : ((j > 255) ? 255 : j); | |
693 table_Y[i] = j; | |
694 } | |
695 | |
696 switch (bpp) { | |
697 case 32: | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
698 table_start= table_32 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t)); |
18861 | 699 |
700 entry_size = sizeof (uint32_t); | |
701 table_r = table_32 + 197; | |
702 table_b = table_32 + 197 + 685; | |
703 table_g = table_32 + 197 + 2*682; | |
704 | |
705 for (i = -197; i < 256+197; i++) | |
706 ((uint32_t *)table_r)[i] = table_Y[i+384] << (isRgb ? 16 : 0); | |
707 for (i = -132; i < 256+132; i++) | |
708 ((uint32_t *)table_g)[i] = table_Y[i+384] << 8; | |
709 for (i = -232; i < 256+232; i++) | |
710 ((uint32_t *)table_b)[i] = table_Y[i+384] << (isRgb ? 0 : 16); | |
711 break; | |
712 | |
713 case 24: | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
714 table_start= table_8 = av_malloc ((256 + 2*232) * sizeof (uint8_t)); |
18861 | 715 |
716 entry_size = sizeof (uint8_t); | |
717 table_r = table_g = table_b = table_8 + 232; | |
718 | |
719 for (i = -232; i < 256+232; i++) | |
720 ((uint8_t * )table_b)[i] = table_Y[i+384]; | |
721 break; | |
722 | |
723 case 15: | |
724 case 16: | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
725 table_start= table_16 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t)); |
18861 | 726 |
727 entry_size = sizeof (uint16_t); | |
728 table_r = table_16 + 197; | |
729 table_b = table_16 + 197 + 685; | |
730 table_g = table_16 + 197 + 2*682; | |
731 | |
732 for (i = -197; i < 256+197; i++) { | |
733 int j = table_Y[i+384] >> 3; | |
734 | |
735 if (isRgb) | |
736 j <<= ((bpp==16) ? 11 : 10); | |
737 | |
738 ((uint16_t *)table_r)[i] = j; | |
739 } | |
740 for (i = -132; i < 256+132; i++) { | |
741 int j = table_Y[i+384] >> ((bpp==16) ? 2 : 3); | |
742 | |
743 ((uint16_t *)table_g)[i] = j << 5; | |
744 } | |
745 for (i = -232; i < 256+232; i++) { | |
746 int j = table_Y[i+384] >> 3; | |
747 | |
748 if (!isRgb) | |
749 j <<= ((bpp==16) ? 11 : 10); | |
750 | |
751 ((uint16_t *)table_b)[i] = j; | |
752 } | |
753 break; | |
754 | |
755 case 8: | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
756 table_start= table_332 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t)); |
18861 | 757 |
758 entry_size = sizeof (uint8_t); | |
759 table_r = table_332 + 197; | |
760 table_b = table_332 + 197 + 685; | |
761 table_g = table_332 + 197 + 2*682; | |
762 | |
763 for (i = -197; i < 256+197; i++) { | |
764 int j = (table_Y[i+384 - 16] + 18)/36; | |
765 | |
766 if (isRgb) | |
767 j <<= 5; | |
768 | |
769 ((uint8_t *)table_r)[i] = j; | |
770 } | |
771 for (i = -132; i < 256+132; i++) { | |
772 int j = (table_Y[i+384 - 16] + 18)/36; | |
773 | |
774 if (!isRgb) | |
775 j <<= 1; | |
776 | |
777 ((uint8_t *)table_g)[i] = j << 2; | |
778 } | |
779 for (i = -232; i < 256+232; i++) { | |
780 int j = (table_Y[i+384 - 37] + 43)/85; | |
781 | |
782 if (!isRgb) | |
783 j <<= 6; | |
784 | |
785 ((uint8_t *)table_b)[i] = j; | |
786 } | |
787 break; | |
788 case 4: | |
789 case 4|128: | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
790 table_start= table_121 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t)); |
18861 | 791 |
792 entry_size = sizeof (uint8_t); | |
793 table_r = table_121 + 197; | |
794 table_b = table_121 + 197 + 685; | |
795 table_g = table_121 + 197 + 2*682; | |
796 | |
797 for (i = -197; i < 256+197; i++) { | |
798 int j = table_Y[i+384 - 110] >> 7; | |
799 | |
800 if (isRgb) | |
801 j <<= 3; | |
802 | |
803 ((uint8_t *)table_r)[i] = j; | |
804 } | |
805 for (i = -132; i < 256+132; i++) { | |
806 int j = (table_Y[i+384 - 37]+ 43)/85; | |
807 | |
808 ((uint8_t *)table_g)[i] = j << 1; | |
809 } | |
810 for (i = -232; i < 256+232; i++) { | |
811 int j =table_Y[i+384 - 110] >> 7; | |
812 | |
813 if (!isRgb) | |
814 j <<= 3; | |
815 | |
816 ((uint8_t *)table_b)[i] = j; | |
817 } | |
818 break; | |
819 | |
820 case 1: | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
821 table_start= table_1 = av_malloc (256*2 * sizeof (uint8_t)); |
18861 | 822 |
823 entry_size = sizeof (uint8_t); | |
824 table_g = table_1; | |
825 table_r = table_b = NULL; | |
826 | |
827 for (i = 0; i < 256+256; i++) { | |
828 int j = table_Y[i + 384 - 110]>>7; | |
829 | |
830 ((uint8_t *)table_g)[i] = j; | |
831 } | |
832 break; | |
833 | |
834 default: | |
835 table_start= NULL; | |
21981 | 836 av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp); |
18861 | 837 //free mem? |
838 return -1; | |
839 } | |
840 | |
841 for (i = 0; i < 256; i++) { | |
21757
51f84ed3251b
Add some other casts, to remove void pointers arithmetic
lucabe
parents:
20576
diff
changeset
|
842 c->table_rV[i] = (uint8_t *)table_r + entry_size * div_round (crv * (i-128), 76309); |
51f84ed3251b
Add some other casts, to remove void pointers arithmetic
lucabe
parents:
20576
diff
changeset
|
843 c->table_gU[i] = (uint8_t *)table_g + entry_size * div_round (cgu * (i-128), 76309); |
18861 | 844 c->table_gV[i] = entry_size * div_round (cgv * (i-128), 76309); |
21757
51f84ed3251b
Add some other casts, to remove void pointers arithmetic
lucabe
parents:
20576
diff
changeset
|
845 c->table_bU[i] = (uint8_t *)table_b + entry_size * div_round (cbu * (i-128), 76309); |
18861 | 846 } |
847 | |
19143
c4dac777b44c
Use libavutil in libswscale, and allow it to be built out of the mplayer tree
lucabe
parents:
18861
diff
changeset
|
848 av_free(c->yuvTable); |
18861 | 849 c->yuvTable= table_start; |
850 return 0; | |
851 } |