← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to extras/ffmpeg/libavcodec/imgconvert_template.h

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
extras/ffmpeg/libavcodec/imgconvert_template.h
 
1
/*
 
2
 * Templates for image convertion routines
 
3
 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
 
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 of the License, or (at your option) any later version.
 
9
 *
 
10
 * This library is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
 * Lesser General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU Lesser General Public
 
16
 * License along with this library; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 */
 
19
 
 
20
#ifndef RGB_OUT
 
21
#define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xff)
 
22
#endif
 
23
 
 
24
static void glue(yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 
25
                                        int width, int height)
 
26
{
 
27
    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
 
28
    uint8_t *d, *d1, *d2;
 
29
    int w, y, cb, cr, r_add, g_add, b_add, width2;
 
30
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
31
    unsigned int r, g, b;
 
32
 
 
33
    d = dst->data[0];
 
34
    y1_ptr = src->data[0];
 
35
    cb_ptr = src->data[1];
 
36
    cr_ptr = src->data[2];
 
37
    width2 = (width + 1) >> 1;
 
38
    for(;height >= 2; height -= 2) {
 
39
        d1 = d;
 
40
        d2 = d + dst->linesize[0];
 
41
        y2_ptr = y1_ptr + src->linesize[0];
 
42
        for(w = width; w >= 2; w -= 2) {
 
43
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
 
44
            /* output 4 pixels */
 
45
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
 
46
            RGB_OUT(d1, r, g, b);
 
47
 
 
48
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);
 
49
            RGB_OUT(d1 + BPP, r, g, b);
 
50
 
 
51
            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);
 
52
            RGB_OUT(d2, r, g, b);
 
53
 
 
54
            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[1]);
 
55
            RGB_OUT(d2 + BPP, r, g, b);
 
56
 
 
57
            d1 += 2 * BPP;
 
58
            d2 += 2 * BPP;
 
59
 
 
60
            y1_ptr += 2;
 
61
            y2_ptr += 2;
 
62
            cb_ptr++;
 
63
            cr_ptr++;
 
64
        }
 
65
        /* handle odd width */
 
66
        if (w) {
 
67
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
 
68
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
 
69
            RGB_OUT(d1, r, g, b);
 
70
 
 
71
            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);
 
72
            RGB_OUT(d2, r, g, b);
 
73
            d1 += BPP;
 
74
            d2 += BPP;
 
75
            y1_ptr++;
 
76
            y2_ptr++;
 
77
            cb_ptr++;
 
78
            cr_ptr++;
 
79
        }
 
80
        d += 2 * dst->linesize[0];
 
81
        y1_ptr += 2 * src->linesize[0] - width;
 
82
        cb_ptr += src->linesize[1] - width2;
 
83
        cr_ptr += src->linesize[2] - width2;
 
84
    }
 
85
    /* handle odd height */
 
86
    if (height) {
 
87
        d1 = d;
 
88
        for(w = width; w >= 2; w -= 2) {
 
89
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
 
90
            /* output 2 pixels */
 
91
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
 
92
            RGB_OUT(d1, r, g, b);
 
93
 
 
94
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);
 
95
            RGB_OUT(d1 + BPP, r, g, b);
 
96
 
 
97
            d1 += 2 * BPP;
 
98
 
 
99
            y1_ptr += 2;
 
100
            cb_ptr++;
 
101
            cr_ptr++;
 
102
        }
 
103
        /* handle width */
 
104
        if (w) {
 
105
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
 
106
            /* output 2 pixels */
 
107
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
 
108
            RGB_OUT(d1, r, g, b);
 
109
            d1 += BPP;
 
110
 
 
111
            y1_ptr++;
 
112
            cb_ptr++;
 
113
            cr_ptr++;
 
114
        }
 
115
    }
 
116
}
 
117
 
 
118
static void glue(yuvj420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 
119
                                         int width, int height)
 
