summaryrefslogtreecommitdiff
path: root/noncore/multimedia/opieplayer2/yuv2rgb.c
Unidiff
Diffstat (limited to 'noncore/multimedia/opieplayer2/yuv2rgb.c') (more/less context) (show whitespace changes)
-rw-r--r--noncore/multimedia/opieplayer2/yuv2rgb.c3160
1 files changed, 3160 insertions, 0 deletions
diff --git a/noncore/multimedia/opieplayer2/yuv2rgb.c b/noncore/multimedia/opieplayer2/yuv2rgb.c
new file mode 100644
index 0000000..d1d6627
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/yuv2rgb.c
@@ -0,0 +1,3160 @@
1/*
2 * yuv2rgb.c
3 *
4 * This file is part of xine, a unix video player.
5 *
6 * based on work from mpeg2dec:
7 * Copyright (C) 1999-2001 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
8 *
9 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
10 *
11 * mpeg2dec is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * mpeg2dec is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 * $Id$
26 */
27
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31#include <inttypes.h>
32
33#include "yuv2rgb.h"
34#include <xine/xineutils.h>
35
36
37static int prof_scale_line = -1;
38
39static scale_line_func_t find_scale_line_func(int step);
40
41
42const int32_t Inverse_Table_6_9[8][4] = {
43 {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
44 {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
45 {104597, 132201, 25675, 53279}, /* unspecified */
46 {104597, 132201, 25675, 53279}, /* reserved */
47 {104448, 132798, 24759, 53109}, /* FCC */
48 {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
49 {104597, 132201, 25675, 53279}, /* SMPTE 170M */
50 {117579, 136230, 16907, 35559} /* SMPTE 240M (1987) */
51};
52
53
54static void *my_malloc_aligned (size_t alignment, size_t size, void **chunk) {
55
56 char *pMem;
57
58 pMem = xine_xmalloc (size+alignment);
59
60 *chunk = pMem;
61
62 while ((int) pMem % alignment)
63 pMem++;
64
65 return pMem;
66}
67
68
69static int yuv2rgb_configure (yuv2rgb_t *this,
70 int source_width, int source_height,
71 int y_stride, int uv_stride,
72 int dest_width, int dest_height,
73 int rgb_stride) {
74 /*
75 printf ("yuv2rgb setup (%d x %d => %d x %d)\n", source_width, source_height,
76 dest_width, dest_height);
77 */
78 if (prof_scale_line == -1)
79 prof_scale_line = xine_profiler_allocate_slot("xshm scale line");
80
81 this->source_width = source_width;
82 this->source_height = source_height;
83 this->y_stride = y_stride;
84 this->uv_stride = uv_stride;
85 this->dest_width = dest_width;
86 this->dest_height = dest_height;
87 this->rgb_stride = rgb_stride;
88
89 if (this->y_chunk) {
90 free (this->y_chunk);
91 this->y_buffer = this->y_chunk = NULL;
92 }
93 if (this->u_chunk) {
94 free (this->u_chunk);
95 this->u_buffer = this->u_chunk = NULL;
96 }
97 if (this->v_chunk) {
98 free (this->v_chunk);
99 this->v_buffer = this->v_chunk = NULL;
100 }
101
102
103 this->step_dx = source_width * 32768 / dest_width;
104 this->step_dy = source_height * 32768 / dest_height;
105
106 this->scale_line = find_scale_line_func(this->step_dx);
107
108 if ((source_width == dest_width) && (source_height == dest_height)) {
109 this->do_scale = 0;
110
111 /*
112 * space for two y-lines (for yuv2rgb_mlib)
113 * u,v subsampled 2:1
114 */
115 this->y_buffer = my_malloc_aligned (16, 2*dest_width, &this->y_chunk);
116 if (!this->y_buffer)
117 return 0;
118 this->u_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->u_chunk);
119 if (!this->u_buffer)
120 return 0;
121 this->v_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->v_chunk);
122 if (!this->v_buffer)
123 return 0;
124
125 } else {
126 this->do_scale = 1;
127
128 /*
129 * space for two y-lines (for yuv2rgb_mlib)
130 * u,v subsampled 2:1
131 */
132 this->y_buffer = my_malloc_aligned (16, 2*dest_width, &this->y_chunk);
133 if (!this->y_buffer)
134 return 0;
135 this->u_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->u_chunk);
136 if (!this->u_buffer)
137 return 0;
138 this->v_buffer = my_malloc_aligned (16, (dest_width+1)/2, &this->v_chunk);
139 if (!this->v_buffer)
140 return 0;
141 }
142 return 1;
143}
144
145
146static void scale_line_gen (uint8_t *source, uint8_t *dest,
147 int width, int step) {
148
149 /*
150 * scales a yuv source row to a dest row, with interpolation
151 * (good quality, but slow)
152 */
153 int p1;
154 int p2;
155 int dx;
156
157 xine_profiler_start_count(prof_scale_line);
158
159 p1 = *source++;
160 p2 = *source++;
161 dx = 0;
162
163 /*
164 * the following code has been optimized by Scott Smith <ssmith@akamai.com>:
165 *
166 * ok now I have a meaningful optimization for yuv2rgb.c:scale_line_gen.
167 * it removes the loop from within the while() loop by separating it out
168 * into 3 cases: where you are enlarging the line (<32768), where you are
169 * between 50% and 100% of the original line (<=65536), and where you are
170 * shrinking it by a lot. anyways, I went from 200 delivered / 100+
171 * skipped to 200 delivered / 80 skipped for the enlarging case. I
172 * noticed when looking at the assembly that the compiler was able to
173 * unroll these while(width) loops, whereas before it was trying to
174 * unroll the while(dx>32768) loops. so the compiler is better able to
175 * deal with this code.
176 */
177
178
179 if (step < 32768) {
180 while (width) {
181 *dest = p1 + (((p2-p1) * dx)>>15);
182
183 dx += step;
184 if (dx > 32768) {
185 dx -= 32768;
186 p1 = p2;
187 p2 = *source++;
188 }
189
190 dest ++;
191 width --;
192 }
193 } else if (step <= 65536) {
194 while (width) {
195 *dest = p1 + (((p2-p1) * dx)>>15);
196
197 dx += step;
198 if (dx > 65536) {
199 dx -= 65536;
200 p1 = *source++;
201 p2 = *source++;
202 } else {
203 dx -= 32768;
204 p1 = p2;
205 p2 = *source++;
206 }
207
208 dest ++;
209 width --;
210 }
211 } else {
212 while (width) {
213 int offs;
214
215 *dest = p1 + (((p2-p1) * dx)>>15);
216
217 dx += step;
218 offs=((dx-1)>>15);
219 dx-=offs<<15;
220 source+=offs-2;
221 p1=*source++;
222 p2=*source++;
223 dest ++;
224 width --;
225 }
226 }
227 xine_profiler_stop_count(prof_scale_line);
228
229
230
231
232}
233
234/*
235 * Interpolates 16 output pixels from 15 source pixels using shifts.
236 * Useful for scaling a PAL mpeg2 dvd input source to 4:3 format on
237 * a monitor using square pixels.
238 * (720 x 576 ==> 768 x 576)
239 */
240static void scale_line_15_16 (uint8_t *source, uint8_t *dest,
241 int width, int step) {
242
243 int p1, p2;
244
245 xine_profiler_start_count(prof_scale_line);
246
247 while ((width -= 16) >= 0) {
248 p1 = source[0];
249 dest[0] = p1;
250 p2 = source[1];
251 dest[1] = (1*p1 + 7*p2) >> 3;
252 p1 = source[2];
253 dest[2] = (1*p2 + 7*p1) >> 3;
254 p2 = source[3];
255 dest[3] = (1*p1 + 3*p2) >> 2;
256 p1 = source[4];
257 dest[4] = (1*p2 + 3*p1) >> 2;
258 p2 = source[5];
259 dest[5] = (3*p1 + 5*p2) >> 3;
260 p1 = source[6];
261 dest[6] = (3*p2 + 5*p1) >> 3;
262 p2 = source[7];
263 dest[7] = (1*p1 + 1*p1) >> 1;
264 p1 = source[8];
265 dest[8] = (1*p2 + 1*p1) >> 1;
266 p2 = source[9];
267 dest[9] = (5*p1 + 3*p2) >> 3;
268 p1 = source[10];
269 dest[10] = (5*p2 + 3*p1) >> 3;
270 p2 = source[11];
271 dest[11] = (3*p1 + 1*p2) >> 2;
272 p1 = source[12];
273 dest[12] = (3*p2 + 1*p1) >> 2;
274 p2 = source[13];
275 dest[13] = (7*p1 + 1*p2) >> 3;
276 p1 = source[14];
277 dest[14] = (7*p2 + 1*p1) >> 3;
278 dest[15] = p1;
279 source += 15;
280 dest += 16;
281 }
282
283 if ((width += 16) <= 0) goto done;
284 *dest++ = source[0];
285 if (--width <= 0) goto done;
286 *dest++ = (1*source[0] + 7*source[1]) >> 3;
287 if (--width <= 0) goto done;
288 *dest++ = (1*source[1] + 7*source[2]) >> 3;
289 if (--width <= 0) goto done;
290 *dest++ = (1*source[2] + 3*source[3]) >> 2;
291 if (--width <= 0) goto done;
292 *dest++ = (1*source[3] + 3*source[4]) >> 2;
293 if (--width <= 0) goto done;
294 *dest++ = (3*source[4] + 5*source[5]) >> 3;
295 if (--width <= 0) goto done;
296 *dest++ = (3*source[5] + 5*source[6]) >> 3;
297 if (--width <= 0) goto done;
298 *dest++ = (1*source[6] + 1*source[7]) >> 1;
299 if (--width <= 0) goto done;
300 *dest++ = (1*source[7] + 1*source[8]) >> 1;
301 if (--width <= 0) goto done;
302 *dest++ = (5*source[8] + 3*source[9]) >> 3;
303 if (--width <= 0) goto done;
304 *dest++ = (5*source[9] + 3*source[10]) >> 3;
305 if (--width <= 0) goto done;
306 *dest++ = (3*source[10] + 1*source[11]) >> 2;
307 if (--width <= 0) goto done;
308 *dest++ = (3*source[11] + 1*source[12]) >> 2;
309 if (--width <= 0) goto done;
310 *dest++ = (7*source[12] + 1*source[13]) >> 3;
311 if (--width <= 0) goto done;
312 *dest++ = (7*source[13] + 1*source[14]) >> 3;
313 done:
314 xine_profiler_stop_count(prof_scale_line);
315}
316
317
318/*
319 * Interpolates 53 output pixels from 45 source pixels using shifts.
320 * Useful for scaling a NTSC mpeg2 dvd input source to 16:9 display
321 * resulution
322 * fullscreen resolution, or to 16:9 format on a monitor using square
323 * pixels.
324 * (720 x 480 ==> 848 x 480)
325 */
326static void scale_line_45_53 (uint8_t *source, uint8_t *dest,
327 int width, int step) {
328
329 int p1, p2;
330
331 xine_profiler_start_count(prof_scale_line);
332
333 while ((width -= 53) >= 0) {
334 p1 = source[0];
335 p2 = source[1];
336 dest[0] = p1;
337 dest[1] = (1*p1 + 7*p2) >> 3;
338 p1 = source[2];
339 dest[2] = (1*p2 + 3*p1) >> 2;
340 p2 = source[3];
341 dest[3] = (1*p1 + 1*p2) >> 1;
342 p1 = source[4];
343 dest[4] = (5*p2 + 3*p1) >> 3;
344 p2 = source[5];
345 dest[5] = (3*p1 + 1*p2) >> 2;
346 p1 = source[6];
347 dest[6] = (7*p2 + 1*p1) >> 3;
348 dest[7] = p1;
349 p2 = source[7];
350 dest[8] = (1*p1 + 3*p2) >> 2;
351 p1 = source[8];
352 dest[9] = (3*p2 + 5*p1) >> 3;
353 p2 = source[9];
354 dest[10] = (1*p1 + 1*p2) >> 1;
355 p1 = source[10];
356 dest[11] = (5*p2 + 3*p1) >> 3;
357 p2 = source[11];
358 dest[12] = (3*p1 + 1*p2) >> 2;
359 p1 = source[12];
360 dest[13] = p2;
361 dest[14] = (1*p2 + 7*p1) >> 3;
362 p2 = source[13];
363 dest[15] = (1*p1 + 3*p2) >> 2;
364 p1 = source[14];
365 dest[16] = (3*p2 + 5*p1) >> 3;
366 p2 = source[15];
367 dest[17] = (5*p1 + 3*p2) >> 3;
368 p1 = source[16];
369 dest[18] = (3*p2 + 1*p1) >> 2;
370 p2 = source[17];
371 dest[19] = (7*p1 + 1*p2) >> 3;
372 dest[20] = p2;
373 p1 = source[18];
374 dest[21] = (1*p2 + 7*p1) >> 3;
375 p2 = source[19];
376 dest[22] = (3*p1 + 5*p2) >> 3;
377 p1 = source[20];
378 dest[23] = (1*p2 + 1*p1) >> 1;
379 p2 = source[21];
380 dest[24] = (5*p1 + 3*p2) >> 3;
381 p1 = source[22];
382 dest[25] = (3*p2 + 1*p1) >> 2;
383 p2 = source[23];
384 dest[26] = (7*p1 + 1*p2) >> 3;
385 dest[27] = (1*p1 + 7*p2) >> 3;
386 p1 = source[24];
387 dest[28] = (1*p2 + 3*p1) >> 2;
388 p2 = source[25];
389 dest[29] = (3*p1 + 5*p2) >> 3;
390 p1 = source[26];
391 dest[30] = (1*p2 + 1*p1) >> 1;
392 p2 = source[27];
393 dest[31] = (5*p1 + 3*p2) >> 3;
394 p1 = source[28];
395 dest[32] = (7*p2 + 1*p1) >> 3;
396 p2 = source[29];
397 dest[33] = p1;
398 dest[34] = (1*p1 + 7*p2) >> 3;
399 p1 = source[30];
400 dest[35] = (1*p2 + 3*p1) >> 2;
401 p2 = source[31];
402 dest[36] = (3*p1 + 5*p2) >> 3;
403 p1 = source[32];
404 dest[37] = (5*p2 + 3*p1) >> 3;
405 p2 = source[33];
406 dest[38] = (3*p1 + 1*p2) >> 2;
407 p1 = source[34];
408 dest[39] = (7*p2 + 1*p1) >> 3;
409 dest[40] = p1;
410 p2 = source[35];
411 dest[41] = (1*p1 + 3*p2) >> 2;
412 p1 = source[36];
413 dest[42] = (3*p2 + 5*p1) >> 3;
414 p2 = source[37];
415 dest[43] = (1*p1 + 1*p2) >> 1;
416 p1 = source[38];
417 dest[44] = (5*p2 + 3*p1) >> 3;
418 p2 = source[39];
419 dest[45] = (3*p1 + 1*p2) >> 2;
420 p1 = source[40];
421 dest[46] = p2;
422 dest[47] = (1*p2 + 7*p1) >> 3;
423 p2 = source[41];
424 dest[48] = (1*p1 + 3*p2) >> 2;
425 p1 = source[42];
426 dest[49] = (3*p2 + 5*p1) >> 3;
427 p2 = source[43];
428 dest[50] = (1*p1 + 1*p2) >> 1;
429 p1 = source[44];
430 dest[51] = (3*p2 + 1*p1) >> 2;
431 p2 = source[45];
432 dest[52] = (7*p1 + 1*p2) >> 3;
433 source += 45;
434 dest += 53;
435 }
436
437 if ((width += 53) <= 0) goto done;
438 *dest++ = source[0];
439 if (--width <= 0) goto done;
440 *dest++ = (1*source[0] + 7*source[1]) >> 3;
441 if (--width <= 0) goto done;
442 *dest++ = (1*source[1] + 3*source[2]) >> 2;
443 if (--width <= 0) goto done;
444 *dest++ = (1*source[2] + 1*source[3]) >> 1;
445 if (--width <= 0) goto done;
446 *dest++ = (5*source[3] + 3*source[4]) >> 3;
447 if (--width <= 0) goto done;
448 *dest++ = (3*source[4] + 1*source[5]) >> 2;
449 if (--width <= 0) goto done;
450 *dest++ = (7*source[5] + 1*source[6]) >> 3;
451 if (--width <= 0) goto done;
452 *dest++ = source[6];
453 if (--width <= 0) goto done;
454 *dest++ = (1*source[6] + 3*source[7]) >> 2;
455 if (--width <= 0) goto done;
456 *dest++ = (3*source[7] + 5*source[8]) >> 3;
457 if (--width <= 0) goto done;
458 *dest++ = (1*source[8] + 1*source[9]) >> 1;
459 if (--width <= 0) goto done;
460 *dest++ = (5*source[9] + 3*source[10]) >> 3;
461 if (--width <= 0) goto done;
462 *dest++ = (3*source[10] + 1*source[11]) >> 2;
463 if (--width <= 0) goto done;
464 *dest++ = source[11];
465 if (--width <= 0) goto done;
466 *dest++ = (1*source[11] + 7*source[12]) >> 3;
467 if (--width <= 0) goto done;
468 *dest++ = (1*source[12] + 3*source[13]) >> 2;
469 if (--width <= 0) goto done;
470 *dest++ = (3*source[13] + 5*source[14]) >> 3;
471 if (--width <= 0) goto done;
472 *dest++ = (5*source[14] + 3*source[15]) >> 3;
473 if (--width <= 0) goto done;
474 *dest++ = (3*source[15] + 1*source[16]) >> 2;
475 if (--width <= 0) goto done;
476 *dest++ = (7*source[16] + 1*source[17]) >> 3;
477 if (--width <= 0) goto done;
478 *dest++ = source[17];
479 if (--width <= 0) goto done;
480 *dest++ = (1*source[17] + 7*source[18]) >> 3;
481 if (--width <= 0) goto done;
482 *dest++ = (3*source[18] + 5*source[19]) >> 3;
483 if (--width <= 0) goto done;
484 *dest++ = (1*source[19] + 1*source[20]) >> 1;
485 if (--width <= 0) goto done;
486 *dest++ = (5*source[20] + 3*source[21]) >> 3;
487 if (--width <= 0) goto done;
488 *dest++ = (3*source[21] + 1*source[22]) >> 2;
489 if (--width <= 0) goto done;
490 *dest++ = (7*source[22] + 1*source[23]) >> 3;
491 if (--width <= 0) goto done;
492 *dest++ = (1*source[22] + 7*source[23]) >> 3;
493 if (--width <= 0) goto done;
494 *dest++ = (1*source[23] + 3*source[24]) >> 2;
495 if (--width <= 0) goto done;
496 *dest++ = (3*source[24] + 5*source[25]) >> 3;
497 if (--width <= 0) goto done;
498 *dest++ = (1*source[25] + 1*source[26]) >> 1;
499 if (--width <= 0) goto done;
500 *dest++ = (5*source[26] + 3*source[27]) >> 3;
501 if (--width <= 0) goto done;
502 *dest++ = (7*source[27] + 1*source[28]) >> 3;
503 if (--width <= 0) goto done;
504 *dest++ = source[28];
505 if (--width <= 0) goto done;
506 *dest++ = (1*source[28] + 7*source[29]) >> 3;
507 if (--width <= 0) goto done;
508 *dest++ = (1*source[29] + 3*source[30]) >> 2;
509 if (--width <= 0) goto done;
510 *dest++ = (3*source[30] + 5*source[31]) >> 3;
511 if (--width <= 0) goto done;
512 *dest++ = (5*source[31] + 3*source[32]) >> 3;
513 if (--width <= 0) goto done;
514 *dest++ = (3*source[32] + 1*source[33]) >> 2;
515 if (--width <= 0) goto done;
516 *dest++ = (7*source[33] + 1*source[34]) >> 3;
517 if (--width <= 0) goto done;
518 *dest++ = source[34];
519 if (--width <= 0) goto done;
520 *dest++ = (1*source[34] + 3*source[35]) >> 2;
521 if (--width <= 0) goto done;
522 *dest++ = (3*source[35] + 5*source[36]) >> 3;
523 if (--width <= 0) goto done;
524 *dest++ = (1*source[36] + 1*source[37]) >> 1;
525 if (--width <= 0) goto done;
526 *dest++ = (5*source[37] + 3*source[38]) >> 3;
527 if (--width <= 0) goto done;
528 *dest++ = (3*source[38] + 1*source[39]) >> 2;
529 if (--width <= 0) goto done;
530 *dest++ = source[39];
531 if (--width <= 0) goto done;
532 *dest++ = (1*source[39] + 7*source[40]) >> 3;
533 if (--width <= 0) goto done;
534 *dest++ = (1*source[40] + 3*source[41]) >> 2;
535 if (--width <= 0) goto done;
536 *dest++ = (3*source[41] + 5*source[42]) >> 3;
537 if (--width <= 0) goto done;
538 *dest++ = (1*source[42] + 1*source[43]) >> 1;
539 if (--width <= 0) goto done;
540 *dest++ = (3*source[43] + 1*source[44]) >> 2;
541 done:
542
543 xine_profiler_stop_count(prof_scale_line);
544}
545
546
547/*
548 * Interpolates 64 output pixels from 45 source pixels using shifts.
549 * Useful for scaling a PAL mpeg2 dvd input source to 1024x768
550 * fullscreen resolution, or to 16:9 format on a monitor using square
551 * pixels.
552 * (720 x 576 ==> 1024 x 576)
553 */
554static void scale_line_45_64 (uint8_t *source, uint8_t *dest,
555 int width, int step) {
556
557 int p1, p2;
558
559 xine_profiler_start_count(prof_scale_line);
560
561 while ((width -= 64) >= 0) {
562 p1 = source[0];
563 p2 = source[1];
564 dest[0] = p1;
565 dest[1] = (1*p1 + 3*p2) >> 2;
566 p1 = source[2];
567 dest[2] = (5*p2 + 3*p1) >> 3;
568 p2 = source[3];
569 dest[3] = (7*p1 + 1*p2) >> 3;
570 dest[4] = (1*p1 + 3*p2) >> 2;
571 p1 = source[4];
572 dest[5] = (1*p2 + 1*p1) >> 1;
573 p2 = source[5];
574 dest[6] = (3*p1 + 1*p2) >> 2;
575 dest[7] = (1*p1 + 7*p2) >> 3;
576 p1 = source[6];
577 dest[8] = (3*p2 + 5*p1) >> 3;
578 p2 = source[7];
579 dest[9] = (5*p1 + 3*p2) >> 3;
580 p1 = source[8];
581 dest[10] = p2;
582 dest[11] = (1*p2 + 3*p1) >> 2;
583 p2 = source[9];
584 dest[12] = (5*p1 + 3*p2) >> 3;
585 p1 = source[10];
586 dest[13] = (7*p2 + 1*p1) >> 3;
587 dest[14] = (1*p2 + 7*p1) >> 3;
588 p2 = source[11];
589 dest[15] = (1*p1 + 1*p2) >> 1;
590 p1 = source[12];
591 dest[16] = (3*p2 + 1*p1) >> 2;
592 dest[17] = p1;
593 p2 = source[13];
594 dest[18] = (3*p1 + 5*p2) >> 3;
595 p1 = source[14];
596 dest[19] = (5*p2 + 3*p1) >> 3;
597 p2 = source[15];
598 dest[20] = p1;
599 dest[21] = (1*p1 + 3*p2) >> 2;
600 p1 = source[16];
601 dest[22] = (1*p2 + 1*p1) >> 1;
602 p2 = source[17];
603 dest[23] = (7*p1 + 1*p2) >> 3;
604 dest[24] = (1*p1 + 7*p2) >> 3;
605 p1 = source[18];
606 dest[25] = (3*p2 + 5*p1) >> 3;
607 p2 = source[19];
608 dest[26] = (3*p1 + 1*p2) >> 2;
609 dest[27] = p2;
610 p1 = source[20];
611 dest[28] = (3*p2 + 5*p1) >> 3;
612 p2 = source[21];
613 dest[29] = (5*p1 + 3*p2) >> 3;
614 p1 = source[22];
615 dest[30] = (7*p2 + 1*p1) >> 3;
616 dest[31] = (1*p2 + 3*p1) >> 2;
617 p2 = source[23];
618 dest[32] = (1*p1 + 1*p2) >> 1;
619 p1 = source[24];
620 dest[33] = (3*p2 + 1*p1) >> 2;
621 dest[34] = (1*p2 + 7*p1) >> 3;
622 p2 = source[25];
623 dest[35] = (3*p1 + 5*p2) >> 3;
624 p1 = source[26];
625 dest[36] = (3*p2 + 1*p1) >> 2;
626 p2 = source[27];
627 dest[37] = p1;
628 dest[38] = (1*p1 + 3*p2) >> 2;
629 p1 = source[28];
630 dest[39] = (5*p2 + 3*p1) >> 3;
631 p2 = source[29];
632 dest[40] = (7*p1 + 1*p2) >> 3;
633 dest[41] = (1*p1 + 7*p2) >> 3;
634 p1 = source[30];
635 dest[42] = (1*p2 + 1*p1) >> 1;
636 p2 = source[31];
637 dest[43] = (3*p1 + 1*p2) >> 2;
638 dest[44] = (1*p1 + 7*p2) >> 3;
639 p1 = source[32];
640 dest[45] = (3*p2 + 5*p1) >> 3;
641 p2 = source[33];
642 dest[46] = (5*p1 + 3*p2) >> 3;
643 p1 = source[34];
644 dest[47] = p2;
645 dest[48] = (1*p2 + 3*p1) >> 2;
646 p2 = source[35];
647 dest[49] = (1*p1 + 1*p2) >> 1;
648 p1 = source[36];
649 dest[50] = (7*p2 + 1*p1) >> 3;
650 dest[51] = (1*p2 + 7*p1) >> 3;
651 p2 = source[37];
652 dest[52] = (1*p1 + 1*p2) >> 1;
653 p1 = source[38];
654 dest[53] = (3*p2 + 1*p1) >> 2;
655 dest[54] = p1;
656 p2 = source[39];
657 dest[55] = (3*p1 + 5*p2) >> 3;
658 p1 = source[40];
659 dest[56] = (5*p2 + 3*p1) >> 3;
660 p2 = source[41];
661 dest[57] = (7*p1 + 1*p2) >> 3;
662 dest[58] = (1*p1 + 3*p2) >> 2;
663 p1 = source[42];
664 dest[59] = (1*p2 + 1*p1) >> 1;
665 p2 = source[43];
666 dest[60] = (7*p1 + 1*p2) >> 3;
667 dest[61] = (1*p1 + 7*p2) >> 3;
668 p1 = source[44];
669 dest[62] = (3*p2 + 5*p1) >> 3;
670 p2 = source[45];
671 dest[63] = (3*p1 + 1*p2) >> 2;
672 source += 45;
673 dest += 64;
674 }
675
676 if ((width += 64) <= 0) goto done;
677 *dest++ = source[0];
678 if (--width <= 0) goto done;
679 *dest++ = (1*source[0] + 3*source[1]) >> 2;
680 if (--width <= 0) goto done;
681 *dest++ = (5*source[1] + 3*source[2]) >> 3;
682 if (--width <= 0) goto done;
683 *dest++ = (7*source[2] + 1*source[3]) >> 3;
684 if (--width <= 0) goto done;
685 *dest++ = (1*source[2] + 3*source[3]) >> 2;
686 if (--width <= 0) goto done;
687 *dest++ = (1*source[3] + 1*source[4]) >> 1;
688 if (--width <= 0) goto done;
689 *dest++ = (3*source[4] + 1*source[5]) >> 2;
690 if (--width <= 0) goto done;
691 *dest++ = (1*source[4] + 7*source[5]) >> 3;
692 if (--width <= 0) goto done;
693 *dest++ = (3*source[5] + 5*source[6]) >> 3;
694 if (--width <= 0) goto done;
695 *dest++ = (5*source[6] + 3*source[7]) >> 3;
696 if (--width <= 0) goto done;
697 *dest++ = source[7];
698 if (--width <= 0) goto done;
699 *dest++ = (1*source[7] + 3*source[8]) >> 2;
700 if (--width <= 0) goto done;
701 *dest++ = (5*source[8] + 3*source[9]) >> 3;
702 if (--width <= 0) goto done;
703 *dest++ = (7*source[9] + 1*source[10]) >> 3;
704 if (--width <= 0) goto done;
705 *dest++ = (1*source[9] + 7*source[10]) >> 3;
706 if (--width <= 0) goto done;
707 *dest++ = (1*source[10] + 1*source[11]) >> 1;
708 if (--width <= 0) goto done;
709 *dest++ = (3*source[11] + 1*source[12]) >> 2;
710 if (--width <= 0) goto done;
711 *dest++ = source[12];
712 if (--width <= 0) goto done;
713 *dest++ = (3*source[12] + 5*source[13]) >> 3;
714 if (--width <= 0) goto done;
715 *dest++ = (5*source[13] + 3*source[14]) >> 3;
716 if (--width <= 0) goto done;
717 *dest++ = source[14];
718 if (--width <= 0) goto done;
719 *dest++ = (1*source[14] + 3*source[15]) >> 2;
720 if (--width <= 0) goto done;
721 *dest++ = (1*source[15] + 1*source[16]) >> 1;
722 if (--width <= 0) goto done;
723 *dest++ = (7*source[16] + 1*source[17]) >> 3;
724 if (--width <= 0) goto done;
725 *dest++ = (1*source[16] + 7*source[17]) >> 3;
726 if (--width <= 0) goto done;
727 *dest++ = (3*source[17] + 5*source[18]) >> 3;
728 if (--width <= 0) goto done;
729 *dest++ = (3*source[18] + 1*source[19]) >> 2;
730 if (--width <= 0) goto done;
731 *dest++ = source[19];
732 if (--width <= 0) goto done;
733 *dest++ = (3*source[19] + 5*source[20]) >> 3;
734 if (--width <= 0) goto done;
735 *dest++ = (5*source[20] + 3*source[21]) >> 3;
736 if (--width <= 0) goto done;
737 *dest++ = (7*source[21] + 1*source[22]) >> 3;
738 if (--width <= 0) goto done;
739 *dest++ = (1*source[21] + 3*source[22]) >> 2;
740 if (--width <= 0) goto done;
741 *dest++ = (1*source[22] + 1*source[23]) >> 1;
742 if (--width <= 0) goto done;
743 *dest++ = (3*source[23] + 1*source[24]) >> 2;
744 if (--width <= 0) goto done;
745 *dest++ = (1*source[23] + 7*source[24]) >> 3;
746 if (--width <= 0) goto done;
747 *dest++ = (3*source[24] + 5*source[25]) >> 3;
748 if (--width <= 0) goto done;
749 *dest++ = (3*source[25] + 1*source[26]) >> 2;
750 if (--width <= 0) goto done;
751 *dest++ = source[26];
752 if (--width <= 0) goto done;
753 *dest++ = (1*source[26] + 3*source[27]) >> 2;
754 if (--width <= 0) goto done;
755 *dest++ = (5*source[27] + 3*source[28]) >> 3;
756 if (--width <= 0) goto done;
757 *dest++ = (7*source[28] + 1*source[29]) >> 3;
758 if (--width <= 0) goto done;
759 *dest++ = (1*source[28] + 7*source[29]) >> 3;
760 if (--width <= 0) goto done;
761 *dest++ = (1*source[29] + 1*source[30]) >> 1;
762 if (--width <= 0) goto done;
763 *dest++ = (3*source[30] + 1*source[31]) >> 2;
764 if (--width <= 0) goto done;
765 *dest++ = (1*source[30] + 7*source[31]) >> 3;
766 if (--width <= 0) goto done;
767 *dest++ = (3*source[31] + 5*source[32]) >> 3;
768 if (--width <= 0) goto done;
769 *dest++ = (5*source[32] + 3*source[33]) >> 3;
770 if (--width <= 0) goto done;
771 *dest++ = source[33];
772 if (--width <= 0) goto done;
773 *dest++ = (1*source[33] + 3*source[34]) >> 2;
774 if (--width <= 0) goto done;
775 *dest++ = (1*source[34] + 1*source[35]) >> 1;
776 if (--width <= 0) goto done;
777 *dest++ = (7*source[35] + 1*source[36]) >> 3;
778 if (--width <= 0) goto done;
779 *dest++ = (1*source[35] + 7*source[36]) >> 3;
780 if (--width <= 0) goto done;
781 *dest++ = (1*source[36] + 1*source[37]) >> 1;
782 if (--width <= 0) goto done;
783 *dest++ = (3*source[37] + 1*source[38]) >> 2;
784 if (--width <= 0) goto done;
785 *dest++ = source[38];
786 if (--width <= 0) goto done;
787 *dest++ = (3*source[38] + 5*source[39]) >> 3;
788 if (--width <= 0) goto done;
789 *dest++ = (5*source[39] + 3*source[40]) >> 3;
790 if (--width <= 0) goto done;
791 *dest++ = (7*source[40] + 1*source[41]) >> 3;
792 if (--width <= 0) goto done;
793 *dest++ = (1*source[40] + 3*source[41]) >> 2;
794 if (--width <= 0) goto done;
795 *dest++ = (1*source[41] + 1*source[42]) >> 1;
796 if (--width <= 0) goto done;
797 *dest++ = (7*source[42] + 1*source[43]) >> 3;
798 if (--width <= 0) goto done;
799 *dest++ = (1*source[42] + 7*source[43]) >> 3;
800 if (--width <= 0) goto done;
801 *dest++ = (3*source[43] + 5*source[44]) >> 3;
802 done:
803
804 xine_profiler_stop_count(prof_scale_line);
805}
806
807
808/*
809 * Interpolates 16 output pixels from 9 source pixels using shifts.
810 * Useful for scaling a PAL mpeg2 dvd input source to 1280x1024 fullscreen
811 * (720 x 576 ==> 1280 x XXX)
812 */
813static void scale_line_9_16 (uint8_t *source, uint8_t *dest,
814 int width, int step) {
815
816 int p1, p2;
817
818 xine_profiler_start_count(prof_scale_line);
819
820 while ((width -= 16) >= 0) {
821 p1 = source[0];
822 p2 = source[1];
823 dest[0] = p1;
824 dest[1] = (1*p1 + 1*p2) >> 1;
825 p1 = source[2];
826 dest[2] = (7*p2 + 1*p1) >> 3;
827 dest[3] = (3*p2 + 5*p1) >> 3;
828 p2 = source[3];
829 dest[4] = (3*p1 + 1*p2) >> 2;
830 dest[5] = (1*p1 + 3*p2) >> 2;
831 p1 = source[4];
832 dest[6] = (5*p2 + 3*p1) >> 3;
833 dest[7] = (1*p2 + 7*p1) >> 3;
834 p2 = source[5];
835 dest[8] = (1*p1 + 1*p2) >> 1;
836 p1 = source[6];
837 dest[9] = p2;
838 dest[10] = (3*p2 + 5*p1) >> 3;
839 p2 = source[7];
840 dest[11] = (7*p1 + 1*p2) >> 3;
841 dest[12] = (1*p1 + 3*p2) >> 2;
842 p1 = source[8];
843 dest[13] = (3*p2 + 1*p1) >> 2;
844 dest[14] = (1*p2 + 7*p1) >> 3;
845 p2 = source[9];
846 dest[15] = (5*p1 + 3*p2) >> 3;
847 source += 9;
848 dest += 16;
849 }
850
851 if ((width += 16) <= 0) goto done;
852 *dest++ = source[0];
853 if (--width <= 0) goto done;
854 *dest++ = (1*source[0] + 1*source[1]) >> 1;
855 if (--width <= 0) goto done;
856 *dest++ = (7*source[1] + 1*source[2]) >> 3;
857 if (--width <= 0) goto done;
858 *dest++ = (3*source[1] + 5*source[2]) >> 3;
859 if (--width <= 0) goto done;
860 *dest++ = (3*source[2] + 1*source[3]) >> 2;
861 if (--width <= 0) goto done;
862 *dest++ = (1*source[2] + 3*source[3]) >> 2;
863 if (--width <= 0) goto done;
864 *dest++ = (5*source[3] + 3*source[4]) >> 3;
865 if (--width <= 0) goto done;
866 *dest++ = (1*source[3] + 7*source[4]) >> 3;
867 if (--width <= 0) goto done;
868 *dest++ = (1*source[4] + 1*source[5]) >> 1;
869 if (--width <= 0) goto done;
870 *dest++ = source[5];
871 if (--width <= 0) goto done;
872 *dest++ = (3*source[5] + 5*source[6]) >> 3;
873 if (--width <= 0) goto done;
874 *dest++ = (7*source[6] + 1*source[7]) >> 3;
875 if (--width <= 0) goto done;
876 *dest++ = (1*source[6] + 3*source[7]) >> 2;
877 if (--width <= 0) goto done;
878 *dest++ = (3*source[7] + 1*source[8]) >> 2;
879 if (--width <= 0) goto done;
880 *dest++ = (1*source[7] + 7*source[8]) >> 3;
881done:
882 xine_profiler_stop_count(prof_scale_line);
883}
884
885
886/*
887 * Interpolates 12 output pixels from 11 source pixels using shifts.
888 * Useful for scaling a PAL vcd input source to 4:3 display format.
889 */
890static void scale_line_11_12 (uint8_t *source, uint8_t *dest,
891 int width, int step) {
892
893 int p1, p2;
894
895 xine_profiler_start_count(prof_scale_line);
896
897 while ((width -= 12) >= 0) {
898 p1 = source[0];
899 p2 = source[1];
900 dest[0] = p1;
901 dest[1] = (1*p1 + 7*p2) >> 3;
902 p1 = source[2];
903 dest[2] = (1*p2 + 7*p1) >> 3;
904 p2 = source[3];
905 dest[3] = (1*p1 + 3*p2) >> 2;
906 p1 = source[4];
907 dest[4] = (3*p2 + 5*p1) >> 3;
908 p2 = source[5];
909 dest[5] = (3*p1 + 5*p2) >> 3;
910 p1 = source[6];
911 dest[6] = (1*p2 + 1*p1) >> 1;
912 p2 = source[7];
913 dest[7] = (5*p1 + 3*p2) >> 3;
914 p1 = source[8];
915 dest[8] = (5*p2 + 3*p1) >> 3;
916 p2 = source[9];
917 dest[9] = (3*p1 + 1*p2) >> 2;
918 p1 = source[10];
919 dest[10] = (7*p2 + 1*p1) >> 3;
920 p2 = source[11];
921 dest[11] = (7*p1 + 1*p2) >> 3;
922 source += 11;
923 dest += 12;
924 }
925
926 if ((width += 12) <= 0) goto done;
927 *dest++ = source[0];
928 if (--width <= 0) goto done;
929 *dest++ = (1*source[0] + 7*source[1]) >> 3;
930 if (--width <= 0) goto done;
931 *dest++ = (1*source[1] + 7*source[2]) >> 3;
932 if (--width <= 0) goto done;
933 *dest++ = (1*source[2] + 3*source[3]) >> 2;
934 if (--width <= 0) goto done;
935 *dest++ = (3*source[3] + 5*source[4]) >> 3;
936 if (--width <= 0) goto done;
937 *dest++ = (3*source[4] + 5*source[5]) >> 3;
938 if (--width <= 0) goto done;
939 *dest++ = (1*source[5] + 1*source[6]) >> 1;
940 if (--width <= 0) goto done;
941 *dest++ = (5*source[6] + 3*source[7]) >> 3;
942 if (--width <= 0) goto done;
943 *dest++ = (5*source[7] + 3*source[8]) >> 3;
944 if (--width <= 0) goto done;
945 *dest++ = (3*source[8] + 1*source[9]) >> 2;
946 if (--width <= 0) goto done;
947 *dest++ = (7*source[9] + 1*source[10]) >> 3;
948done:
949
950 xine_profiler_stop_count(prof_scale_line);
951}
952
953
954/*
955 * Interpolates 24 output pixels from 11 source pixels using shifts.
956 * Useful for scaling a PAL vcd input source to 4:3 display format
957 * at 2*zoom.
958 */
959static void scale_line_11_24 (uint8_t *source, uint8_t *dest,
960 int width, int step) {
961
962 int p1, p2;
963
964 xine_profiler_start_count(prof_scale_line);
965
966 while ((width -= 24) >= 0) {
967 p1 = source[0];
968 p2 = source[1];
969 dest[0] = p1;
970 dest[1] = (1*p1 + 1*p2) >> 1;
971 dest[2] = (1*p1 + 7*p2) >> 3;
972 p1 = source[2];
973 dest[3] = (5*p2 + 3*p1) >> 3;
974 dest[4] = (1*p2 + 7*p1) >> 3;
975 p2 = source[3];
976 dest[5] = (3*p1 + 1*p2) >> 2;
977 dest[6] = (1*p1 + 3*p2) >> 2;
978 p1 = source[4];
979 dest[7] = (3*p2 + 1*p1) >> 2;
980 dest[8] = (3*p2 + 5*p1) >> 3;
981 p2 = source[5];
982 dest[9] = (7*p1 + 1*p2) >> 3;
983 dest[10] = (3*p1 + 5*p2) >> 3;
984 p1 = source[6];
985 dest[11] = p2;
986 dest[12] = (1*p2 + 1*p1) >> 1;
987 dest[13] = p1;
988 p2 = source[7];
989 dest[14] = (5*p1 + 3*p2) >> 3;
990 dest[15] = (1*p1 + 7*p2) >> 3;
991 p1 = source[8];
992 dest[16] = (5*p2 + 3*p1) >> 3;
993 dest[17] = (1*p2 + 3*p1) >> 2;
994 p2 = source[9];
995 dest[18] = (3*p1 + 1*p2) >> 2;
996 dest[19] = (1*p1 + 3*p2) >> 2;
997 p1 = source[10];
998 dest[20] = (7*p2 + 1*p1) >> 3;
999 dest[21] = (3*p2 + 5*p1) >> 3;
1000 p2 = source[11];
1001 dest[22] = (7*p1 + 1*p2) >> 3;
1002 dest[23] = (1*p1 + 1*p2) >> 1;
1003 source += 11;
1004 dest += 24;
1005 }
1006
1007 if ((width += 24) <= 0) goto done;
1008 *dest++ = source[0];
1009 if (--width <= 0) goto done;
1010 *dest++ = (1*source[0] + 1*source[1]) >> 1;
1011 if (--width <= 0) goto done;
1012 *dest++ = (1*source[0] + 7*source[1]) >> 3;
1013 if (--width <= 0) goto done;
1014 *dest++ = (5*source[1] + 3*source[2]) >> 3;
1015 if (--width <= 0) goto done;
1016 *dest++ = (1*source[1] + 7*source[2]) >> 3;
1017 if (--width <= 0) goto done;
1018 *dest++ = (3*source[2] + 1*source[3]) >> 2;
1019 if (--width <= 0) goto done;
1020 *dest++ = (1*source[2] + 3*source[3]) >> 2;
1021 if (--width <= 0) goto done;
1022 *dest++ = (3*source[3] + 1*source[4]) >> 2;
1023 if (--width <= 0) goto done;
1024 *dest++ = (3*source[3] + 5*source[4]) >> 3;
1025 if (--width <= 0) goto done;
1026 *dest++ = (7*source[4] + 1*source[5]) >> 3;
1027 if (--width <= 0) goto done;
1028 *dest++ = (3*source[4] + 5*source[5]) >> 3;
1029 if (--width <= 0) goto done;
1030 *dest++ = source[5];
1031 if (--width <= 0) goto done;
1032 *dest++ = (1*source[5] + 1*source[6]) >> 1;
1033 if (--width <= 0) goto done;
1034 *dest++ = source[6];
1035 if (--width <= 0) goto done;
1036 *dest++ = (5*source[6] + 3*source[7]) >> 3;
1037 if (--width <= 0) goto done;
1038 *dest++ = (1*source[6] + 7*source[7]) >> 3;
1039 if (--width <= 0) goto done;
1040 *dest++ = (5*source[7] + 3*source[8]) >> 3;
1041 if (--width <= 0) goto done;
1042 *dest++ = (1*source[7] + 3*source[8]) >> 2;
1043 if (--width <= 0) goto done;
1044 *dest++ = (3*source[8] + 1*source[9]) >> 2;
1045 if (--width <= 0) goto done;
1046 *dest++ = (1*source[8] + 3*source[9]) >> 2;
1047 if (--width <= 0) goto done;
1048 *dest++ = (7*source[9] + 1*source[10]) >> 3;
1049 if (--width <= 0) goto done;
1050 *dest++ = (3*source[9] + 5*source[10]) >> 3;
1051 if (--width <= 0) goto done;
1052 *dest++ = (7*source[10] + 1*source[11]) >> 3;
1053done:
1054
1055 xine_profiler_stop_count(prof_scale_line);
1056}
1057
1058
1059/*
1060 * Interpolates 8 output pixels from 5 source pixels using shifts.
1061 * Useful for scaling a PAL svcd input source to 4:3 display format.
1062 */
1063static void scale_line_5_8 (uint8_t *source, uint8_t *dest,
1064 int width, int step) {
1065
1066 int p1, p2;
1067
1068 xine_profiler_start_count(prof_scale_line);
1069
1070 while ((width -= 8) >= 0) {
1071 p1 = source[0];
1072 p2 = source[1];
1073 dest[0] = p1;
1074 dest[1] = (3*p1 + 5*p2) >> 3;
1075 p1 = source[2];
1076 dest[2] = (3*p2 + 1*p1) >> 2;
1077 dest[3] = (1*p2 + 7*p1) >> 3;
1078 p2 = source[3];
1079 dest[4] = (1*p1 + 1*p2) >> 1;
1080 p1 = source[4];
1081 dest[5] = (7*p2 + 1*p1) >> 3;
1082 dest[6] = (1*p2 + 3*p1) >> 2;
1083 p2 = source[5];
1084 dest[7] = (5*p1 + 3*p2) >> 3;
1085 source += 5;
1086 dest += 8;
1087 }
1088
1089 if ((width += 8) <= 0) goto done;
1090 *dest++ = source[0];
1091 if (--width <= 0) goto done;
1092 *dest++ = (3*source[0] + 5*source[1]) >> 3;
1093 if (--width <= 0) goto done;
1094 *dest++ = (3*source[1] + 1*source[2]) >> 2;
1095 if (--width <= 0) goto done;
1096 *dest++ = (1*source[1] + 7*source[2]) >> 3;
1097 if (--width <= 0) goto done;
1098 *dest++ = (1*source[2] + 1*source[3]) >> 1;
1099 if (--width <= 0) goto done;
1100 *dest++ = (7*source[3] + 1*source[4]) >> 3;
1101 if (--width <= 0) goto done;
1102 *dest++ = (1*source[3] + 3*source[4]) >> 2;
1103done:
1104
1105 xine_profiler_stop_count(prof_scale_line);
1106}
1107
1108
1109/*
1110 * Interpolates 4 output pixels from 3 source pixels using shifts.
1111 * Useful for scaling a NTSC svcd input source to 4:3 display format.
1112 */
1113static void scale_line_3_4 (uint8_t *source, uint8_t *dest,
1114 int width, int step) {
1115
1116 int p1, p2;
1117
1118 xine_profiler_start_count(prof_scale_line);
1119
1120 while ((width -= 4) >= 0) {
1121 p1 = source[0];
1122 p2 = source[1];
1123 dest[0] = p1;
1124 dest[1] = (1*p1 + 3*p2) >> 2;
1125 p1 = source[2];
1126 dest[2] = (1*p2 + 1*p1) >> 1;
1127 p2 = source[3];
1128 dest[3] = (3*p1 + 1*p2) >> 2;
1129 source += 3;
1130 dest += 4;
1131 }
1132
1133 if ((width += 4) <= 0) goto done;
1134 *dest++ = source[0];
1135 if (--width <= 0) goto done;
1136 *dest++ = (1*source[0] + 3*source[1]) >> 2;
1137 if (--width <= 0) goto done;
1138 *dest++ = (1*source[1] + 1*source[2]) >> 1;
1139done:
1140
1141 xine_profiler_stop_count(prof_scale_line);
1142}
1143
1144
1145/* Interpolate 2 output pixels from one source pixel. */
1146
1147static void scale_line_1_2 (uint8_t *source, uint8_t *dest,
1148 int width, int step) {
1149 int p1, p2;
1150
1151 xine_profiler_start_count(prof_scale_line);
1152
1153 p1 = *source;
1154 while ((width -= 4) >= 0) {
1155 *dest++ = p1;
1156 p2 = *++source;
1157 *dest++ = (p1 + p2) >> 1;
1158 *dest++ = p2;
1159 p1 = *++source;
1160 *dest++ = (p2 + p1) >> 1;
1161 }
1162
1163 if ((width += 4) <= 0) goto done;
1164 *dest++ = source[0];
1165 if (--width <= 0) goto done;
1166 *dest++ = (source[0] + source[1]) >> 1;
1167 if (--width <= 0) goto done;
1168 *dest++ = source[1];
1169 done:
1170
1171 xine_profiler_stop_count(prof_scale_line);
1172}
1173
1174
1175/*
1176 * Scale line with no horizontal scaling. For NTSC mpeg2 dvd input in
1177 * 4:3 output format (720x480 -> 720x540)
1178 */
1179static void scale_line_1_1 (uint8_t *source, uint8_t *dest,
1180 int width, int step) {
1181
1182 xine_profiler_start_count(prof_scale_line);
1183 xine_fast_memcpy(dest, source, width);
1184 xine_profiler_stop_count(prof_scale_line);
1185}
1186
1187
1188static scale_line_func_t find_scale_line_func(int step) {
1189 static struct {
1190 int src_step;
1191 int dest_step;
1192 scale_line_func_tfunc;
1193 char *desc;
1194 } scale_line[] = {
1195 { 15, 16, scale_line_15_16, "dvd 4:3(pal)" },
1196 { 45, 64, scale_line_45_64, "dvd 16:9(pal), fullscreen(1024x768)" },
1197 { 9, 16, scale_line_9_16, "dvd fullscreen(1280x1024)" },
1198 { 45, 53, scale_line_45_53, "dvd 16:9(ntsc)" },
1199 { 11, 12, scale_line_11_12, "vcd 4:3(pal)" },
1200 { 11, 24, scale_line_11_24, "vcd 4:3(pal) 2*zoom" },
1201 { 5, 8, scale_line_5_8, "svcd 4:3(pal)" },
1202 { 3, 4, scale_line_3_4, "svcd 4:3(ntsc)" },
1203 { 1, 2, scale_line_1_2, "2*zoom" },
1204 { 1, 1, scale_line_1_1, "non-scaled" },
1205 };
1206 int i;
1207
1208 for (i = 0; i < sizeof(scale_line)/sizeof(scale_line[0]); i++) {
1209 if (step == scale_line[i].src_step*32768/scale_line[i].dest_step) {
1210 printf("yuv2rgb: using %s optimized scale_line\n", scale_line[i].desc);
1211 return scale_line[i].func;
1212 }
1213 }
1214 printf("yuv2rgb: using generic scale_line with interpolation\n");
1215 return scale_line_gen;
1216
1217}
1218
1219
1220static void scale_line_2 (uint8_t *source, uint8_t *dest,
1221 int width, int step) {
1222 int p1;
1223 int p2;
1224 int dx;
1225
1226 p1 = *source; source+=2;
1227 p2 = *source; source+=2;
1228 dx = 0;
1229
1230 while (width) {
1231
1232 *dest = (p1 * (32768 - dx) + p2 * dx) / 32768;
1233
1234 dx += step;
1235 while (dx > 32768) {
1236 dx -= 32768;
1237 p1 = p2;
1238 p2 = *source;
1239 source+=2;
1240 }
1241
1242 dest ++;
1243 width --;
1244 }
1245}
1246
1247static void scale_line_4 (uint8_t *source, uint8_t *dest,
1248 int width, int step) {
1249 int p1;
1250 int p2;
1251 int dx;
1252
1253 p1 = *source; source+=4;
1254 p2 = *source; source+=4;
1255 dx = 0;
1256
1257 while (width) {
1258
1259 *dest = (p1 * (32768 - dx) + p2 * dx) / 32768;
1260
1261 dx += step;
1262 while (dx > 32768) {
1263 dx -= 32768;
1264 p1 = p2;
1265 p2 = *source;
1266 source+=4;
1267 }
1268
1269 dest ++;
1270 width --;
1271 }
1272}
1273
1274
1275 #define RGB(i) \
1276 U = pu[i]; \
1277 V = pv[i]; \
1278 r = this->table_rV[V]; \
1279 g = (void *) (((uint8_t *)this->table_gU[U]) + this->table_gV[V]);\
1280 b = this->table_bU[U];
1281
1282 #define DST1(i) \
1283 Y = py_1[2*i]; \
1284 dst_1[2*i] = r[Y] + g[Y] + b[Y];\
1285 Y = py_1[2*i+1]; \
1286 dst_1[2*i+1] = r[Y] + g[Y] + b[Y];
1287
1288 #define DST2(i) \
1289 Y = py_2[2*i]; \
1290 dst_2[2*i] = r[Y] + g[Y] + b[Y];\
1291 Y = py_2[2*i+1]; \
1292 dst_2[2*i+1] = r[Y] + g[Y] + b[Y];
1293
1294 #define DST1RGB(i) \
1295 Y = py_1[2*i]; \
1296 dst_1[6*i] = r[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = b[Y];\
1297 Y = py_1[2*i+1]; \
1298 dst_1[6*i+3] = r[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = b[Y];
1299
1300 #define DST2RGB(i) \
1301 Y = py_2[2*i]; \
1302 dst_2[6*i] = r[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = b[Y];\
1303 Y = py_2[2*i+1]; \
1304 dst_2[6*i+3] = r[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = b[Y];
1305
1306 #define DST1BGR(i) \
1307 Y = py_1[2*i]; \
1308 dst_1[6*i] = b[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = r[Y];\
1309 Y = py_1[2*i+1]; \
1310 dst_1[6*i+3] = b[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = r[Y];
1311
1312 #define DST2BGR(i) \
1313 Y = py_2[2*i]; \
1314 dst_2[6*i] = b[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = r[Y];\
1315 Y = py_2[2*i+1]; \
1316 dst_2[6*i+3] = b[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = r[Y];
1317
1318 #define DST1CMAP(i) \
1319 Y = py_1[2*i]; \
1320 dst_1[2*i] = this->cmap[r[Y] + g[Y] + b[Y]]; \
1321 Y = py_1[2*i+1]; \
1322 dst_1[2*i+1] = this->cmap[r[Y] + g[Y] + b[Y]];
1323
1324 #define DST2CMAP(i) \
1325 Y = py_2[2*i]; \
1326 dst_2[2*i] = this->cmap[r[Y] + g[Y] + b[Y]]; \
1327 Y = py_2[2*i+1]; \
1328 dst_2[2*i+1] = this->cmap[r[Y] + g[Y] + b[Y]];
1329
1330static void yuv2rgb_c_32 (yuv2rgb_t *this, uint8_t * _dst,
1331 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
1332{
1333 int U, V, Y;
1334 uint8_t * py_1, * py_2, * pu, * pv;
1335 uint32_t * r, * g, * b;
1336 uint32_t * dst_1, * dst_2;
1337 int width, height, dst_height;
1338 int dy;
1339
1340 if (this->do_scale) {
1341 scale_line_func_t scale_line = this->scale_line;
1342
1343 scale_line (_pu, this->u_buffer,
1344 this->dest_width >> 1, this->step_dx);
1345 scale_line (_pv, this->v_buffer,
1346 this->dest_width >> 1, this->step_dx);
1347 scale_line (_py, this->y_buffer,
1348 this->dest_width, this->step_dx);
1349
1350 dy = 0;
1351 dst_height = this->dest_height;
1352
1353 for (height = 0;; ) {
1354 dst_1 = (uint32_t*)_dst;
1355 py_1 = this->y_buffer;
1356 pu = this->u_buffer;
1357 pv = this->v_buffer;
1358
1359 width = this->dest_width >> 3;
1360
1361 do {
1362 RGB(0);
1363 DST1(0);
1364
1365 RGB(1);
1366 DST1(1);
1367
1368 RGB(2);
1369 DST1(2);
1370
1371 RGB(3);
1372 DST1(3);
1373
1374 pu += 4;
1375 pv += 4;
1376 py_1 += 8;
1377 dst_1 += 8;
1378 } while (--width);
1379
1380 dy += this->step_dy;
1381 _dst += this->rgb_stride;
1382
1383 while (--dst_height > 0 && dy < 32768) {
1384
1385 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*4);
1386
1387 dy += this->step_dy;
1388 _dst += this->rgb_stride;
1389 }
1390
1391 if (dst_height <= 0)
1392 break;
1393
1394 do {
1395 dy -= 32768;
1396 _py += this->y_stride;
1397
1398 scale_line (_py, this->y_buffer,
1399 this->dest_width, this->step_dx);
1400
1401 if (height & 1) {
1402 _pu += this->uv_stride;
1403 _pv += this->uv_stride;
1404
1405 scale_line (_pu, this->u_buffer,
1406 this->dest_width >> 1, this->step_dx);
1407 scale_line (_pv, this->v_buffer,
1408 this->dest_width >> 1, this->step_dx);
1409
1410 }
1411 height++;
1412 } while( dy>=32768);
1413 }
1414 } else {
1415 height = this->source_height >> 1;
1416 do {
1417 dst_1 = (uint32_t*)_dst;
1418 dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
1419 py_1 = _py;
1420 py_2 = _py + this->y_stride;
1421 pu = _pu;
1422 pv = _pv;
1423
1424 width = this->source_width >> 3;
1425 do {
1426 RGB(0);
1427 DST1(0);
1428 DST2(0);
1429
1430 RGB(1);
1431 DST2(1);
1432 DST1(1);
1433
1434 RGB(2);
1435 DST1(2);
1436 DST2(2);
1437
1438 RGB(3);
1439 DST2(3);
1440 DST1(3);
1441
1442 pu += 4;
1443 pv += 4;
1444 py_1 += 8;
1445 py_2 += 8;
1446 dst_1 += 8;
1447 dst_2 += 8;
1448 } while (--width);
1449
1450 _dst += 2 * this->rgb_stride;
1451 _py += 2 * this->y_stride;
1452 _pu += this->uv_stride;
1453 _pv += this->uv_stride;
1454
1455 } while (--height);
1456 }
1457}
1458
1459/* This is very near from the yuv2rgb_c_32 code */
1460static void yuv2rgb_c_24_rgb (yuv2rgb_t *this, uint8_t * _dst,
1461 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
1462{
1463 int U, V, Y;
1464 uint8_t * py_1, * py_2, * pu, * pv;
1465 uint8_t * r, * g, * b;
1466 uint8_t * dst_1, * dst_2;
1467 int width, height, dst_height;
1468 int dy;
1469
1470 if (this->do_scale) {
1471
1472 scale_line_func_t scale_line = this->scale_line;
1473
1474 scale_line (_pu, this->u_buffer,
1475 this->dest_width >> 1, this->step_dx);
1476 scale_line (_pv, this->v_buffer,
1477 this->dest_width >> 1, this->step_dx);
1478 scale_line (_py, this->y_buffer,
1479 this->dest_width, this->step_dx);
1480
1481 dy = 0;
1482 dst_height = this->dest_height;
1483
1484 for (height = 0;; ) {
1485 dst_1 = _dst;
1486 py_1 = this->y_buffer;
1487 pu = this->u_buffer;
1488 pv = this->v_buffer;
1489
1490 width = this->dest_width >> 3;
1491
1492 do {
1493 RGB(0);
1494 DST1RGB(0);
1495
1496 RGB(1);
1497 DST1RGB(1);
1498
1499 RGB(2);
1500 DST1RGB(2);
1501
1502 RGB(3);
1503 DST1RGB(3);
1504
1505 pu += 4;
1506 pv += 4;
1507 py_1 += 8;
1508 dst_1 += 24;
1509 } while (--width);
1510
1511 dy += this->step_dy;
1512 _dst += this->rgb_stride;
1513
1514 while (--dst_height > 0 && dy < 32768) {
1515
1516 xine_fast_memcpy (_dst, _dst-this->rgb_stride, this->dest_width*3);
1517
1518 dy += this->step_dy;
1519 _dst += this->rgb_stride;
1520 }
1521
1522 if (dst_height <= 0)
1523 break;
1524
1525 do {
1526 dy -= 32768;
1527 _py += this->y_stride;
1528
1529 scale_line (_py, this->y_buffer,
1530 this->dest_width, this->step_dx);
1531
1532 if (height & 1) {
1533 _pu += this->uv_stride;
1534 _pv += this->uv_stride;
1535
1536 scale_line (_pu, this->u_buffer,
1537 this->dest_width >> 1, this->step_dx);
1538 scale_line (_pv, this->v_buffer,
1539 this->dest_width >> 1, this->step_dx);
1540
1541 }
1542 height++;
1543 } while (dy>=32768);
1544 }
1545 } else {
1546 height = this->source_height >> 1;
1547 do {
1548 dst_1 = _dst;
1549 dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
1550 py_1 = _py;
1551 py_2 = _py + this->y_stride;
1552 pu = _pu;
1553 pv = _pv;
1554
1555 width = this->source_width >> 3;
1556 do {
1557 RGB(0);
1558 DST1RGB(0);
1559 DST2RGB(0);
1560
1561 RGB(1);
1562 DST2RGB(1);
1563 DST1RGB(1);
1564
1565 RGB(2);
1566 DST1RGB(2);
1567 DST2RGB(2);
1568
1569 RGB(3);
1570 DST2RGB(3);
1571 DST1RGB(3);
1572
1573 pu += 4;
1574 pv += 4;
1575 py_1 += 8;
1576 py_2 += 8;
1577 dst_1 += 24;
1578 dst_2 += 24;
1579 } while (--width);
1580
1581 _dst += 2 * this->rgb_stride;
1582 _py += 2 * this->y_stride;
1583 _pu += this->uv_stride;
1584 _pv += this->uv_stride;
1585
1586 } while (--height);
1587 }
1588}
1589
1590/* only trivial mods from yuv2rgb_c_24_rgb */
1591static void yuv2rgb_c_24_bgr (yuv2rgb_t *this, uint8_t * _dst,
1592 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
1593{
1594 int U, V, Y;
1595 uint8_t * py_1, * py_2, * pu, * pv;
1596 uint8_t * r, * g, * b;
1597 uint8_t * dst_1, * dst_2;
1598 int width, height, dst_height;
1599 int dy;
1600
1601 if (this->do_scale) {
1602
1603 scale_line_func_t scale_line = this->scale_line;
1604
1605 scale_line (_pu, this->u_buffer,
1606 this->dest_width >> 1, this->step_dx);
1607 scale_line (_pv, this->v_buffer,
1608 this->dest_width >> 1, this->step_dx);
1609 scale_line (_py, this->y_buffer,
1610 this->dest_width, this->step_dx);
1611
1612 dy = 0;
1613 dst_height = this->dest_height;
1614
1615 for (height = 0;; ) {
1616 dst_1 = _dst;
1617 py_1 = this->y_buffer;
1618 pu = this->u_buffer;
1619 pv = this->v_buffer;
1620
1621 width = this->dest_width >> 3;
1622
1623 do {
1624 RGB(0);
1625 DST1BGR(0);
1626
1627 RGB(1);
1628 DST1BGR(1);
1629
1630 RGB(2);
1631 DST1BGR(2);
1632
1633 RGB(3);
1634 DST1BGR(3);
1635
1636 pu += 4;
1637 pv += 4;
1638 py_1 += 8;
1639 dst_1 += 24;
1640 } while (--width);
1641
1642 dy += this->step_dy;
1643 _dst += this->rgb_stride;
1644
1645 while (--dst_height > 0 && dy < 32768) {
1646
1647 xine_fast_memcpy (_dst, _dst-this->rgb_stride, this->dest_width*3);
1648
1649 dy += this->step_dy;
1650 _dst += this->rgb_stride;
1651 }
1652
1653 if (dst_height <= 0)
1654 break;
1655
1656 do {
1657 dy -= 32768;
1658 _py += this->y_stride;
1659
1660 scale_line (_py, this->y_buffer,
1661 this->dest_width, this->step_dx);
1662
1663 if (height & 1) {
1664 _pu += this->uv_stride;
1665 _pv += this->uv_stride;
1666
1667 scale_line (_pu, this->u_buffer,
1668 this->dest_width >> 1, this->step_dx);
1669 scale_line (_pv, this->v_buffer,
1670 this->dest_width >> 1, this->step_dx);
1671
1672 }
1673 height++;
1674 } while( dy>=32768 );
1675 }
1676
1677 } else {
1678 height = this->source_height >> 1;
1679 do {
1680 dst_1 = _dst;
1681 dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
1682 py_1 = _py;
1683 py_2 = _py + this->y_stride;
1684 pu = _pu;
1685 pv = _pv;
1686 width = this->source_width >> 3;
1687 do {
1688 RGB(0);
1689 DST1BGR(0);
1690 DST2BGR(0);
1691
1692 RGB(1);
1693 DST2BGR(1);
1694 DST1BGR(1);
1695
1696 RGB(2);
1697 DST1BGR(2);
1698 DST2BGR(2);
1699
1700 RGB(3);
1701 DST2BGR(3);
1702 DST1BGR(3);
1703
1704 pu += 4;
1705 pv += 4;
1706 py_1 += 8;
1707 py_2 += 8;
1708 dst_1 += 24;
1709 dst_2 += 24;
1710 } while (--width);
1711
1712 _dst += 2 * this->rgb_stride;
1713 _py += 2 * this->y_stride;
1714 _pu += this->uv_stride;
1715 _pv += this->uv_stride;
1716
1717 } while (--height);
1718 }
1719}
1720
1721/* This is exactly the same code as yuv2rgb_c_32 except for the types of */
1722/* r, g, b, dst_1, dst_2 */
1723static void yuv2rgb_c_16 (yuv2rgb_t *this, uint8_t * _dst,
1724 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
1725{
1726 int U, V, Y;
1727 uint8_t * py_1, * py_2, * pu, * pv;
1728 uint16_t * r, * g, * b;
1729 uint16_t * dst_1, * dst_2;
1730 int width, height, dst_height;
1731 int dy;
1732
1733 if (this->do_scale) {
1734 scale_line_func_t scale_line = this->scale_line;
1735
1736 scale_line (_pu, this->u_buffer,
1737 this->dest_width >> 1, this->step_dx);
1738 scale_line (_pv, this->v_buffer,
1739 this->dest_width >> 1, this->step_dx);
1740 scale_line (_py, this->y_buffer,
1741 this->dest_width, this->step_dx);
1742
1743 dy = 0;
1744 dst_height = this->dest_height;
1745
1746 for (height = 0;; ) {
1747 dst_1 = (uint16_t*)_dst;
1748 py_1 = this->y_buffer;
1749 pu = this->u_buffer;
1750 pv = this->v_buffer;
1751
1752 width = this->dest_width >> 3;
1753
1754 do {
1755 RGB(0);
1756 DST1(0);
1757
1758 RGB(1);
1759 DST1(1);
1760
1761 RGB(2);
1762 DST1(2);
1763
1764 RGB(3);
1765 DST1(3);
1766
1767 pu += 4;
1768 pv += 4;
1769 py_1 += 8;
1770 dst_1 += 8;
1771 } while (--width);
1772
1773 dy += this->step_dy;
1774 _dst += this->rgb_stride;
1775
1776 while (--dst_height > 0 && dy < 32768) {
1777
1778 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*2);
1779
1780 dy += this->step_dy;
1781 _dst += this->rgb_stride;
1782 }
1783
1784 if (dst_height <= 0)
1785 break;
1786
1787 do {
1788 dy -= 32768;
1789 _py += this->y_stride;
1790
1791 scale_line (_py, this->y_buffer,
1792 this->dest_width, this->step_dx);
1793
1794 if (height & 1) {
1795 _pu += this->uv_stride;
1796 _pv += this->uv_stride;
1797
1798 scale_line (_pu, this->u_buffer,
1799 this->dest_width >> 1, this->step_dx);
1800 scale_line (_pv, this->v_buffer,
1801 this->dest_width >> 1, this->step_dx);
1802
1803 }
1804 height++;
1805 } while( dy>=32768);
1806 }
1807 } else {
1808 height = this->source_height >> 1;
1809 do {
1810 dst_1 = (uint16_t*)_dst;
1811 dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
1812 py_1 = _py;
1813 py_2 = _py + this->y_stride;
1814 pu = _pu;
1815 pv = _pv;
1816 width = this->source_width >> 3;
1817 do {
1818 RGB(0);
1819 DST1(0);
1820 DST2(0);
1821
1822 RGB(1);
1823 DST2(1);
1824 DST1(1);
1825
1826 RGB(2);
1827 DST1(2);
1828 DST2(2);
1829
1830 RGB(3);
1831 DST2(3);
1832 DST1(3);
1833
1834 pu += 4;
1835 pv += 4;
1836 py_1 += 8;
1837 py_2 += 8;
1838 dst_1 += 8;
1839 dst_2 += 8;
1840 } while (--width);
1841
1842 _dst += 2 * this->rgb_stride;
1843 _py += 2 * this->y_stride;
1844 _pu += this->uv_stride;
1845 _pv += this->uv_stride;
1846
1847 } while (--height);
1848 }
1849}
1850
1851/* This is exactly the same code as yuv2rgb_c_32 except for the types of */
1852/* r, g, b, dst_1, dst_2 */
1853static void yuv2rgb_c_8 (yuv2rgb_t *this, uint8_t * _dst,
1854 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
1855{
1856 int U, V, Y;
1857 uint8_t * py_1, * py_2, * pu, * pv;
1858 uint8_t * r, * g, * b;
1859 uint8_t * dst_1, * dst_2;
1860 int width, height, dst_height;
1861 int dy;
1862
1863 if (this->do_scale) {
1864 scale_line_func_t scale_line = this->scale_line;
1865
1866 scale_line (_pu, this->u_buffer,
1867 this->dest_width >> 1, this->step_dx);
1868 scale_line (_pv, this->v_buffer,
1869 this->dest_width >> 1, this->step_dx);
1870 scale_line (_py, this->y_buffer,
1871 this->dest_width, this->step_dx);
1872
1873 dy = 0;
1874 dst_height = this->dest_height;
1875
1876 for (height = 0;; ) {
1877 dst_1 = (uint8_t*)_dst;
1878 py_1 = this->y_buffer;
1879 pu = this->u_buffer;
1880 pv = this->v_buffer;
1881
1882 width = this->dest_width >> 3;
1883
1884 do {
1885 RGB(0);
1886 DST1(0);
1887
1888 RGB(1);
1889 DST1(1);
1890
1891 RGB(2);
1892 DST1(2);
1893
1894 RGB(3);
1895 DST1(3);
1896
1897 pu += 4;
1898 pv += 4;
1899 py_1 += 8;
1900 dst_1 += 8;
1901 } while (--width);
1902
1903 dy += this->step_dy;
1904 _dst += this->rgb_stride;
1905
1906 while (--dst_height > 0 && dy < 32768) {
1907
1908 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
1909
1910 dy += this->step_dy;
1911 _dst += this->rgb_stride;
1912 }
1913
1914 if (dst_height <= 0)
1915 break;
1916
1917 do {
1918 dy -= 32768;
1919 _py += this->y_stride;
1920
1921 scale_line (_py, this->y_buffer,
1922 this->dest_width, this->step_dx);
1923
1924 if (height & 1) {
1925 _pu += this->uv_stride;
1926 _pv += this->uv_stride;
1927
1928 scale_line (_pu, this->u_buffer,
1929 this->dest_width >> 1, this->step_dx);
1930 scale_line (_pv, this->v_buffer,
1931 this->dest_width >> 1, this->step_dx);
1932
1933 }
1934 height++;
1935 } while( dy>=32768 );
1936 }
1937 } else {
1938 height = this->source_height >> 1;
1939 do {
1940 dst_1 = (uint8_t*)_dst;
1941 dst_2 = (void*)( (uint8_t *)_dst + this->rgb_stride );
1942 py_1 = _py;
1943 py_2 = _py + this->y_stride;
1944 pu = _pu;
1945 pv = _pv;
1946
1947 width = this->source_width >> 3;
1948 do {
1949 RGB(0);
1950 DST1(0);
1951 DST2(0);
1952
1953 RGB(1);
1954 DST2(1);
1955 DST1(1);
1956
1957 RGB(2);
1958 DST1(2);
1959 DST2(2);
1960
1961 RGB(3);
1962 DST2(3);
1963 DST1(3);
1964
1965 pu += 4;
1966 pv += 4;
1967 py_1 += 8;
1968 py_2 += 8;
1969 dst_1 += 8;
1970 dst_2 += 8;
1971 } while (--width);
1972
1973 _dst += 2 * this->rgb_stride;
1974 _py += 2 * this->y_stride;
1975 _pu += this->uv_stride;
1976 _pv += this->uv_stride;
1977
1978 } while (--height);
1979 }
1980}
1981
1982/* now for something different: 256 grayscale mode */
1983static void yuv2rgb_c_gray (yuv2rgb_t *this, uint8_t * _dst,
1984 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
1985{
1986 int height, dst_height;
1987 int dy;
1988
1989 if (this->do_scale) {
1990 scale_line_func_t scale_line = this->scale_line;
1991
1992 dy = 0;
1993 dst_height = this->dest_height;
1994
1995 for (;;) {
1996 scale_line (_py, _dst, this->dest_width, this->step_dx);
1997
1998 dy += this->step_dy;
1999 _dst += this->rgb_stride;
2000
2001 while (--dst_height > 0 && dy < 32768) {
2002
2003 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
2004
2005 dy += this->step_dy;
2006 _dst += this->rgb_stride;
2007 }
2008
2009 if (dst_height <= 0)
2010 break;
2011
2012 _py += this->y_stride*(dy>>15);
2013 dy &= 32767;
2014 /* dy -= 32768;
2015 _py += this->y_stride;
2016 */
2017 }
2018 } else {
2019 for (height = this->source_height; --height >= 0; ) {
2020 xine_fast_memcpy(_dst, _py, this->dest_width);
2021 _dst += this->rgb_stride;
2022 _py += this->y_stride;
2023 }
2024 }
2025}
2026
2027/* now for something different: 256 color mode */
2028static void yuv2rgb_c_palette (yuv2rgb_t *this, uint8_t * _dst,
2029 uint8_t * _py, uint8_t * _pu, uint8_t * _pv)
2030{
2031 int U, V, Y;
2032 uint8_t * py_1, * py_2, * pu, * pv;
2033 uint16_t * r, * g, * b;
2034 uint8_t * dst_1, * dst_2;
2035 int width, height, dst_height;
2036 int dy;
2037
2038 if (this->do_scale) {
2039 scale_line_func_t scale_line = this->scale_line;
2040
2041 scale_line (_pu, this->u_buffer,
2042 this->dest_width >> 1, this->step_dx);
2043 scale_line (_pv, this->v_buffer,
2044 this->dest_width >> 1, this->step_dx);
2045 scale_line (_py, this->y_buffer,
2046 this->dest_width, this->step_dx);
2047
2048 dy = 0;
2049 dst_height = this->dest_height;
2050
2051 for (height = 0;; ) {
2052 dst_1 = _dst;
2053 py_1 = this->y_buffer;
2054 pu = this->u_buffer;
2055 pv = this->v_buffer;
2056
2057 width = this->dest_width >> 3;
2058
2059 do {
2060 RGB(0);
2061 DST1CMAP(0);
2062
2063 RGB(1);
2064 DST1CMAP(1);
2065
2066 RGB(2);
2067 DST1CMAP(2);
2068
2069 RGB(3);
2070 DST1CMAP(3);
2071
2072 pu += 4;
2073 pv += 4;
2074 py_1 += 8;
2075 dst_1 += 8;
2076 } while (--width);
2077
2078 dy += this->step_dy;
2079 _dst += this->rgb_stride;
2080
2081 while (--dst_height > 0 && dy < 32768) {
2082
2083 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
2084
2085 dy += this->step_dy;
2086 _dst += this->rgb_stride;
2087 }
2088
2089 if (dst_height <= 0)
2090 break;
2091
2092 do {
2093 dy -= 32768;
2094 _py += this->y_stride;
2095
2096 scale_line (_py, this->y_buffer,
2097 this->dest_width, this->step_dx);
2098
2099 if (height & 1) {
2100 _pu += this->uv_stride;
2101 _pv += this->uv_stride;
2102
2103 scale_line (_pu, this->u_buffer,
2104 this->dest_width >> 1, this->step_dx);
2105 scale_line (_pv, this->v_buffer,
2106 this->dest_width >> 1, this->step_dx);
2107
2108 }
2109 height++;
2110 } while( dy>=32768 );
2111 }
2112 } else {
2113 height = this->source_height >> 1;
2114 do {
2115 dst_1 = _dst;
2116 dst_2 = _dst + this->rgb_stride;
2117 py_1 = _py;
2118 py_2 = _py + this->y_stride;
2119 pu = _pu;
2120 pv = _pv;
2121 width = this->source_width >> 3;
2122 do {
2123 RGB(0);
2124 DST1CMAP(0);
2125 DST2CMAP(0);
2126
2127 RGB(1);
2128 DST2CMAP(1);
2129 DST1CMAP(1);
2130
2131 RGB(2);
2132 DST1CMAP(2);
2133 DST2CMAP(2);
2134
2135 RGB(3);
2136 DST2CMAP(3);
2137 DST1CMAP(3);
2138
2139 pu += 4;
2140 pv += 4;
2141 py_1 += 8;
2142 py_2 += 8;
2143 dst_1 += 8;
2144 dst_2 += 8;
2145 } while (--width);
2146
2147 _dst += 2 * this->rgb_stride;
2148 _py += 2 * this->y_stride;
2149 _pu += this->uv_stride;
2150 _pv += this->uv_stride;
2151
2152 } while (--height);
2153 }
2154}
2155
2156static int div_round (int dividend, int divisor)
2157{
2158 if (dividend > 0)
2159 return (dividend + (divisor>>1)) / divisor;
2160 else
2161 return -((-dividend + (divisor>>1)) / divisor);
2162}
2163
2164static void yuv2rgb_setup_tables (yuv2rgb_factory_t *this, int mode, int swapped)
2165{
2166 int i;
2167 uint8_t table_Y[1024];
2168 uint32_t * table_32 = 0;
2169 uint16_t * table_16 = 0;
2170 uint8_t * table_8 = 0;
2171 int entry_size = 0;
2172 void *table_r = 0, *table_g = 0, *table_b = 0;
2173 int shift_r = 0, shift_g = 0, shift_b = 0;
2174
2175 int crv = Inverse_Table_6_9[this->matrix_coefficients][0];
2176 int cbu = Inverse_Table_6_9[this->matrix_coefficients][1];
2177 int cgu = -Inverse_Table_6_9[this->matrix_coefficients][2];
2178 int cgv = -Inverse_Table_6_9[this->matrix_coefficients][3];
2179
2180 for (i = 0; i < 1024; i++) {
2181 int j;
2182
2183 j = (76309 * (i - 384 - 16) + 32768) >> 16;
2184 j = (j < 0) ? 0 : ((j > 255) ? 255 : j);
2185 table_Y[i] = j;
2186 }
2187
2188 switch (mode) {
2189 case MODE_32_RGB:
2190 case MODE_32_BGR:
2191 table_32 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
2192
2193 entry_size = sizeof (uint32_t);
2194 table_r = table_32 + 197;
2195 table_b = table_32 + 197 + 685;
2196 table_g = table_32 + 197 + 2*682;
2197
2198 if (swapped) {
2199 switch (mode) {
2200 case MODE_32_RGB: shift_r = 8; shift_g = 16; shift_b = 24; break;
2201 case MODE_32_BGR:shift_r = 24; shift_g = 16; shift_b = 8; break;
2202 }
2203 } else {
2204 switch (mode) {
2205 case MODE_32_RGB:shift_r = 16; shift_g = 8; shift_b = 0; break;
2206 case MODE_32_BGR:shift_r = 0; shift_g = 8; shift_b = 16; break;
2207 }
2208 }
2209
2210 for (i = -197; i < 256+197; i++)
2211 ((uint32_t *) table_r)[i] = table_Y[i+384] << shift_r;
2212 for (i = -132; i < 256+132; i++)
2213 ((uint32_t *) table_g)[i] = table_Y[i+384] << shift_g;
2214 for (i = -232; i < 256+232; i++)
2215 ((uint32_t *) table_b)[i] = table_Y[i+384] << shift_b;
2216 break;
2217
2218 case MODE_24_RGB:
2219 case MODE_24_BGR:
2220 table_8 = malloc ((256 + 2*232) * sizeof (uint8_t));
2221
2222 entry_size = sizeof (uint8_t);
2223 table_r = table_g = table_b = table_8 + 232;
2224
2225 for (i = -232; i < 256+232; i++)
2226 ((uint8_t * )table_b)[i] = table_Y[i+384];
2227 break;
2228
2229 case MODE_15_BGR:
2230 case MODE_16_BGR:
2231 case MODE_15_RGB:
2232 case MODE_16_RGB:
2233 table_16 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
2234
2235 entry_size = sizeof (uint16_t);
2236 table_r = table_16 + 197;
2237 table_b = table_16 + 197 + 685;
2238 table_g = table_16 + 197 + 2*682;
2239
2240 if (swapped) {
2241 switch (mode) {
2242 case MODE_15_BGR: shift_r = 8; shift_g = 5; shift_b = 2; break;
2243 case MODE_16_BGR:shift_r = 8; shift_g = 5; shift_b = 3; break;
2244 case MODE_15_RGB:shift_r = 2; shift_g = 5; shift_b = 8; break;
2245 case MODE_16_RGB:shift_r = 3; shift_g = 5; shift_b = 8; break;
2246 }
2247 } else {
2248 switch (mode) {
2249 case MODE_15_BGR:shift_r = 0; shift_g = 5; shift_b = 10; break;
2250 case MODE_16_BGR:shift_r = 0; shift_g = 5; shift_b = 11; break;
2251 case MODE_15_RGB:shift_r = 10; shift_g = 5; shift_b = 0; break;
2252 case MODE_16_RGB:shift_r = 11; shift_g = 5; shift_b = 0; break;
2253 }
2254 }
2255
2256 for (i = -197; i < 256+197; i++)
2257 ((uint16_t *)table_r)[i] = (table_Y[i+384] >> 3) << shift_r;
2258
2259 for (i = -132; i < 256+132; i++) {
2260 int j = table_Y[i+384] >> (((mode==MODE_16_RGB) || (mode==MODE_16_BGR)) ? 2 : 3);
2261 if (swapped)
2262 ((uint16_t *)table_g)[i] = (j&7) << 13 | (j>>3);
2263 else
2264 ((uint16_t *)table_g)[i] = j << 5;
2265 }
2266 for (i = -232; i < 256+232; i++)
2267 ((uint16_t *)table_b)[i] = (table_Y[i+384] >> 3) << shift_b;
2268
2269 break;
2270
2271 case MODE_8_RGB:
2272 case MODE_8_BGR:
2273 table_8 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
2274
2275 entry_size = sizeof (uint8_t);
2276 table_r = table_8 + 197;
2277 table_b = table_8 + 197 + 685;
2278 table_g = table_8 + 197 + 2*682;
2279
2280 switch (mode) {
2281 case MODE_8_RGB: shift_r = 5; shift_g = 2; shift_b = 0; break;
2282 case MODE_8_BGR: shift_r = 0; shift_g = 3; shift_b = 6; break;
2283 }
2284
2285 for (i = -197; i < 256+197; i++)
2286 ((uint8_t *) table_r)[i] = (table_Y[i+384] >> 5) << shift_r;
2287 for (i = -132; i < 256+132; i++)
2288 ((uint8_t *) table_g)[i] = (table_Y[i+384] >> 5) << shift_g;
2289 for (i = -232; i < 256+232; i++)
2290 ((uint8_t *) table_b)[i] = (table_Y[i+384] >> 6) << shift_b;
2291 break;
2292
2293 case MODE_8_GRAY:
2294 return;
2295
2296 case MODE_PALETTE:
2297 table_16 = malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
2298
2299 entry_size = sizeof (uint16_t);
2300 table_r = table_16 + 197;
2301 table_b = table_16 + 197 + 685;
2302 table_g = table_16 + 197 + 2*682;
2303
2304 shift_r = 10;
2305 shift_g = 5;
2306 shift_b = 0;
2307
2308 for (i = -197; i < 256+197; i++)
2309 ((uint16_t *)table_r)[i] = (table_Y[i+384] >> 3) << 10;
2310
2311 for (i = -132; i < 256+132; i++)
2312 ((uint16_t *)table_g)[i] = (table_Y[i+384] >> 3) << 5;
2313
2314 for (i = -232; i < 256+232; i++)
2315 ((uint16_t *)table_b)[i] = (table_Y[i+384] >> 3) << 0;
2316
2317 break;
2318
2319
2320 default:
2321 fprintf (stderr, "mode %d not supported by yuv2rgb\n", mode);
2322 abort();
2323 }
2324
2325 for (i = 0; i < 256; i++) {
2326 this->table_rV[i] = (((uint8_t *) table_r) +
2327 entry_size * div_round (crv * (i-128), 76309));
2328 this->table_gU[i] = (((uint8_t *) table_g) +
2329 entry_size * div_round (cgu * (i-128), 76309));
2330 this->table_gV[i] = entry_size * div_round (cgv * (i-128), 76309);
2331 this->table_bU[i] = (((uint8_t *)table_b) +
2332 entry_size * div_round (cbu * (i-128), 76309));
2333 }
2334 this->gamma = 0;
2335 this->entry_size = entry_size;
2336}
2337
2338static uint32_t yuv2rgb_single_pixel_32 (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2339{
2340 uint32_t * r, * g, * b;
2341
2342 r = this->table_rV[v];
2343 g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
2344 b = this->table_bU[u];
2345
2346 return r[y] + g[y] + b[y];
2347}
2348
2349static uint32_t yuv2rgb_single_pixel_24_rgb (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2350{
2351 uint8_t * r, * g, * b;
2352
2353 r = this->table_rV[v];
2354 g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
2355 b = this->table_bU[u];
2356
2357 return (uint32_t) r[y] +
2358 ((uint32_t) g[y] << 8) +
2359 ((uint32_t) b[y] << 16);
2360}
2361
2362static uint32_t yuv2rgb_single_pixel_24_bgr (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2363{
2364 uint8_t * r, * g, * b;
2365
2366 r = this->table_rV[v];
2367 g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
2368 b = this->table_bU[u];
2369
2370 return (uint32_t) b[y] +
2371 ((uint32_t) g[y] << 8) +
2372 ((uint32_t) r[y] << 16);
2373}
2374
2375static uint32_t yuv2rgb_single_pixel_16 (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2376{
2377 uint16_t * r, * g, * b;
2378
2379 r = this->table_rV[v];
2380 g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
2381 b = this->table_bU[u];
2382
2383 return r[y] + g[y] + b[y];
2384}
2385
2386static uint32_t yuv2rgb_single_pixel_8 (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2387{
2388 uint8_t * r, * g, * b;
2389
2390 r = this->table_rV[v];
2391 g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
2392 b = this->table_bU[u];
2393
2394 return r[y] + g[y] + b[y];
2395}
2396
2397static uint32_t yuv2rgb_single_pixel_gray (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2398{
2399 return y;
2400}
2401
2402static uint32_t yuv2rgb_single_pixel_palette (yuv2rgb_t *this, uint8_t y, uint8_t u, uint8_t v)
2403{
2404 uint16_t * r, * g, * b;
2405
2406 r = this->table_rV[v];
2407 g = (void *) (((uint8_t *)this->table_gU[u]) + this->table_gV[v]);
2408 b = this->table_bU[u];
2409
2410 return this->cmap[r[y] + g[y] + b[y]];
2411}
2412
2413
2414static void yuv2rgb_c_init (yuv2rgb_factory_t *this)
2415{
2416 switch (this->mode) {
2417 case MODE_32_RGB:
2418 case MODE_32_BGR:
2419 this->yuv2rgb_fun = yuv2rgb_c_32;
2420 break;
2421
2422 case MODE_24_RGB:
2423 case MODE_24_BGR:
2424 this->yuv2rgb_fun =
2425 (this->mode==MODE_24_RGB && !this->swapped) || (this->mode==MODE_24_BGR && this->swapped)
2426 ? yuv2rgb_c_24_rgb
2427 : yuv2rgb_c_24_bgr;
2428 break;
2429
2430 case MODE_15_BGR:
2431 case MODE_16_BGR:
2432 case MODE_15_RGB:
2433 case MODE_16_RGB:
2434 this->yuv2rgb_fun = yuv2rgb_c_16;
2435 break;
2436
2437 case MODE_8_RGB:
2438 case MODE_8_BGR:
2439 this->yuv2rgb_fun = yuv2rgb_c_8;
2440 break;
2441
2442 case MODE_8_GRAY:
2443 this->yuv2rgb_fun = yuv2rgb_c_gray;
2444 break;
2445
2446 case MODE_PALETTE:
2447 this->yuv2rgb_fun = yuv2rgb_c_palette;
2448 break;
2449
2450 default:
2451 printf ("yuv2rgb: mode %d not supported by yuv2rgb\n", this->mode);
2452 abort();
2453 }
2454
2455}
2456
2457static void yuv2rgb_single_pixel_init (yuv2rgb_factory_t *this) {
2458
2459 switch (this->mode) {
2460 case MODE_32_RGB:
2461 case MODE_32_BGR:
2462 this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_32;
2463 break;
2464
2465 case MODE_24_RGB:
2466 case MODE_24_BGR:
2467 this->yuv2rgb_single_pixel_fun =
2468 (this->mode==MODE_24_RGB && !this->swapped) || (this->mode==MODE_24_BGR && this->swapped)
2469 ? yuv2rgb_single_pixel_24_rgb
2470 : yuv2rgb_single_pixel_24_bgr;
2471 break;
2472
2473 case MODE_15_BGR:
2474 case MODE_16_BGR:
2475 case MODE_15_RGB:
2476 case MODE_16_RGB:
2477 this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_16;
2478 break;
2479
2480 case MODE_8_RGB:
2481 case MODE_8_BGR:
2482 this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_8;
2483 break;
2484
2485 case MODE_8_GRAY:
2486 this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_gray;
2487 break;
2488
2489 case MODE_PALETTE:
2490 this->yuv2rgb_single_pixel_fun = yuv2rgb_single_pixel_palette;
2491 break;
2492
2493 default:
2494 printf ("yuv2rgb: mode %d not supported by yuv2rgb\n", this->mode);
2495 abort();
2496 }
2497}
2498
2499
2500/*
2501 * yuy2 stuff
2502 */
2503
2504static void yuy22rgb_c_32 (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2505{
2506 int U, V, Y;
2507 uint8_t * py_1, * pu, * pv;
2508 uint32_t * r, * g, * b;
2509 uint32_t * dst_1;
2510 int width, height;
2511 int dy;
2512
2513 /* FIXME: implement unscaled version */
2514
2515 scale_line_4 (_p+1, this->u_buffer,
2516 this->dest_width >> 1, this->step_dx);
2517 scale_line_4 (_p+3, this->v_buffer,
2518 this->dest_width >> 1, this->step_dx);
2519 scale_line_2 (_p, this->y_buffer,
2520 this->dest_width, this->step_dx);
2521
2522 dy = 0;
2523 height = this->dest_height;
2524
2525 for (;;) {
2526 dst_1 = (uint32_t*)_dst;
2527 py_1 = this->y_buffer;
2528 pu = this->u_buffer;
2529 pv = this->v_buffer;
2530
2531 width = this->dest_width >> 3;
2532
2533 do {
2534
2535 RGB(0);
2536 DST1(0);
2537
2538 RGB(1);
2539 DST1(1);
2540
2541 RGB(2);
2542 DST1(2);
2543
2544 RGB(3);
2545 DST1(3);
2546
2547 pu += 4;
2548 pv += 4;
2549 py_1 += 8;
2550 dst_1 += 8;
2551 } while (--width);
2552
2553 dy += this->step_dy;
2554 _dst += this->rgb_stride;
2555
2556 while (--height > 0 && dy < 32768) {
2557
2558 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*4);
2559
2560 dy += this->step_dy;
2561 _dst += this->rgb_stride;
2562 }
2563
2564 if (height <= 0)
2565 break;
2566
2567 _p += this->y_stride*2*(dy>>15);
2568 dy &= 32767;
2569 /*
2570 dy -= 32768;
2571 _p += this->y_stride*2;
2572 */
2573
2574 scale_line_4 (_p+1, this->u_buffer,
2575 this->dest_width >> 1, this->step_dx);
2576 scale_line_4 (_p+3, this->v_buffer,
2577 this->dest_width >> 1, this->step_dx);
2578 scale_line_2 (_p, this->y_buffer,
2579 this->dest_width, this->step_dx);
2580 }
2581}
2582
2583static void yuy22rgb_c_24_rgb (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2584{
2585 int U, V, Y;
2586 uint8_t * py_1, * pu, * pv;
2587 uint8_t * r, * g, * b;
2588 uint8_t * dst_1;
2589 int width, height;
2590 int dy;
2591
2592 /* FIXME: implement unscaled version */
2593
2594 scale_line_4 (_p+1, this->u_buffer,
2595 this->dest_width >> 1, this->step_dx);
2596 scale_line_4 (_p+3, this->v_buffer,
2597 this->dest_width >> 1, this->step_dx);
2598 scale_line_2 (_p, this->y_buffer,
2599 this->dest_width, this->step_dx);
2600
2601 dy = 0;
2602 height = this->dest_height;
2603
2604 for (;;) {
2605 dst_1 = _dst;
2606 py_1 = this->y_buffer;
2607 pu = this->u_buffer;
2608 pv = this->v_buffer;
2609
2610 width = this->dest_width >> 3;
2611
2612 do {
2613 RGB(0);
2614 DST1RGB(0);
2615
2616 RGB(1);
2617 DST1RGB(1);
2618
2619 RGB(2);
2620 DST1RGB(2);
2621
2622 RGB(3);
2623 DST1RGB(3);
2624
2625 pu += 4;
2626 pv += 4;
2627 py_1 += 8;
2628 dst_1 += 24;
2629 } while (--width);
2630
2631 dy += this->step_dy;
2632 _dst += this->rgb_stride;
2633
2634 while (--height > 0 && dy < 32768) {
2635
2636 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*3);
2637
2638 dy += this->step_dy;
2639 _dst += this->rgb_stride;
2640 }
2641
2642 if (height <= 0)
2643 break;
2644
2645 _p += this->y_stride*2*(dy>>15);
2646 dy &= 32767;
2647 /*
2648 dy -= 32768;
2649 _p += this->y_stride*2;
2650 */
2651
2652 scale_line_4 (_p+1, this->u_buffer,
2653 this->dest_width >> 1, this->step_dx);
2654 scale_line_4 (_p+3, this->v_buffer,
2655 this->dest_width >> 1, this->step_dx);
2656 scale_line_2 (_p, this->y_buffer,
2657 this->dest_width, this->step_dx);
2658 }
2659}
2660
2661static void yuy22rgb_c_24_bgr (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2662{
2663 int U, V, Y;
2664 uint8_t * py_1, * pu, * pv;
2665 uint8_t * r, * g, * b;
2666 uint8_t * dst_1;
2667 int width, height;
2668 int dy;
2669
2670 /* FIXME: implement unscaled version */
2671
2672 scale_line_4 (_p+1, this->u_buffer,
2673 this->dest_width >> 1, this->step_dx);
2674 scale_line_4 (_p+3, this->v_buffer,
2675 this->dest_width >> 1, this->step_dx);
2676 scale_line_2 (_p, this->y_buffer,
2677 this->dest_width, this->step_dx);
2678
2679 dy = 0;
2680 height = this->dest_height;
2681
2682 for (;;) {
2683 dst_1 = _dst;
2684 py_1 = this->y_buffer;
2685 pu = this->u_buffer;
2686 pv = this->v_buffer;
2687
2688 width = this->dest_width >> 3;
2689
2690 do {
2691 RGB(0);
2692 DST1BGR(0);
2693
2694 RGB(1);
2695 DST1BGR(1);
2696
2697 RGB(2);
2698 DST1BGR(2);
2699
2700 RGB(3);
2701 DST1BGR(3);
2702
2703 pu += 4;
2704 pv += 4;
2705 py_1 += 8;
2706 dst_1 += 24;
2707 } while (--width);
2708
2709 dy += this->step_dy;
2710 _dst += this->rgb_stride;
2711
2712 while (--height > 0 && dy < 32768) {
2713
2714 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*3);
2715
2716 dy += this->step_dy;
2717 _dst += this->rgb_stride;
2718 }
2719
2720 if (height <= 0)
2721 break;
2722
2723 _p += this->y_stride*2*(dy>>15);
2724 dy &= 32767;
2725
2726 scale_line_4 (_p+1, this->u_buffer,
2727 this->dest_width >> 1, this->step_dx);
2728 scale_line_4 (_p+3, this->v_buffer,
2729 this->dest_width >> 1, this->step_dx);
2730 scale_line_2 (_p, this->y_buffer,
2731 this->dest_width, this->step_dx);
2732 }
2733}
2734
2735static void yuy22rgb_c_16 (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2736{
2737 int U, V, Y;
2738 uint8_t * py_1, * pu, * pv;
2739 uint16_t * r, * g, * b;
2740 uint16_t * dst_1;
2741 int width, height;
2742 int dy;
2743
2744 /* FIXME: implement unscaled version */
2745
2746 scale_line_4 (_p+1, this->u_buffer,
2747 this->dest_width >> 1, this->step_dx);
2748 scale_line_4 (_p+3, this->v_buffer,
2749 this->dest_width >> 1, this->step_dx);
2750 scale_line_2 (_p, this->y_buffer,
2751 this->dest_width, this->step_dx);
2752
2753 dy = 0;
2754 height = this->dest_height;
2755
2756 for (;;) {
2757 dst_1 = (uint16_t*)_dst;
2758 py_1 = this->y_buffer;
2759 pu = this->u_buffer;
2760 pv = this->v_buffer;
2761
2762 width = this->dest_width >> 3;
2763
2764 do {
2765 RGB(0);
2766 DST1(0);
2767
2768 RGB(1);
2769 DST1(1);
2770
2771 RGB(2);
2772 DST1(2);
2773
2774 RGB(3);
2775 DST1(3);
2776
2777 pu += 4;
2778 pv += 4;
2779 py_1 += 8;
2780 dst_1 += 8;
2781 } while (--width);
2782
2783 dy += this->step_dy;
2784 _dst += this->rgb_stride;
2785
2786 while (--height > 0 && dy < 32768) {
2787
2788 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width*2);
2789
2790 dy += this->step_dy;
2791 _dst += this->rgb_stride;
2792 }
2793
2794 if (height <= 0)
2795 break;
2796
2797 _p += this->y_stride*2*(dy>>15);
2798 dy &= 32767;
2799
2800 scale_line_4 (_p+1, this->u_buffer,
2801 this->dest_width >> 1, this->step_dx);
2802 scale_line_4 (_p+3, this->v_buffer,
2803 this->dest_width >> 1, this->step_dx);
2804 scale_line_2 (_p, this->y_buffer,
2805 this->dest_width, this->step_dx);
2806 }
2807}
2808
2809static void yuy22rgb_c_8 (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2810{
2811 int U, V, Y;
2812 uint8_t * py_1, * pu, * pv;
2813 uint8_t * r, * g, * b;
2814 uint8_t * dst_1;
2815 int width, height;
2816 int dy;
2817
2818 /* FIXME: implement unscaled version */
2819
2820 scale_line_4 (_p+1, this->u_buffer,
2821 this->dest_width >> 1, this->step_dx);
2822 scale_line_4 (_p+3, this->v_buffer,
2823 this->dest_width >> 1, this->step_dx);
2824 scale_line_2 (_p, this->y_buffer,
2825 this->dest_width, this->step_dx);
2826
2827 dy = 0;
2828 height = this->dest_height;
2829
2830 for (;;) {
2831 dst_1 = _dst;
2832 py_1 = this->y_buffer;
2833 pu = this->u_buffer;
2834 pv = this->v_buffer;
2835
2836 width = this->dest_width >> 3;
2837
2838 do {
2839 RGB(0);
2840 DST1(0);
2841
2842 RGB(1);
2843 DST1(1);
2844
2845 RGB(2);
2846 DST1(2);
2847
2848 RGB(3);
2849 DST1(3);
2850
2851 pu += 4;
2852 pv += 4;
2853 py_1 += 8;
2854 dst_1 += 8;
2855 } while (--width);
2856
2857 dy += this->step_dy;
2858 _dst += this->rgb_stride;
2859
2860 while (--height > 0 && dy < 32768) {
2861
2862 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
2863
2864 dy += this->step_dy;
2865 _dst += this->rgb_stride;
2866 }
2867
2868 if (height <= 0)
2869 break;
2870
2871 _p += this->y_stride*2*(dy>>15);
2872 dy &= 32767;
2873
2874 scale_line_4 (_p+1, this->u_buffer,
2875 this->dest_width >> 1, this->step_dx);
2876 scale_line_4 (_p+3, this->v_buffer,
2877 this->dest_width >> 1, this->step_dx);
2878 scale_line_2 (_p, this->y_buffer,
2879 this->dest_width, this->step_dx);
2880 }
2881}
2882
2883static void yuy22rgb_c_gray (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2884{
2885 int width, height;
2886 int dy;
2887 uint8_t * dst;
2888 uint8_t * y;
2889
2890 if (this->do_scale) {
2891 dy = 0;
2892 height = this->dest_height;
2893
2894 for (;;) {
2895 scale_line_2 (_p, _dst, this->dest_width, this->step_dx);
2896
2897 dy += this->step_dy;
2898 _dst += this->rgb_stride;
2899
2900 while (--height > 0 && dy < 32768) {
2901
2902 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
2903
2904 dy += this->step_dy;
2905 _dst += this->rgb_stride;
2906 }
2907
2908 if (height <= 0)
2909 break;
2910
2911 _p += this->y_stride*2*(dy>>15);
2912 dy &= 32767;
2913 }
2914 } else {
2915 for (height = this->source_height; --height >= 0; ) {
2916 dst = _dst;
2917 y = _p;
2918 for (width = this->source_width; --width >= 0; ) {
2919 *dst++ = *y;
2920 y += 2;
2921 }
2922 _dst += this->rgb_stride;
2923 _p += this->y_stride*2;
2924 }
2925 }
2926}
2927
2928static void yuy22rgb_c_palette (yuv2rgb_t *this, uint8_t * _dst, uint8_t * _p)
2929{
2930 int U, V, Y;
2931 uint8_t * py_1, * pu, * pv;
2932 uint16_t * r, * g, * b;
2933 uint8_t * dst_1;
2934 int width, height;
2935 int dy;
2936
2937 scale_line_4 (_p+1, this->u_buffer,
2938 this->dest_width >> 1, this->step_dx);
2939 scale_line_4 (_p+3, this->v_buffer,
2940 this->dest_width >> 1, this->step_dx);
2941 scale_line_2 (_p, this->y_buffer,
2942 this->dest_width, this->step_dx);
2943
2944 dy = 0;
2945 height = this->dest_height;
2946
2947 for (;;) {
2948 dst_1 = _dst;
2949 py_1 = this->y_buffer;
2950 pu = this->u_buffer;
2951 pv = this->v_buffer;
2952
2953 width = this->dest_width >> 3;
2954
2955 do {
2956 RGB(0);
2957 DST1CMAP(0);
2958
2959 RGB(1);
2960 DST1CMAP(1);
2961
2962 RGB(2);
2963 DST1CMAP(2);
2964
2965 RGB(3);
2966 DST1CMAP(3);
2967
2968 pu += 4;
2969 pv += 4;
2970 py_1 += 8;
2971 dst_1 += 8;
2972 } while (--width);
2973
2974 dy += this->step_dy;
2975 _dst += this->rgb_stride;
2976
2977 while (--height > 0 && dy < 32768) {
2978
2979 xine_fast_memcpy (_dst, (uint8_t*)_dst-this->rgb_stride, this->dest_width);
2980
2981 dy += this->step_dy;
2982 _dst += this->rgb_stride;
2983 }
2984
2985 if (height <= 0)
2986 break;
2987
2988 _p += this->y_stride*2*(dy>>15);
2989 dy &= 32767;
2990
2991 scale_line_4 (_p+1, this->u_buffer,
2992 this->dest_width >> 1, this->step_dx);
2993 scale_line_4 (_p+3, this->v_buffer,
2994 this->dest_width >> 1, this->step_dx);
2995 scale_line_2 (_p, this->y_buffer,
2996 this->dest_width, this->step_dx);
2997 }
2998}
2999
3000static void yuy22rgb_c_init (yuv2rgb_factory_t *this)
3001{
3002 switch (this->mode) {
3003 case MODE_32_RGB:
3004 case MODE_32_BGR:
3005 this->yuy22rgb_fun = yuy22rgb_c_32;
3006 break;
3007
3008 case MODE_24_RGB:
3009 case MODE_24_BGR:
3010 this->yuy22rgb_fun =
3011 (this->mode==MODE_24_RGB && !this->swapped) || (this->mode==MODE_24_BGR && this->swapped)
3012 ? yuy22rgb_c_24_rgb
3013 : yuy22rgb_c_24_bgr;
3014 break;
3015 case MODE_15_BGR:
3016 case MODE_16_BGR:
3017 case MODE_15_RGB:
3018 case MODE_16_RGB:
3019 this->yuy22rgb_fun = yuy22rgb_c_16;
3020 break;
3021
3022 case MODE_8_RGB:
3023 case MODE_8_BGR:
3024 this->yuy22rgb_fun = yuy22rgb_c_8;
3025 break;
3026
3027 case MODE_8_GRAY:
3028 this->yuy22rgb_fun = yuy22rgb_c_gray;
3029 break;
3030
3031 case MODE_PALETTE:
3032 this->yuy22rgb_fun = yuy22rgb_c_palette;
3033 break;
3034
3035 default:
3036 printf ("yuv2rgb: mode %d not supported for yuy2\n", this->mode);
3037 }
3038}
3039
3040yuv2rgb_t *yuv2rgb_create_converter (yuv2rgb_factory_t *factory) {
3041
3042 yuv2rgb_t *this = xine_xmalloc (sizeof (yuv2rgb_t));
3043
3044 this->cmap = factory->cmap;
3045
3046 this->y_chunk = this->y_buffer = NULL;
3047 this->u_chunk = this->u_buffer = NULL;
3048 this->v_chunk = this->v_buffer = NULL;
3049
3050 this->table_rV = factory->table_rV;
3051 this->table_gU = factory->table_gU;
3052 this->table_gV = factory->table_gV;
3053 this->table_bU = factory->table_bU;
3054
3055 this->yuv2rgb_fun = factory->yuv2rgb_fun;
3056 this->yuy22rgb_fun = factory->yuy22rgb_fun;
3057 this->yuv2rgb_single_pixel_fun = factory->yuv2rgb_single_pixel_fun;
3058
3059 this->configure = yuv2rgb_configure;
3060 return this;
3061}
3062
3063/*
3064 * factory functions
3065 */
3066
3067void yuv2rgb_set_gamma (yuv2rgb_factory_t *this, int gamma) {
3068
3069 int i;
3070
3071 for (i = 0; i < 256; i++) {
3072 (uint8_t *)this->table_rV[i] += this->entry_size*(gamma - this->gamma);
3073 (uint8_t *)this->table_gU[i] += this->entry_size*(gamma - this->gamma);
3074 (uint8_t *)this->table_bU[i] += this->entry_size*(gamma - this->gamma);
3075 }
3076#ifdef ARCH_X86
3077 mmx_yuv2rgb_set_gamma(gamma);
3078#endif
3079 this->gamma = gamma;
3080}
3081
3082int yuv2rgb_get_gamma (yuv2rgb_factory_t *this) {
3083
3084 return this->gamma;
3085}
3086
3087yuv2rgb_factory_t* yuv2rgb_factory_init (int mode, int swapped,
3088 uint8_t *cmap) {
3089
3090 yuv2rgb_factory_t *this;
3091
3092#ifdef ARCH_X86
3093 uint32_t mm = xine_mm_accel();
3094#endif
3095
3096 this = malloc (sizeof (yuv2rgb_factory_t));
3097
3098 this->mode = mode;
3099 this->swapped = swapped;
3100 this->cmap = cmap;
3101 this->create_converter = yuv2rgb_create_converter;
3102 this->set_gamma = yuv2rgb_set_gamma;
3103 this->get_gamma = yuv2rgb_get_gamma;
3104 this->matrix_coefficients = 6;
3105
3106
3107 yuv2rgb_setup_tables (this, mode, swapped);
3108
3109 /*
3110 * auto-probe for the best yuv2rgb function
3111 */
3112
3113 this->yuv2rgb_fun = NULL;
3114#ifdef ARCH_X86
3115 if ((this->yuv2rgb_fun == NULL) && (mm & MM_ACCEL_X86_MMXEXT)) {
3116
3117 yuv2rgb_init_mmxext (this);
3118
3119 if (this->yuv2rgb_fun != NULL)
3120 printf ("yuv2rgb: using MMXEXT for colorspace transform\n");
3121 }
3122
3123 if ((this->yuv2rgb_fun == NULL) && (mm & MM_ACCEL_X86_MMX)) {
3124
3125 yuv2rgb_init_mmx (this);
3126
3127 if (this->yuv2rgb_fun != NULL)
3128 printf ("yuv2rgb: using MMX for colorspace transform\n");
3129 }
3130#endif
3131#if HAVE_MLIB
3132 if (this->yuv2rgb_fun == NULL) {
3133
3134 yuv2rgb_init_mlib (this);
3135
3136 if (this->yuv2rgb_fun != NULL)
3137 printf ("yuv2rgb: using medialib for colorspace transform\n");
3138 }
3139#endif
3140 if (this->yuv2rgb_fun == NULL) {
3141 printf ("yuv2rgb: no accelerated colorspace conversion found\n");
3142 yuv2rgb_c_init (this);
3143 }
3144
3145 /*
3146 * auto-probe for the best yuy22rgb function
3147 */
3148
3149 /* FIXME: implement mmx/mlib functions */
3150 yuy22rgb_c_init (this);
3151
3152 /*
3153 * set up single pixel function
3154 */
3155
3156 yuv2rgb_single_pixel_init (this);
3157
3158 return this;
3159}
3160