This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_yuv_sw.c
1303 lines (1150 loc) · 40.5 KB
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.
14
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
#if 0 /* TODO */
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
87
/* 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"
88
#include "SDL_cpuinfo.h"
89
90
91
92
93
94
#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 = {
95
96
97
98
SDL_LockYUV_SW,
SDL_UnlockYUV_SW,
SDL_DisplayYUV_SW,
SDL_FreeYUV_SW
99
100
101
};
/* RGB conversion lookup tables */
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
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];
121
122
123
124
125
};
/* The colorspace conversion functions */
126
#if 0 /*defined(__GNUC__) && defined(__i386__) && SDL_ASSEMBLY_ROUTINES */
127
128
129
130
131
132
133
134
extern void Color565DitherYV12MMX1X(int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod);
extern void ColorRGBDitherYV12MMX1X(int *colortab, Uint32 * rgb_2_pix,
unsigned char *lum, unsigned char *cr,
unsigned char *cb, unsigned char *out,
int rows, int cols, int mod);
135
#endif
136
137
static void
138
139
140
141
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)
142
{
143
144
145
unsigned short *row1;
unsigned short *row2;
unsigned char *lum2;
146
147
148
149
150
151
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
152
row1 = (unsigned short *) out;
153
154
155
156
157
158
row2 = row1 + cols + mod;
lum2 = lum + cols;
mod += cols + mod;
y = rows / 2;
159
while (y--) {
160
x = cols_2;
161
while (x--) {
162
163
register int L;
164
165
166
167
168
169
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;
170
171
L = *lum++;
172
173
174
*row1++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
175
176
L = *lum++;
177
178
179
*row1++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
180
181
182
183
184
/* Now, do second row. */
L = *lum2++;
185
186
187
*row2++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
188
189
L = *lum2++;
190
191
192
*row2++ = (unsigned short) (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
193
194
195
196
197
198
199
}
/*
* 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
lum += cols;
201
202
203
204
205
206
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
207
static void
208
209
210
211
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)
212
213
{
unsigned int value;
214
215
216
unsigned char *row1;
unsigned char *row2;
unsigned char *lum2;
217
218
219
220
221
222
223
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
row1 = out;
224
row2 = row1 + cols * 3 + mod * 3;
225
226
227
228
229
230
lum2 = lum + cols;
mod += cols + mod;
mod *= 3;
y = rows / 2;
231
while (y--) {
232
x = cols_2;
233
while (x--) {
234
235
register int L;
236
237
238
239
240
241
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;
242
243
L = *lum++;
244
245
246
247
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;
248
249
250
*row1++ = (value >> 16) & 0xFF;
L = *lum++;
251
252
253
254
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;
255
256
257
258
259
260
*row1++ = (value >> 16) & 0xFF;
/* Now, do second row. */
L = *lum2++;
261
262
263
264
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;
265
266
267
*row2++ = (value >> 16) & 0xFF;
L = *lum2++;
268
269
270
271
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;
272
273
274
275
276
277
278
279
*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
lum += cols;
281
282
283
284
285
286
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
287
static void
288
289
290
291
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)
292
{
293
294
295
unsigned int *row1;
unsigned int *row2;
unsigned char *lum2;
296
297
298
299
300
301
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
302
row1 = (unsigned int *) out;
303
304
305
306
307
308
row2 = row1 + cols + mod;
lum2 = lum + cols;
mod += cols + mod;
y = rows / 2;
309
while (y--) {
310
x = cols_2;
311
while (x--) {
312
313
register int L;
314
315
316
317
318
319
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;
320
321
L = *lum++;
322
323
*row1++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
324
325
L = *lum++;
326
327
*row1++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
328
329
330
331
332
/* Now, do second row. */
L = *lum2++;
333
334
*row2++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
335
336
L = *lum2++;
337
338
*row2++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
339
340
341
342
343
344
345
}
/*
* 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
lum += cols;
347
348
349
350
351
352
353
354
355
356
357
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).
*/
358
static void
359
360
361
362
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)
363
{
364
365
366
367
unsigned int *row1 = (unsigned int *) out;
const int next_row = cols + (mod / 2);
unsigned int *row2 = row1 + 2 * next_row;
unsigned char *lum2;
368
369
370
371
372
373
374
375
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
lum2 = lum + cols;
376
mod = (next_row * 3) + (mod / 2);
377
378
y = rows / 2;
379
while (y--) {
380
x = cols_2;
381
while (x--) {
382
383
register int L;
384
385
386
387
388
389
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;
390
391
L = *lum++;
392
393
394
row1[0] = row1[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
395
396
397
row1++;
L = *lum++;
398
399
400
row1[0] = row1[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
401
402
403
404
405
406
row1++;
/* Now, do second row. */
L = *lum2++;
407
408
409
row2[0] = row2[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
410
411
412
row2++;
L = *lum2++;
413
414
415
row2[0] = row2[next_row] = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] |
rgb_2_pix[L + cb_b]);
416
417
418
419
420
421
422
423
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
lum += cols;
425
426
427
428
429
430
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
431
static void
432
433
434
435
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)
436
437
{
unsigned int value;
438
439
440
441
unsigned char *row1 = out;
const int next_row = (cols * 2 + mod) * 3;
unsigned char *row2 = row1 + 2 * next_row;
unsigned char *lum2;
442
443
444
445
446
447
448
449
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
lum2 = lum + cols;
450
mod = next_row * 3 + mod * 3;
451
452
y = rows / 2;
453
while (y--) {
454
x = cols_2;
455
while (x--) {
456
457
register int L;
458
459
460
461
462
463
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;
464
465
L = *lum++;
466
467
468
469
470
471
472
473
474
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;
475
476
L = *lum++;
477
478
479
480
481
482
483
484
485
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;
486
487
488
489
490
/* Now, do second row. */
L = *lum2++;
491
492
493
494
495
496
497
498
499
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;
500
501
L = *lum2++;
502
503
504
505
506
507
508
509
510
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;
511
512
513
514
515
516
517
}
/*
* 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
lum += cols;
519
520
521
522
523
524
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
525
static void
526
527
528
529
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)
530
{
531
532
533
534
unsigned int *row1 = (unsigned int *) out;
const int next_row = cols * 2 + mod;
unsigned int *row2 = row1 + 2 * next_row;
unsigned char *lum2;
535
536
537
538
539
540
541
542
543
544
545
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
while (y--) {
547
x = cols_2;
548
while (x--) {
549
550
register int L;
551
552
553
554
555
556
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;
557
558
L = *lum++;
559
560
561
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]);
562
563
564
row1 += 2;
L = *lum++;
565
566
567
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]);
568
569
570
571
572
573
row1 += 2;
/* Now, do second row. */
L = *lum2++;
574
575
576
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]);
577
578
579
row2 += 2;
L = *lum2++;
580
581
582
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]);
583
584
585
586
587
588
589
590
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
lum += cols;
592
593
594
595
596
597
lum2 += cols;
row1 += mod;
row2 += mod;
}
}
598
static void
599
600
601
602
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)
603
{
604
unsigned short *row;
605
606
607
608
609
610
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
611
row = (unsigned short *) out;
612
613
y = rows;
614
while (y--) {
615
x = cols_2;
616
while (x--) {
617
618
register int L;
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
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]);
637
638
639
640
641
642
643
}
row += mod;
}
}
644
static void
645
646
647
648
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)
649
650
{
unsigned int value;
651
unsigned char *row;
652
653
654
655
656
657
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
658
row = (unsigned char *) out;
659
660
mod *= 3;
y = rows;
661
while (y--) {
662
x = cols_2;
663
while (x--) {
664
665
register int L;
666
667
668
669
670
671
672
673
674
675
676
677
678
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;
679
680
*row++ = (value >> 16) & 0xFF;
681
682
683
684
685
686
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;
687
688
689
690
691
692
693
*row++ = (value >> 16) & 0xFF;
}
row += mod;
}
}
694
static void
695
696
697
698
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)
699
{
700
unsigned int *row;
701
702
703
704
705
706
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
707
row = (unsigned int *) out;
708
y = rows;
709
while (y--) {
710
x = cols_2;
711
while (x--) {
712
713
register int L;
714
715
716
717
718
719
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
724
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
729
L = *lum;
lum += 2;
*row++ = (rgb_2_pix[L + cr_r] |
rgb_2_pix[L + crb_g] | rgb_2_pix[L + cb_b]);
730
731
732
733
734
735
736
737
738
739
740
741
}
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).
*/
742
static void
743
744
745
746
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)
747
{
748
749
unsigned int *row = (unsigned int *) out;
const int next_row = cols + (mod / 2);
750
751
752
753
754
755
756
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
y = rows;
757
while (y--) {
758
x = cols_2;
759
while (x--) {
760
761
register int L;
762
763
764
765
766
767
768
769
770
771
772
773
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]);
774
775
row++;
776
777
778
779
780
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]);
781
782
783
784
785
786
787
row++;
}
row += next_row;
}
}
788
static void
789
790
791
792
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)
793
794
{
unsigned int value;
795
796
unsigned char *row = out;
const int next_row = (cols * 2 + mod) * 3;
797
798
799
800
801
802
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
y = rows;
803
while (y--) {
804
x = cols_2;
805
while (x--) {
806
807
register int L;
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
837
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;
838
839
840
841
842
843
}
row += next_row;
}
}
844
static void
845
846
847
848
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)
849
{
850
851
unsigned int *row = (unsigned int *) out;
const int next_row = cols * 2 + mod;
852
853
854
855
856
int x, y;
int cr_r;
int crb_g;
int cb_b;
int cols_2 = cols / 2;
857
mod += mod;
858
y = rows;
859
while (y--) {
860
x = cols_2;
861
while (x--) {
862
863
register int L;
864
865
866
867
868
869
870
871
872
873
874
875
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]);
876
877
row += 2;
878
879
880
881
882
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]);
883
884
885
886
887
888
889
890
891
892
893
894
895
row += 2;
}
row += next_row;
}
}
/*
* How many 1 bits are there in the Uint32.
* Low performance, do not call often.
*/
896
static int
897
number_of_bits_set(Uint32 a)
898
{
899
900
901
if (!a)
return 0;
if (a & 1)
902
903
return 1 + number_of_bits_set(a >> 1);
return (number_of_bits_set(a >> 1));
904
905
906
907
908
909
}
/*
* How many 0 bits are there at least significant end of Uint32.
* Low performance, do not call often.
*/
910
static int
911
free_bits_at_bottom(Uint32 a)
912
{
913
914
/* assume char is 8 bits */
if (!a)
915
return sizeof(Uint32) * 8;
916
917
if (((Sint32) a) & 1l)
return 0;
918
return 1 + free_bits_at_bottom(a >> 1);
919
920
921
}
922
SDL_Overlay *
923
924
SDL_CreateYUV_SW(_THIS, int width, int height, Uint32 format,
SDL_Surface * display)
925
{
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
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)) {
943
SDL_SetError("Can't use YUV data on non 16/24/32 bit surfaces");
944
945
946
947
948
949
950
951
952
953
954
955
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:
956
SDL_SetError("Unsupported YUV format");
957
958
959
960
return (NULL);
}
/* Create the overlay structure */
961
overlay = (SDL_Overlay *) SDL_malloc(sizeof *overlay);
962
if (overlay == NULL) {
963
SDL_OutOfMemory();
964
965
return (NULL);
}
966
SDL_memset(overlay, 0, (sizeof *overlay));
967
968
969
970
971
972
973
974
975
976
/* 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 */
977
swdata = (struct private_yuvhwdata *) SDL_malloc(sizeof *swdata);
978
979
overlay->hwdata = swdata;
if (swdata == NULL) {
980
981
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
982
983
984
985
return (NULL);
}
swdata->stretch = NULL;
swdata->display = display;
986
987
swdata->pixels = (Uint8 *) SDL_malloc(width * height * 2);
swdata->colortab = (int *) SDL_malloc(4 * 256 * sizeof(int));
988
989
990
991
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];
992
swdata->rgb_2_pix = (Uint32 *) SDL_malloc(3 * 768 * sizeof(Uint32));
993
994
995
996
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) {
997
998
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
999
1000
return (NULL);
}