120
{
 
121
    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
 
122
    uint8_t *d, *d1, *d2;
 
123
    int w, y, cb, cr, r_add, g_add, b_add, width2;
 
124
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
125
    unsigned int r, g, b;
 
126
 
 
127
    d = dst->data[0];
 
128
    y1_ptr = src->data[0];
 
129
    cb_ptr = src->data[1];
 
130
    cr_ptr = src->data[2];
 
131
    width2 = (width + 1) >> 1;
 
132
    for(;height >= 2; height -= 2) {
 
133
        d1 = d;
 
134
        d2 = d + dst->linesize[0];
 
135
        y2_ptr = y1_ptr + src->linesize[0];
 
136
        for(w = width; w >= 2; w -= 2) {
 
137
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
 
138
            /* output 4 pixels */
 
139
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
 
140
            RGB_OUT(d1, r, g, b);
 
141
 
 
142
            YUV_TO_RGB2(r, g, b, y1_ptr[1]);
 
143
            RGB_OUT(d1 + BPP, r, g, b);
 
144
 
 
145
            YUV_TO_RGB2(r, g, b, y2_ptr[0]);
 
146
            RGB_OUT(d2, r, g, b);
 
147
 
 
148
            YUV_TO_RGB2(r, g, b, y2_ptr[1]);
 
149
            RGB_OUT(d2 + BPP, r, g, b);
 
150
 
 
151
            d1 += 2 * BPP;
 
152
            d2 += 2 * BPP;
 
153
 
 
154
            y1_ptr += 2;
 
155
            y2_ptr += 2;
 
156
            cb_ptr++;
 
157
            cr_ptr++;
 
158
        }
 
159
        /* handle odd width */
 
160
        if (w) {
 
161
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
 
162
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
 
163
            RGB_OUT(d1, r, g, b);
 
164
 
 
165
            YUV_TO_RGB2(r, g, b, y2_ptr[0]);
 
166
            RGB_OUT(d2, r, g, b);
 
167
            d1 += BPP;
 
168
            d2 += BPP;
 
169
            y1_ptr++;
 
170
            y2_ptr++;
 
171
            cb_ptr++;
 
172
            cr_ptr++;
 
173
        }
 
174
        d += 2 * dst->linesize[0];
 
175
        y1_ptr += 2 * src->linesize[0] - width;
 
176
        cb_ptr += src->linesize[1] - width2;
 
177
        cr_ptr += src->linesize[2] - width2;
 
178
    }
 
179
    /* handle odd height */
 
180
    if (height) {
 
181
        d1 = d;
 
182
        for(w = width; w >= 2; w -= 2) {
 
183
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
 
184
            /* output 2 pixels */
 
185
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
 
186
            RGB_OUT(d1, r, g, b);
 
187
 
 
188
            YUV_TO_RGB2(r, g, b, y1_ptr[1]);
 
189
            RGB_OUT(d1 + BPP, r, g, b);
 
190
 
 
191
            d1 += 2 * BPP;
 
192
 
 
193
            y1_ptr += 2;
 
194
            cb_ptr++;
 
195
            cr_ptr++;
 
196
        }
 
197
        /* handle width */
 
198
        if (w) {
 
199
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
 
200
            /* output 2 pixels */
 
201
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
 
202
            RGB_OUT(d1, r, g, b);
 
203
            d1 += BPP;
 
204
 
 
205
            y1_ptr++;
 
206
            cb_ptr++;
 
207
            cr_ptr++;
 
208
        }
 
209
    }
 
210
}
 
211
 
 
212
static void glue(RGB_NAME, _to_yuv420p)(AVPicture *dst, const AVPicture *src,
 
213
                                        int width, int height)
 
