This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_yuv_sw.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/* This is the software implementation of the YUV video overlay support */
/* This code was derived from code carrying the following copyright notices:
* Copyright (c) 1995 The Regents of the University of California.
* All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without written agreement is
* hereby granted, provided that the above copyright notice and the following
* two paragraphs appear in all copies of this software.
*
* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
* Copyright (c) 1995 Erik Corry
* All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without written agreement is
* hereby granted, provided that the above copyright notice and the following
* two paragraphs appear in all copies of this software.
*
* IN NO EVENT SHALL ERIK CORRY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
* SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
* THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF ERIK CORRY HAS BEEN ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ERIK CORRY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
* BASIS, AND ERIK CORRY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,
* UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
* Portions of this software Copyright (c) 1995 Brown University.
* All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without written agreement
* is hereby granted, provided that the above copyright notice and the
* following two paragraphs appear in all copies of this software.
*
* IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN
* UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
* BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
* SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
#include "SDL_video.h"
87
#include "SDL_cpuinfo.h"
88
89
90
91
92
93
#include "SDL_stretch_c.h"
#include "SDL_yuvfuncs.h"
#include "SDL_yuv_sw_c.h"
/* The functions used to manipulate software video overlays */
static struct private_yuvhwfuncs sw_yuvfuncs = {
94
95
96
97
SDL_LockYUV_SW,
SDL_UnlockYUV_SW,
SDL_DisplayYUV_SW,
SDL_FreeYUV_SW
98
99
100
};
/* RGB conversion lookup tables */
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
struct private_yuvhwdata
{
SDL_Surface *stretch;
SDL_Surface *display;
Uint8 *pixels;
int *colortab;
Uint32 *rgb_2_pix;
void (*Display1X) (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod);
void (*Display2X) (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod);
/* These are just so we don't have to allocate them separately */
Uint16 pitches[3];
Uint8 *planes[3];
120
121
122
123
124
};
/* The colorspace conversion functions */
125
126
#if 0 /*defined(__GNUC__) && defined(__i386__) && SDL_ASSEMBLY_ROUTINES */
extern void Color565DitherYV12MMX1X (int *colortab, Uint32 * rgb_2_pix,
127
128
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
129
130
int rows, int cols, int mod);
extern void ColorRGBDitherYV12MMX1X (int *colortab, Uint32 * rgb_2_pix,
131
132
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
133
134
int rows, int cols, int mod);
#endif
136
137
138
139
140
static void
Color16DitherYV12Mod1X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
141
{
142
143
144
unsigned short *row1;
unsigned short *row2;
unsigned char *lum2;
145
146
147
148
149
150
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
151
row1 = (unsigned short *) out;
152
153
154
155
156
157
row2 = row1 + cols + mod;
lum2 = lum + cols;
mod += cols + mod;
y = rows / 2;
159
x = cols_2;
161
162
register int L;
163
164
165
166
167
168
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
++cr;
++cb;
169
170
L = *lum++;
171
172
173
*row1++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
174
175
L = *lum++;
176
177
178
*row1++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
179
180
181
182
183
/* Now, do second row. */
L = *lum2++;
184
185
186
*row2++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
187
188
L = *lum2++;
189
190
191
*row2++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
192
193
194
195
196
197
198
}
/*
* These values are at the start of the next line, (due
* to the ++'s above),but they need to be at the start
* of the line after that.
*/
200
201
202
203
204
205
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
206
207
208
209
210
static void
Color24DitherYV12Mod1X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
211
212
{
unsigned int value;
213
214
215
unsigned char *row1;
unsigned char *row2;
unsigned char *lum2;
216
217
218
219
220
221
222
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
row1 = out;
223
row2 = row1 + cols * 3 + mod * 3;
224
225
226
227
228
229
lum2 = lum + cols;
mod += cols + mod;
mod *= 3;
y = rows / 2;
231
x = cols_2;
233
234
register int L;
235
236
237
238
239
240
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
++cr;
++cb;
241
242
L = *lum++;
243
244
245
246
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
*row1++ = (value) & 0xFF;
*row1++ = (value >> 8) & 0xFF;
247
248
249
*row1++ = (value >> 16) & 0xFF;
L = *lum++;
250
251
252
253
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
*row1++ = (value) & 0xFF;
*row1++ = (value >> 8) & 0xFF;
254
255
256
257
258
259
*row1++ = (value >> 16) & 0xFF;
/* Now, do second row. */
L = *lum2++;
260
261
262
263
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
*row2++ = (value) & 0xFF;
*row2++ = (value >> 8) & 0xFF;
264
265
266
*row2++ = (value >> 16) & 0xFF;
L = *lum2++;
267
268
269
270
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
*row2++ = (value) & 0xFF;
*row2++ = (value >> 8) & 0xFF;
271
272
273
274
275
276
277
278
*row2++ = (value >> 16) & 0xFF;
}
/*
* These values are at the start of the next line, (due
* to the ++'s above),but they need to be at the start
* of the line after that.
*/
280
281
282
283
284
285
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
286
287
288
289
290
static void
Color32DitherYV12Mod1X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
291
{
292
293
294
unsigned int *row1;
unsigned int *row2;
unsigned char *lum2;
295
296
297
298
299
300
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
301
row1 = (unsigned int *) out;
302
303
304
305
306
307
row2 = row1 + cols + mod;
lum2 = lum + cols;
mod += cols + mod;
y = rows / 2;
309
x = cols_2;
311
312
register int L;
313
314
315
316
317
318
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
++cr;
++cb;
319
320
L = *lum++;
321
322
*row1++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
323
324
L = *lum++;
325
326
*row1++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
327
328
329
330
331
/* Now, do second row. */
L = *lum2++;
332
333
*row2++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
334
335
L = *lum2++;
336
337
*row2++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
338
339
340
341
342
343
344
}
/*
* These values are at the start of the next line, (due
* to the ++'s above),but they need to be at the start
* of the line after that.
*/
346
347
348
349
350
351
352
353
354
355
356
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
/*
* In this function I make use of a nasty trick. The tables have the lower
* 16 bits replicated in the upper 16. This means I can write ints and get
* the horisontal doubling for free (almost).
*/
357
358
359
360
361
static void
Color16DitherYV12Mod2X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
362
{
363
364
365
366
unsigned int *row1 = (unsigned int *) out;
const int next_row = cols + (mod / 2);
unsigned int *row2 = row1 + 2 * next_row;
unsigned char *lum2;
367
368
369
370
371
372
373
374
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
lum2 = lum + cols;
375
mod = (next_row * 3) + (mod / 2);
376
377
y = rows / 2;
379
x = cols_2;
381
382
register int L;
383
384
385
386
387
388
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
++cr;
++cb;
389
390
L = *lum++;
391
392
393
row1[0] = row1[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
394
395
396
row1++;
L = *lum++;
397
398
399
row1[0] = row1[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
400
401
402
403
404
405
row1++;
/* Now, do second row. */
L = *lum2++;
406
407
408
row2[0] = row2[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
409
410
411
row2++;
L = *lum2++;
412
413
414
row2[0] = row2[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
415
416
417
418
419
420
421
422
row2++;
}
/*
* These values are at the start of the next line, (due
* to the ++'s above),but they need to be at the start
* of the line after that.
*/
424
425
426
427
428
429
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
430
431
432
433
434
static void
Color24DitherYV12Mod2X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
435
436
{
unsigned int value;
437
438
439
440
unsigned char *row1 = out;
const int next_row = (cols * 2 + mod) * 3;
unsigned char *row2 = row1 + 2 * next_row;
unsigned char *lum2;
441
442
443
444
445
446
447
448
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
lum2 = lum + cols;
449
mod = next_row * 3 + mod * 3;
450
451
y = rows / 2;
453
x = cols_2;
455
456
register int L;
457
458
459
460
461
462
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
++cr;
++cb;
463
464
L = *lum++;
465
466
467
468
469
470
471
472
473
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
row1[0 + 0] = row1[3 + 0] = row1[next_row + 0] =
row1[next_row + 3 + 0] = (value) & 0xFF;
row1[0 + 1] = row1[3 + 1] = row1[next_row + 1] =
row1[next_row + 3 + 1] = (value >> 8) & 0xFF;
row1[0 + 2] = row1[3 + 2] = row1[next_row + 2] =
row1[next_row + 3 + 2] = (value >> 16) & 0xFF;
row1 += 2 * 3;
474
475
L = *lum++;
476
477
478
479
480
481
482
483
484
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
row1[0 + 0] = row1[3 + 0] = row1[next_row + 0] =
row1[next_row + 3 + 0] = (value) & 0xFF;
row1[0 + 1] = row1[3 + 1] = row1[next_row + 1] =
row1[next_row + 3 + 1] = (value >> 8) & 0xFF;
row1[0 + 2] = row1[3 + 2] = row1[next_row + 2] =
row1[next_row + 3 + 2] = (value >> 16) & 0xFF;
row1 += 2 * 3;
485
486
487
488
489
/* Now, do second row. */
L = *lum2++;
490
491
492
493
494
495
496
497
498
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
row2[0 + 0] = row2[3 + 0] = row2[next_row + 0] =
row2[next_row + 3 + 0] = (value) & 0xFF;
row2[0 + 1] = row2[3 + 1] = row2[next_row + 1] =
row2[next_row + 3 + 1] = (value >> 8) & 0xFF;
row2[0 + 2] = row2[3 + 2] = row2[next_row + 2] =
row2[next_row + 3 + 2] = (value >> 16) & 0xFF;
row2 += 2 * 3;
499
500
L = *lum2++;
501
502
503
504
505
506
507
508
509
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
row2[0 + 0] = row2[3 + 0] = row2[next_row + 0] =
row2[next_row + 3 + 0] = (value) & 0xFF;
row2[0 + 1] = row2[3 + 1] = row2[next_row + 1] =
row2[next_row + 3 + 1] = (value >> 8) & 0xFF;
row2[0 + 2] = row2[3 + 2] = row2[next_row + 2] =
row2[next_row + 3 + 2] = (value >> 16) & 0xFF;
row2 += 2 * 3;
510
511
512
513
514
515
516
}
/*
* These values are at the start of the next line, (due
* to the ++'s above),but they need to be at the start
* of the line after that.
*/
518
519
520
521
522
523
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
524
525
526
527
528
static void
Color32DitherYV12Mod2X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
529
{
530
531
532
533
unsigned int *row1 = (unsigned int *) out;
const int next_row = cols * 2 + mod;
unsigned int *row2 = row1 + 2 * next_row;
unsigned char *lum2;
534
535
536
537
538
539
540
541
542
543
544
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
lum2 = lum + cols;
mod = (next_row * 3) + mod;
y = rows / 2;
546
x = cols_2;
548
549
register int L;
550
551
552
553
554
555
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
++cr;
++cb;
556
557
L = *lum++;
558
559
560
row1[0] = row1[1] = row1[next_row] = row1[next_row + 1] =
(rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
561
562
563
row1 += 2;
L = *lum++;
564
565
566
row1[0] = row1[1] = row1[next_row] = row1[next_row + 1] =
(rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
567
568
569
570
571
572
row1 += 2;
/* Now, do second row. */
L = *lum2++;
573
574
575
row2[0] = row2[1] = row2[next_row] = row2[next_row + 1] =
(rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
576
577
578
row2 += 2;
L = *lum2++;
579
580
581
row2[0] = row2[1] = row2[next_row] = row2[next_row + 1] =
(rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
582
583
584
585
586
587
588
589
row2 += 2;
}
/*
* These values are at the start of the next line, (due
* to the ++'s above),but they need to be at the start
* of the line after that.
*/
591
592
593
594
595
596
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
597
598
599
600
601
static void
Color16DitherYUY2Mod1X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
602
{
603
unsigned short *row;
604
605
606
607
608
609
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
610
row = (unsigned short *) out;
611
612
y = rows;
614
x = cols_2;
616
617
register int L;
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
cr += 4;
cb += 4;
L = *lum;
lum += 2;
*row++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
L = *lum;
lum += 2;
*row++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
636
637
638
639
640
641
642
}
row += mod;
}
}
643
644
645
646
647
static void
Color24DitherYUY2Mod1X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
648
649
{
unsigned int value;
650
unsigned char *row;
651
652
653
654
655
656
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
657
row = (unsigned char *) out;
658
659
mod *= 3;
y = rows;
661
x = cols_2;
663
664
register int L;
665
666
667
668
669
670
671
672
673
674
675
676
677
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
cr += 4;
cb += 4;
L = *lum;
lum += 2;
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
*row++ = (value) & 0xFF;
*row++ = (value >> 8) & 0xFF;
678
679
*row++ = (value >> 16) & 0xFF;
680
681
682
683
684
685
L = *lum;
lum += 2;
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
*row++ = (value) & 0xFF;
*row++ = (value >> 8) & 0xFF;
686
687
688
689
690
691
692
*row++ = (value >> 16) & 0xFF;
}
row += mod;
}
}
693
694
695
696
697
static void
Color32DitherYUY2Mod1X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
698
{
699
unsigned int *row;
700
701
702
703
704
705
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
706
row = (unsigned int *) out;
707
y = rows;
709
x = cols_2;
711
712
register int L;
713
714
715
716
717
718
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
cr += 4;
cb += 4;
720
721
722
723
L = *lum;
lum += 2;
*row++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
725
726
727
728
L = *lum;
lum += 2;
*row++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
729
730
731
732
733
734
735
736
737
738
739
740
}
row += mod;
}
}
/*
* In this function I make use of a nasty trick. The tables have the lower
* 16 bits replicated in the upper 16. This means I can write ints and get
* the horisontal doubling for free (almost).
*/
741
742
743
744
745
static void
Color16DitherYUY2Mod2X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
746
{
747
748
unsigned int *row = (unsigned int *) out;
const int next_row = cols + (mod / 2);
749
750
751
752
753
754
755
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
y = rows;
757
x = cols_2;
759
760
register int L;
761
762
763
764
765
766
767
768
769
770
771
772
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
cr += 4;
cb += 4;
L = *lum;
lum += 2;
row[0] = row[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
773
774
row++;
775
776
777
778
779
L = *lum;
lum += 2;
row[0] = row[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
780
781
782
783
784
785
786
row++;
}
row += next_row;
}
}
787
788
789
790
791
static void
Color24DitherYUY2Mod2X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
792
793
{
unsigned int value;
794
795
unsigned char *row = out;
const int next_row = (cols * 2 + mod) * 3;
796
797
798
799
800
801
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
y = rows;
803
x = cols_2;
805
806
register int L;
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
cr += 4;
cb += 4;
L = *lum;
lum += 2;
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
row[0 + 0] = row[3 + 0] = row[next_row + 0] =
row[next_row + 3 + 0] = (value) & 0xFF;
row[0 + 1] = row[3 + 1] = row[next_row + 1] =
row[next_row + 3 + 1] = (value >> 8) & 0xFF;
row[0 + 2] = row[3 + 2] = row[next_row + 2] =
row[next_row + 3 + 2] = (value >> 16) & 0xFF;
row += 2 * 3;
L = *lum;
lum += 2;
value = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
row[0 + 0] = row[3 + 0] = row[next_row + 0] =
row[next_row + 3 + 0] = (value) & 0xFF;
row[0 + 1] = row[3 + 1] = row[next_row + 1] =
row[next_row + 3 + 1] = (value >> 8) & 0xFF;
row[0 + 2] = row[3 + 2] = row[next_row + 2] =
row[next_row + 3 + 2] = (value >> 16) & 0xFF;
row += 2 * 3;
837
838
839
840
841
842
}
row += next_row;
}
}
843
844
845
846
847
static void
Color32DitherYUY2Mod2X (int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod)
848
{
849
850
unsigned int *row = (unsigned int *) out;
const int next_row = cols * 2 + mod;
851
852
853
854
855
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
857
y = rows;
859
x = cols_2;
861
862
register int L;
863
864
865
866
867
868
869
870
871
872
873
874
cr_r = 0 * 768 + 256 + colortab[*cr + 0 * 256];
crb_g = 1 * 768 + 256 + colortab[*cr + 1 * 256]
+ colortab[*cb + 2 * 256];
cb_b = 2 * 768 + 256 + colortab[*cb + 3 * 256];
cr += 4;
cb += 4;
L = *lum;
lum += 2;
row[0] = row[1] = row[next_row] = row[next_row + 1] =
(rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
875
876
row += 2;
877
878
879
880
881
L = *lum;
lum += 2;
row[0] = row[1] = row[next_row] = row[next_row + 1] =
(rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
882
883
884
885
886
887
888
889
890
891
892
893
894
row += 2;
}
row += next_row;
}
}
/*
* How many 1 bits are there in the Uint32.
* Low performance, do not call often.
*/
895
896
static int
number_of_bits_set (Uint32 a)
897
{
898
899
900
901
902
if (!a)
return 0;
if (a & 1)
return 1 + number_of_bits_set (a >> 1);
return (number_of_bits_set (a >> 1));
903
904
905
906
907
908
}
/*
* How many 0 bits are there at least significant end of Uint32.
* Low performance, do not call often.
*/
909
910
static int
free_bits_at_bottom (Uint32 a)
911
{
912
913
914
915
916
917
/* assume char is 8 bits */
if (!a)
return sizeof (Uint32) * 8;
if (((Sint32) a) & 1l)
return 0;
return 1 + free_bits_at_bottom (a >> 1);
918
919
920
}
921
922
923
SDL_Overlay *
SDL_CreateYUV_SW (_THIS, int width, int height, Uint32 format,
SDL_Surface * display)
924
{
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
SDL_Overlay *overlay;
struct private_yuvhwdata *swdata;
int *Cr_r_tab;
int *Cr_g_tab;
int *Cb_g_tab;
int *Cb_b_tab;
Uint32 *r_2_pix_alloc;
Uint32 *g_2_pix_alloc;
Uint32 *b_2_pix_alloc;
int i;
int CR, CB;
Uint32 Rmask, Gmask, Bmask;
/* Only RGB packed pixel conversion supported */
if ((display->format->BytesPerPixel != 2) &&
(display->format->BytesPerPixel != 3) &&
(display->format->BytesPerPixel != 4)) {
SDL_SetError ("Can't use YUV data on non 16/24/32 bit surfaces");
return (NULL);
}
/* Verify that we support the format */
switch (format) {
case SDL_YV12_OVERLAY:
case SDL_IYUV_OVERLAY:
case SDL_YUY2_OVERLAY:
case SDL_UYVY_OVERLAY:
case SDL_YVYU_OVERLAY:
break;
default:
SDL_SetError ("Unsupported YUV format");
return (NULL);
}
/* Create the overlay structure */
overlay = (SDL_Overlay *) SDL_malloc (sizeof *overlay);
if (overlay == NULL) {
SDL_OutOfMemory ();
return (NULL);
}
SDL_memset (overlay, 0, (sizeof *overlay));
/* Fill in the basic members */
overlay->format = format;
overlay->w = width;
overlay->h = height;
/* Set up the YUV surface function structure */
overlay->hwfuncs = &sw_yuvfuncs;
/* Create the pixel data and lookup tables */
swdata = (struct private_yuvhwdata *) SDL_malloc (sizeof *swdata);
overlay->hwdata = swdata;
if (swdata == NULL) {
SDL_OutOfMemory ();
SDL_FreeYUVOverlay (overlay);
return (NULL);
}
swdata->stretch = NULL;
swdata->display = display;
swdata->pixels = (Uint8 *) SDL_malloc (width * height * 2);
swdata->colortab = (int *) SDL_malloc (4 * 256 * sizeof (int));
Cr_r_tab = &swdata->colortab[0 * 256];
Cr_g_tab = &swdata->colortab[1 * 256];
Cb_g_tab = &swdata->colortab[2 * 256];
Cb_b_tab = &swdata->colortab[3 * 256];
swdata->rgb_2_pix = (Uint32 *) SDL_malloc (3 * 768 * sizeof (Uint32));
r_2_pix_alloc = &swdata->rgb_2_pix[0 * 768];
g_2_pix_alloc = &swdata->rgb_2_pix[1 * 768];
b_2_pix_alloc = &swdata->rgb_2_pix[2 * 768];
if (!swdata->pixels || !swdata->colortab || !swdata->rgb_2_pix) {
SDL_OutOfMemory ();
SDL_FreeYUVOverlay (overlay);
return (NULL);
}