214
{
 
215
    int wrap, wrap3, width2;
 
216
    int r, g, b, r1, g1, b1, w;
 
217
    uint8_t *lum, *cb, *cr;
 
218
    const uint8_t *p;
 
219
 
 
220
    lum = dst->data[0];
 
221
    cb = dst->data[1];
 
222
    cr = dst->data[2];
 
223
 
 
224
    width2 = (width + 1) >> 1;
 
225
    wrap = dst->linesize[0];
 
226
    wrap3 = src->linesize[0];
 
227
    p = src->data[0];
 
228
    for(;height>=2;height -= 2) {
 
229
        for(w = width; w >= 2; w -= 2) {
 
230
            RGB_IN(r, g, b, p);
 
231
            r1 = r;
 
232
            g1 = g;
 
233
            b1 = b;
 
234
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
235
 
 
236
            RGB_IN(r, g, b, p + BPP);
 
237
            r1 += r;
 
238
            g1 += g;
 
239
            b1 += b;
 
240
            lum[1] = RGB_TO_Y_CCIR(r, g, b);
 
241
            p += wrap3;
 
242
            lum += wrap;
 
243
 
 
244
            RGB_IN(r, g, b, p);
 
245
            r1 += r;
 
246
            g1 += g;
 
247
            b1 += b;
 
248
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
249
 
 
250
            RGB_IN(r, g, b, p + BPP);
 
251
            r1 += r;
 
252
            g1 += g;
 
253
            b1 += b;
 
254
            lum[1] = RGB_TO_Y_CCIR(r, g, b);
 
255
 
 
256
            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 2);
 
257
            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 2);
 
258
 
 
259
            cb++;
 
260
            cr++;
 
261
            p += -wrap3 + 2 * BPP;
 
262
            lum += -wrap + 2;
 
263
        }
 
264
        if (w) {
 
265
            RGB_IN(r, g, b, p);
 
266
            r1 = r;
 
267
            g1 = g;
 
268
            b1 = b;
 
269
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
270
            p += wrap3;
 
271
            lum += wrap;
 
272
            RGB_IN(r, g, b, p);
 
273
            r1 += r;
 
274
            g1 += g;
 
275
            b1 += b;
 
276
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
277
            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);
 
278
            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);
 
279
            cb++;
 
280
            cr++;
 
281
            p += -wrap3 + BPP;
 
282
            lum += -wrap + 1;
 
283
        }
 
284
        p += wrap3 + (wrap3 - width * BPP);
 
285
        lum += wrap + (wrap - width);
 
286
        cb += dst->linesize[1] - width2;
 
287
        cr += dst->linesize[2] - width2;
 
288
    }
 
289
    /* handle odd height */
 
290
    if (height) {
 
291
        for(w = width; w >= 2; w -= 2) {
 
292
            RGB_IN(r, g, b, p);
 
293
            r1 = r;
 
294
            g1 = g;
 
295
            b1 = b;
 
296
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
297
 
 
298
            RGB_IN(r, g, b, p + BPP);
 
299
            r1 += r;
 
300
            g1 += g;
 
301
            b1 += b;
 
302
            lum[1] = RGB_TO_Y_CCIR(r, g, b);
 
303
            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);
 
304
            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);
 
305
            cb++;
 
306
            cr++;
 
307
            p += 2 * BPP;
 
308
           lum += 2;
 
309
        }
 
310
        if (w) {
 
311
            RGB_IN(r, g, b, p);
 
312
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
313
            cb[0] = RGB_TO_U_CCIR(r, g, b, 0);
 
314
            cr[0] = RGB_TO_V_CCIR(r, g, b, 0);
 
315
        }
 
316
    }
 
317
}
 
318
 
 
319
static void glue(RGB_NAME, _to_gray)(AVPicture *dst, const AVPicture *src,
 
320
                                     int width, int height)
 
321
{
 
322
    const unsigned char *p;
 
323
    unsigned char *q;
 
324
    int r, g, b, dst_wrap, src_wrap;
 
325
    int x, y;
 
326
 
 
327
    p = src->data[0];
 
328
    src_wrap = src->linesize[0] - BPP * width;
 
329
 
 
330
    q = dst->data[0];
 
331
    dst_wrap = dst->linesize[0] - width;
 
332
 
 
333
    for(y=0;y<height;y++) {
 
334
        for(x=0;x<width;x++) {
 
335
            RGB_IN(r, g, b, p);
 
336
            q[0] = RGB_TO_Y(r, g, b);
 
337
            q++;
 
338
            p += BPP;
 
339
        }
 
340
        p += src_wrap;
 
341
        q += dst_wrap;
 
342
    }
 
343
}
 
344
 
 
345
static void glue(gray_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 
346
                                     int width, int height)
 
347
{
 
348
    const unsigned char *p;
 
349
    unsigned char *q;
 
350
    int r, dst_wrap, src_wrap;
 
351
    int x, y;
 
352
 
 
353
    p = src->data[0];
 
354
    src_wrap = src->linesize[0] - width;
 
355
 
 
356
    q = dst->data[0];
 
357
    dst_wrap = dst->linesize[0] - BPP * width;
 
358
 
 
359
    for(y=0;y<height;y++) {
 
360
        for(x=0;x<width;x++) {
 
361
            r = p[0];
 
362
            RGB_OUT(q, r, r, r);
 
363
            q += BPP;
 
364
            p ++;
 
365
        }
 
366
        p += src_wrap;
 
367
        q += dst_wrap;
 
368
    }
 
369
}
 
370
 
 
371
static void glue(pal8_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 
372
                                     int width, int height)
 
373
{
 
374
    const unsigned char *p;
 
375
    unsigned char *q;
 
376
    int r, g, b, dst_wrap, src_wrap;
 
377
    int x, y;
 
378
    uint32_t v;
 
379
    const uint32_t *palette;
 
380
 
 
381
    p = src->data[0];
 
382
    src_wrap = src->linesize[0] - width;
 
383
    palette = (uint32_t *)src->data[1];
 
384
 
 
385
    q = dst->data[0];
 
386
    dst_wrap = dst->linesize[0] - BPP * width;
 
387
 
 
388
    for(y=0;y<height;y++) {
 
389
        for(x=0;x<width;x++) {
 
390
            v = palette[p[0]];
 
391
            r = (v >> 16) & 0xff;
 
392
            g = (v >> 8) & 0xff;
 
393
            b = (v) & 0xff;
 
394
#ifdef RGBA_OUT
 
395
            {
 
396
                int a;
 
397
                a = (v >> 24) & 0xff;
 
398
                RGBA_OUT(q, r, g, b, a);
 
399
            }
 
400
#else
 
401
            RGB_OUT(q, r, g, b);
 
402
#endif
 
403
            q += BPP;
 
404
            p ++;
 
405
        }
 
406
        p += src_wrap;
 
407
        q += dst_wrap;
 
408
    }
 
409
}
 
410
 
 
411
#if !defined(FMT_RGBA32) && defined(RGBA_OUT)
 
412
/* alpha support */
 
413
 
 
414
static void glue(rgba32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 
415
                                      int width, int height)
 
416
{
 
417
    const uint8_t *s;
 
418
    uint8_t *d;
 
419
    int src_wrap, dst_wrap, j, y;
 
420
    unsigned int v, r, g, b, a;
 
421
 
 
422
    s = src->data[0];
 
423
    src_wrap = src->linesize[0] - width * 4;
 
424
 
 
425
    d = dst->data[0];
 
426
    dst_wrap = dst->linesize[0] - width * BPP;
 
427
 
 
428
    for(y=0;y<height;y++) {
 
429
        for(j = 0;j < width; j++) {
 
430
            v = ((const uint32_t *)(s))[0];
 
431
            a = (v >> 24) & 0xff;
 
432
            r = (v >> 16) & 0xff;
 
433
            g = (v >> 8) & 0xff;
 
434
            b = v & 0xff;
 
435
            RGBA_OUT(d, r, g, b, a);
 
436
            s += 4;
 
437
            d += BPP;
 
438
        }
 
439
        s += src_wrap;
 
440
        d += dst_wrap;
 
441
    }
 
442
}
 
443
 
 
444
static void glue(RGB_NAME, _to_rgba32)(AVPicture *dst, const AVPicture *src,
 
445
                                       int width, int height)
 
446
{
 
447
    const uint8_t *s;
 
448
    uint8_t *d;
 
449
    int src_wrap, dst_wrap, j, y;
 
450
    unsigned int r, g, b, a;
 
451
 
 
452
    s = src->data[0];
 
453
    src_wrap = src->linesize[0] - width * BPP;
 
454
 
 
455
    d = dst->data[0];
 
456
    dst_wrap = dst->linesize[0] - width * 4;
 
457
 
 
458
    for(y=0;y<height;y++) {
 
459
        for(j = 0;j < width; j++) {
 
460
            RGBA_IN(r, g, b, a, s);
 
461
            ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
 
462
            d += 4;
 
463
            s += BPP;
 
464
        }
 
465
        s += src_wrap;
 
466
        d += dst_wrap;
 
467
    }
 
468
}
 
469
 
 
470
#endif /* !defined(FMT_RGBA32) && defined(RGBA_IN) */
 
471
 
 
472
#ifndef FMT_RGB24
 
473
 
 
474
static void glue(rgb24_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 
475
                                      int width, int height)
 
476
{
 
477
    const uint8_t *s;
 
478
    uint8_t *d;
 
479
    int src_wrap, dst_wrap, j, y;
 
480
    unsigned int r, g, b;
 
481
 
 
482
    s = src->data[0];
 
483
    src_wrap = src->linesize[0] - width * 3;
 
484
 
 
485
    d = dst->data[0];
 
486
    dst_wrap = dst->linesize[0] - width * BPP;
 
487
 
 
488
    for(y=0;y<height;y++) {
 
489
        for(j = 0;j < width; j++) {
 
490
            r = s[0];
 
491
            g = s[1];
 
492
            b = s[2];
 
493
            RGB_OUT(d, r, g, b);
 
494
            s += 3;
 
495
            d += BPP;
 
496
        }
 
497
        s += src_wrap;
 
498
        d += dst_wrap;
 
499
    }
 
500
}
 
501
 
 
502
static void glue(RGB_NAME, _to_rgb24)(AVPicture *dst, const AVPicture *src,
 
503
                                      int width, int height)
 
504
{
 
505
    const uint8_t *s;
 
506
    uint8_t *d;
 
507
    int src_wrap, dst_wrap, j, y;
 
508
    unsigned int r, g , b;
 
509
 
 
510
    s = src->data[0];
 
511
    src_wrap = src->linesize[0] - width * BPP;
 
512
 
 
513
    d = dst->data[0];
 
514
    dst_wrap = dst->linesize[0] - width * 3;
 
515
 
 
516
    for(y=0;y<height;y++) {
 
517
        for(j = 0;j < width; j++) {
 
518
            RGB_IN(r, g, b, s)
 
519
            d[0] = r;
 
520
            d[1] = g;
 
521
            d[2] = b;
 
522
            d += 3;
 
523
            s += BPP;
 
524
        }
 
525
        s += src_wrap;
 
526
        d += dst_wrap;
 
527
    }
 
528
}
 
529
 
 
530
#endif /* !FMT_RGB24 */
 
531
 
 
532
#ifdef FMT_RGB24
 
533
 
 
534
static void yuv444p_to_rgb24(AVPicture *dst, const AVPicture *src,
 
535
                             int width, int height)
 
536
{
 
537
    const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
 
538
    uint8_t *d, *d1;
 
539
    int w, y, cb, cr, r_add, g_add, b_add;
 
540
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
541
    unsigned int r, g, b;
 
542
 
 
543
    d = dst->data[0];
 
544
    y1_ptr = src->data[0];
 
545
    cb_ptr = src->data[1];
 
546
    cr_ptr = src->data[2];
 
547
    for(;height > 0; height --) {
 
548
        d1 = d;
 
549
        for(w = width; w > 0; w--) {
 
550
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
 
551
 
 
552
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
 
553
            RGB_OUT(d1, r, g, b);
 
554
            d1 += BPP;
 
555
 
 
556
            y1_ptr++;
 
557
            cb_ptr++;
 
558
            cr_ptr++;
 
559
        }
 
560
        d += dst->linesize[0];
 
561
        y1_ptr += src->linesize[0] - width;
 
562
        cb_ptr += src->linesize[1] - width;
 
563
        cr_ptr += src->linesize[2] - width;
 
564
    }
 
565
}
 
566
 
 
567
static void yuvj444p_to_rgb24(AVPicture *dst, const AVPicture *src,
 
568
                              int width, int height)
 
569
{
 
570
    const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
 
571
    uint8_t *d, *d1;
 
572
    int w, y, cb, cr, r_add, g_add, b_add;
 
573
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
574
    unsigned int r, g, b;
 
575
 
 
576
    d = dst->data[0];
 
577
    y1_ptr = src->data[0];
 
578
    cb_ptr = src->data[1];
 
579
    cr_ptr = src->data[2];
 
580
    for(;height > 0; height --) {
 
581
        d1 = d;
 
582
        for(w = width; w > 0; w--) {
 
583
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
 
584
 
 
585
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
 
586
            RGB_OUT(d1, r, g, b);
 
587
            d1 += BPP;
 
588
 
 
589
            y1_ptr++;
 
590
            cb_ptr++;
 
591
            cr_ptr++;
 
592
        }
 
593
        d += dst->linesize[0];
 
594
        y1_ptr += src->linesize[0] - width;
 
595
        cb_ptr += src->linesize[1] - width;
 
596
        cr_ptr += src->linesize[2] - width;
 
597
    }
 
598
}
 
599
 
 
600
static void rgb24_to_yuv444p(AVPicture *dst, const AVPicture *src,
 
601
                             int width, int height)
 
602
{
 
603
    int src_wrap, x, y;
 
604
    int r, g, b;
 
605
    uint8_t *lum, *cb, *cr;
 
606
    const uint8_t *p;
 
607
 
 
608
    lum = dst->data[0];
 
609
    cb = dst->data[1];
 
610
    cr = dst->data[2];
 
611
 
 
612
    src_wrap = src->linesize[0] - width * BPP;
 
613
    p = src->data[0];
 
614
    for(y=0;y<height;y++) {
 
615
        for(x=0;x<width;x++) {
 
616
            RGB_IN(r, g, b, p);
 
617
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
 
618
            cb[0] = RGB_TO_U_CCIR(r, g, b, 0);
 
619
            cr[0] = RGB_TO_V_CCIR(r, g, b, 0);
 
620
            p += BPP;
 
621
            cb++;
 
622
            cr++;
 
623
            lum++;
 
624
        }
 
625
        p += src_wrap;
 
626
        lum += dst->linesize[0] - width;
 
627
        cb += dst->linesize[1] - width;
 
628
        cr += dst->linesize[2] - width;
 
629
    }
 
630
}
 
631
 
 
632
static void rgb24_to_yuvj420p(AVPicture *dst, const AVPicture *src,
 
633
                              int width, int height)
 
634
{
 
635
    int wrap, wrap3, width2;
 
636
    int r, g, b, r1, g1, b1, w;
 
637
    uint8_t *lum, *cb, *cr;
 
638
    const uint8_t *p;
 
639
 
 
640
    lum = dst->data[0];
 
641
    cb = dst->data[1];
 
642
    cr = dst->data[2];
 
643
 
 
644
    width2 = (width + 1) >> 1;
 
645
    wrap = dst->linesize[0];
 
646
    wrap3 = src->linesize[0];
 
647
    p = src->data[0];
 
648
    for(;height>=2;height -= 2) {
 
649
        for(w = width; w >= 2; w -= 2) {
 
650
            RGB_IN(r, g, b, p);
 
651
            r1 = r;
 
652
            g1 = g;
 
653
            b1 = b;
 
654
            lum[0] = RGB_TO_Y(r, g, b);
 
655
 
 
656
            RGB_IN(r, g, b, p + BPP);
 
657
            r1 += r;
 
658
            g1 += g;
 
659
            b1 += b;
 
660
            lum[1] = RGB_TO_Y(r, g, b);
 
661
            p += wrap3;
 
662
            lum += wrap;
 
663
 
 
664
            RGB_IN(r, g, b, p);
 
665
            r1 += r;
 
666
            g1 += g;
 
667
            b1 += b;
 
668
            lum[0] = RGB_TO_Y(r, g, b);
 
669
 
 
670
            RGB_IN(r, g, b, p + BPP);
 
671
            r1 += r;
 
672
            g1 += g;
 
673
            b1 += b;
 
674
            lum[1] = RGB_TO_Y(r, g, b);
 
675
 
 
676
            cb[0] = RGB_TO_U(r1, g1, b1, 2);
 
677
            cr[0] = RGB_TO_V(r1, g1, b1, 2);
 
678
 
 
679
            cb++;
 
680
            cr++;
 
681
            p += -wrap3 + 2 * BPP;
 
682
            lum += -wrap + 2;
 
683
        }
 
684
        if (w) {
 
685
            RGB_IN(r, g, b, p);
 
686
            r1 = r;
 
687
            g1 = g;
 
688
            b1 = b;
 
689
            lum[0] = RGB_TO_Y(r, g, b);
 
690
            p += wrap3;
 
691
            lum += wrap;
 
692
            RGB_IN(r, g, b, p);
 
693
            r1 += r;
 
694
            g1 += g;
 
695
            b1 += b;
 
696
            lum[0] = RGB_TO_Y(r, g, b);
 
697
            cb[0] = RGB_TO_U(r1, g1, b1, 1);
 
698
            cr[0] = RGB_TO_V(r1, g1, b1, 1);
 
699
            cb++;
 
700
            cr++;
 
701
            p += -wrap3 + BPP;
 
702
            lum += -wrap + 1;
 
703
        }
 
704
        p += wrap3 + (wrap3 - width * BPP);
 
705
        lum += wrap + (wrap - width);
 
706
        cb += dst->linesize[1] - width2;
 
707
        cr += dst->linesize[2] - width2;
 
708
    }
 
709
    /* handle odd height */
 
710
    if (height) {
 
711
        for(w = width; w >= 2; w -= 2) {
 
712
            RGB_IN(r, g, b, p);
 
713
            r1 = r;
 
714
            g1 = g;
 
715
            b1 = b;
 
716
            lum[0] = RGB_TO_Y(r, g, b);
 
717
 
 
718
            RGB_IN(r, g, b, p + BPP);
 
719
            r1 += r;
 
720
            g1 += g;
 
721
            b1 += b;
 
722
            lum[1] = RGB_TO_Y(r, g, b);
 
723
            cb[0] = RGB_TO_U(r1, g1, b1, 1);
 
724
            cr[0] = RGB_TO_V(r1, g1, b1, 1);
 
725
            cb++;
 
726
            cr++;
 
727
            p += 2 * BPP;
 
728
           lum += 2;
 
729
        }
 
730
        if (w) {
 
731
            RGB_IN(r, g, b, p);
 
732
            lum[0] = RGB_TO_Y(r, g, b);
 
733
            cb[0] = RGB_TO_U(r, g, b, 0);
 
734
            cr[0] = RGB_TO_V(r, g, b, 0);
 
735
        }
 
736
    }
 
737
}
 
738
 
 
739
static void rgb24_to_yuvj444p(AVPicture *dst, const AVPicture *src,
 
740
                              int width, int height)
 
741
{
 
742
    int src_wrap, x, y;
 
743
    int r, g, b;
 
744
    uint8_t *lum, *cb, *cr;
 
745
    const uint8_t *p;
 
746
 
 
747
    lum = dst->data[0];
 
748
    cb = dst->data[1];
 
749
    cr = dst->data[2];
 
750
 
 
751
    src_wrap = src->linesize[0] - width * BPP;
 
752
    p = src->data[0];
 
753
    for(y=0;y<height;y++) {
 
754
        for(x=0;x<width;x++) {
 
755
            RGB_IN(r, g, b, p);
 
756
            lum[0] = RGB_TO_Y(r, g, b);
 
757
            cb[0] = RGB_TO_U(r, g, b, 0);
 
758
            cr[0] = RGB_TO_V(r, g, b, 0);
 
759
            p += BPP;
 
760
            cb++;
 
761
            cr++;
 
762
            lum++;
 
763
        }
 
764
        p += src_wrap;
 
765
        lum += dst->linesize[0] - width;
 
766
        cb += dst->linesize[1] - width;
 
767
        cr += dst->linesize[2] - width;
 
768
    }
 
769
}
 
770
 
 
771
#endif /* FMT_RGB24 */
 
772
 
 
773
#if defined(FMT_RGB24) || defined(FMT_RGBA32)
 
774
 
 
775
static void glue(RGB_NAME, _to_pal8)(AVPicture *dst, const AVPicture *src,
 
776
                                     int width, int height)
 
777
{
 
778
    const unsigned char *p;
 
779
    unsigned char *q;
 
780
    int dst_wrap, src_wrap;
 
781
    int x, y, has_alpha;
 
782
    unsigned int r, g, b;
 
783
 
 
784
    p = src->data[0];
 
785
    src_wrap = src->linesize[0] - BPP * width;
 
786
 
 
787
    q = dst->data[0];
 
788
    dst_wrap = dst->linesize[0] - width;
 
789
    has_alpha = 0;
 
790
    
 
791
    for(y=0;y<height;y++) {
 
792
        for(x=0;x<width;x++) {
 
793
#ifdef RGBA_IN
 
794
            {
 
795
                unsigned int a;
 
796
                RGBA_IN(r, g, b, a, p);
 
797
                /* crude approximation for alpha ! */
 
798
                if (a < 0x80) {
 
799
                    has_alpha = 1;
 
800
                    q[0] = TRANSP_INDEX;
 
801
                } else {
 
802
                    q[0] = gif_clut_index(r, g, b);
 
803
                }
 
804
            }
 
805
#else
 
806
            RGB_IN(r, g, b, p);
 
807
            q[0] = gif_clut_index(r, g, b);
 
808
#endif
 
809
            q++;
 
810
            p += BPP;
 
811
        }
 
812
        p += src_wrap;
 
813
        q += dst_wrap;
 
814
    }
 
815
 
 
816
    build_rgb_palette(dst->data[1], has_alpha);
 
817
}
 
818
 
 
819
#endif /* defined(FMT_RGB24) || defined(FMT_RGBA32) */
 
820
        
 
821
#ifdef RGBA_IN
 
822
 
 
823
static int glue(get_alpha_info_, RGB_NAME)(const AVPicture *src,
 
824
                                           int width, int height)
 
825
{
 
826
    const unsigned char *p;
 
827
    int src_wrap, ret, x, y;
 
828
    unsigned int r, g, b, a;
 
829
 
 
830
    p = src->data[0];
 
831
    src_wrap = src->linesize[0] - BPP * width;
 
832
    ret = 0;
 
833
    for(y=0;y<height;y++) {
 
834
        for(x=0;x<width;x++) {
 
835
            RGBA_IN(r, g, b, a, p);
 
836
            if (a == 0x00) {
 
837
                ret |= FF_ALPHA_TRANSP;
 
838
            } else if (a != 0xff) {
 
839
                ret |= FF_ALPHA_SEMI_TRANSP;
 
840
            }
 
841
            p += BPP;
 
842
        }
 
843
        p += src_wrap;
 
844
    }
 
845
    return ret;
 
846
}
 
847
 
 
848
#endif /* RGBA_IN */
 
849
 
 
850
#undef RGB_IN
 
851
#undef RGBA_IN
 
852
#undef RGB_OUT
 
853
#undef RGBA_OUT
 
854
#undef BPP
 
855
#undef RGB_NAME
 
856
#undef FMT_RGB24
 
857
#undef FMT_RGBA32