Statistics
| Branch: | Revision:

ffmpeg / libavcodec / imgconvert_template.c @ 782fc0c3

History | View | Annotate | Download (22.1 KB)

1
/*
2
 * templates for image conversion routines
3
 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* This header intentionally has no multiple inclusion guards. It is meant to
23
 * be included multiple times and generates different code depending on the
24
 * value of certain #defines. */
25

    
26
#ifndef RGB_OUT
27
#define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xff)
28
#endif
29

    
30
static void glue(yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
31
                                        int width, int height)
32
{
33
    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
34
    uint8_t *d, *d1, *d2;
35
    int w, y, cb, cr, r_add, g_add, b_add, width2;
36
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
37
    unsigned int r, g, b;
38

    
39
    d = dst->data[0];
40
    y1_ptr = src->data[0];
41
    cb_ptr = src->data[1];
42
    cr_ptr = src->data[2];
43
    width2 = (width + 1) >> 1;
44
    for(;height >= 2; height -= 2) {
45
        d1 = d;
46
        d2 = d + dst->linesize[0];
47
        y2_ptr = y1_ptr + src->linesize[0];
48
        for(w = width; w >= 2; w -= 2) {
49
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
50
            /* output 4 pixels */
51
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
52
            RGB_OUT(d1, r, g, b);
53

    
54
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);
55
            RGB_OUT(d1 + BPP, r, g, b);
56

    
57
            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);
58
            RGB_OUT(d2, r, g, b);
59

    
60
            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[1]);
61
            RGB_OUT(d2 + BPP, r, g, b);
62

    
63
            d1 += 2 * BPP;
64
            d2 += 2 * BPP;
65

    
66
            y1_ptr += 2;
67
            y2_ptr += 2;
68
            cb_ptr++;
69
            cr_ptr++;
70
        }
71
        /* handle odd width */
72
        if (w) {
73
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
74
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
75
            RGB_OUT(d1, r, g, b);
76

    
77
            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);
78
            RGB_OUT(d2, r, g, b);
79
            d1 += BPP;
80
            d2 += BPP;
81
            y1_ptr++;
82
            y2_ptr++;
83
            cb_ptr++;
84
            cr_ptr++;
85
        }
86
        d += 2 * dst->linesize[0];
87
        y1_ptr += 2 * src->linesize[0] - width;
88
        cb_ptr += src->linesize[1] - width2;
89
        cr_ptr += src->linesize[2] - width2;
90
    }
91
    /* handle odd height */
92
    if (height) {
93
        d1 = d;
94
        for(w = width; w >= 2; w -= 2) {
95
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
96
            /* output 2 pixels */
97
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
98
            RGB_OUT(d1, r, g, b);
99

    
100
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);
101
            RGB_OUT(d1 + BPP, r, g, b);
102

    
103
            d1 += 2 * BPP;
104

    
105
            y1_ptr += 2;
106
            cb_ptr++;
107
            cr_ptr++;
108
        }
109
        /* handle width */
110
        if (w) {
111
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
112
            /* output 2 pixels */
113
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
114
            RGB_OUT(d1, r, g, b);
115
            d1 += BPP;
116

    
117
            y1_ptr++;
118
            cb_ptr++;
119
            cr_ptr++;
120
        }
121
    }
122
}
123

    
124
static void glue(yuvj420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
125
                                         int width, int height)
126
{
127
    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
128
    uint8_t *d, *d1, *d2;
129
    int w, y, cb, cr, r_add, g_add, b_add, width2;
130
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
131
    unsigned int r, g, b;
132

    
133
    d = dst->data[0];
134
    y1_ptr = src->data[0];
135
    cb_ptr = src->data[1];
136
    cr_ptr = src->data[2];
137
    width2 = (width + 1) >> 1;
138
    for(;height >= 2; height -= 2) {
139
        d1 = d;
140
        d2 = d + dst->linesize[0];
141
        y2_ptr = y1_ptr + src->linesize[0];
142
        for(w = width; w >= 2; w -= 2) {
143
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
144
            /* output 4 pixels */
145
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
146
            RGB_OUT(d1, r, g, b);
147

    
148
            YUV_TO_RGB2(r, g, b, y1_ptr[1]);
149
            RGB_OUT(d1 + BPP, r, g, b);
150

    
151
            YUV_TO_RGB2(r, g, b, y2_ptr[0]);
152
            RGB_OUT(d2, r, g, b);
153

    
154
            YUV_TO_RGB2(r, g, b, y2_ptr[1]);
155
            RGB_OUT(d2 + BPP, r, g, b);
156

    
157
            d1 += 2 * BPP;
158
            d2 += 2 * BPP;
159

    
160
            y1_ptr += 2;
161
            y2_ptr += 2;
162
            cb_ptr++;
163
            cr_ptr++;
164
        }
165
        /* handle odd width */
166
        if (w) {
167
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
168
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
169
            RGB_OUT(d1, r, g, b);
170

    
171
            YUV_TO_RGB2(r, g, b, y2_ptr[0]);
172
            RGB_OUT(d2, r, g, b);
173
            d1 += BPP;
174
            d2 += BPP;
175
            y1_ptr++;
176
            y2_ptr++;
177
            cb_ptr++;
178
            cr_ptr++;
179
        }
180
        d += 2 * dst->linesize[0];
181
        y1_ptr += 2 * src->linesize[0] - width;
182
        cb_ptr += src->linesize[1] - width2;
183
        cr_ptr += src->linesize[2] - width2;
184
    }
185
    /* handle odd height */
186
    if (height) {
187
        d1 = d;
188
        for(w = width; w >= 2; w -= 2) {
189
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
190
            /* output 2 pixels */
191
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
192
            RGB_OUT(d1, r, g, b);
193

    
194
            YUV_TO_RGB2(r, g, b, y1_ptr[1]);
195
            RGB_OUT(d1 + BPP, r, g, b);
196

    
197
            d1 += 2 * BPP;
198

    
199
            y1_ptr += 2;
200
            cb_ptr++;
201
            cr_ptr++;
202
        }
203
        /* handle width */
204
        if (w) {
205
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
206
            /* output 2 pixels */
207
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
208
            RGB_OUT(d1, r, g, b);
209
            d1 += BPP;
210

    
211
            y1_ptr++;
212
            cb_ptr++;
213
            cr_ptr++;
214
        }
215
    }
216
}
217

    
218
static void glue(RGB_NAME, _to_yuv420p)(AVPicture *dst, const AVPicture *src,
219
                                        int width, int height)
220
{
221
    int wrap, wrap3, width2;
222
    int r, g, b, r1, g1, b1, w;
223
    uint8_t *lum, *cb, *cr;
224
    const uint8_t *p;
225

    
226
    lum = dst->data[0];
227
    cb = dst->data[1];
228
    cr = dst->data[2];
229

    
230
    width2 = (width + 1) >> 1;
231
    wrap = dst->linesize[0];
232
    wrap3 = src->linesize[0];
233
    p = src->data[0];
234
    for(;height>=2;height -= 2) {
235
        for(w = width; w >= 2; w -= 2) {
236
            RGB_IN(r, g, b, p);
237
            r1 = r;
238
            g1 = g;
239
            b1 = b;
240
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
241

    
242
            RGB_IN(r, g, b, p + BPP);
243
            r1 += r;
244
            g1 += g;
245
            b1 += b;
246
            lum[1] = RGB_TO_Y_CCIR(r, g, b);
247
            p += wrap3;
248
            lum += wrap;
249

    
250
            RGB_IN(r, g, b, p);
251
            r1 += r;
252
            g1 += g;
253
            b1 += b;
254
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
255

    
256
            RGB_IN(r, g, b, p + BPP);
257
            r1 += r;
258
            g1 += g;
259
            b1 += b;
260
            lum[1] = RGB_TO_Y_CCIR(r, g, b);
261

    
262
            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 2);
263
            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 2);
264

    
265
            cb++;
266
            cr++;
267
            p += -wrap3 + 2 * BPP;
268
            lum += -wrap + 2;
269
        }
270
        if (w) {
271
            RGB_IN(r, g, b, p);
272
            r1 = r;
273
            g1 = g;
274
            b1 = b;
275
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
276
            p += wrap3;
277
            lum += wrap;
278
            RGB_IN(r, g, b, p);
279
            r1 += r;
280
            g1 += g;
281
            b1 += b;
282
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
283
            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);
284
            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);
285
            cb++;
286
            cr++;
287
            p += -wrap3 + BPP;
288
            lum += -wrap + 1;
289
        }
290
        p += wrap3 + (wrap3 - width * BPP);
291
        lum += wrap + (wrap - width);
292
        cb += dst->linesize[1] - width2;
293
        cr += dst->linesize[2] - width2;
294
    }
295
    /* handle odd height */
296
    if (height) {
297
        for(w = width; w >= 2; w -= 2) {
298
            RGB_IN(r, g, b, p);
299
            r1 = r;
300
            g1 = g;
301
            b1 = b;
302
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
303

    
304
            RGB_IN(r, g, b, p + BPP);
305
            r1 += r;
306
            g1 += g;
307
            b1 += b;
308
            lum[1] = RGB_TO_Y_CCIR(r, g, b);
309
            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);
310
            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);
311
            cb++;
312
            cr++;
313
            p += 2 * BPP;
314
           lum += 2;
315
        }
316
        if (w) {
317
            RGB_IN(r, g, b, p);
318
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
319
            cb[0] = RGB_TO_U_CCIR(r, g, b, 0);
320
            cr[0] = RGB_TO_V_CCIR(r, g, b, 0);
321
        }
322
    }
323
}
324

    
325
static void glue(RGB_NAME, _to_gray)(AVPicture *dst, const AVPicture *src,
326
                                     int width, int height)
327
{
328
    const unsigned char *p;
329
    unsigned char *q;
330
    int r, g, b, dst_wrap, src_wrap;
331
    int x, y;
332

    
333
    p = src->data[0];
334
    src_wrap = src->linesize[0] - BPP * width;
335

    
336
    q = dst->data[0];
337
    dst_wrap = dst->linesize[0] - width;
338

    
339
    for(y=0;y<height;y++) {
340
        for(x=0;x<width;x++) {
341
            RGB_IN(r, g, b, p);
342
            q[0] = RGB_TO_Y(r, g, b);
343
            q++;
344
            p += BPP;
345
        }
346
        p += src_wrap;
347
        q += dst_wrap;
348
    }
349
}
350

    
351
static void glue(gray_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
352
                                     int width, int height)
353
{
354
    const unsigned char *p;
355
    unsigned char *q;
356
    int r, dst_wrap, src_wrap;
357
    int x, y;
358

    
359
    p = src->data[0];
360
    src_wrap = src->linesize[0] - width;
361

    
362
    q = dst->data[0];
363
    dst_wrap = dst->linesize[0] - BPP * width;
364

    
365
    for(y=0;y<height;y++) {
366
        for(x=0;x<width;x++) {
367
            r = p[0];
368
            RGB_OUT(q, r, r, r);
369
            q += BPP;
370
            p ++;
371
        }
372
        p += src_wrap;
373
        q += dst_wrap;
374
    }
375
}
376

    
377
static void glue(pal8_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
378
                                     int width, int height)
379
{
380
    const unsigned char *p;
381
    unsigned char *q;
382
    int r, g, b, dst_wrap, src_wrap;
383
    int x, y;
384
    uint32_t v;
385
    const uint32_t *palette;
386

    
387
    p = src->data[0];
388
    src_wrap = src->linesize[0] - width;
389
    palette = (uint32_t *)src->data[1];
390

    
391
    q = dst->data[0];
392
    dst_wrap = dst->linesize[0] - BPP * width;
393

    
394
    for(y=0;y<height;y++) {
395
        for(x=0;x<width;x++) {
396
            v = palette[p[0]];
397
            r = (v >> 16) & 0xff;
398
            g = (v >> 8) & 0xff;
399
            b = (v) & 0xff;
400
#ifdef RGBA_OUT
401
            {
402
                int a;
403
                a = (v >> 24) & 0xff;
404
                RGBA_OUT(q, r, g, b, a);
405
            }
406
#else
407
            RGB_OUT(q, r, g, b);
408
#endif
409
            q += BPP;
410
            p ++;
411
        }
412
        p += src_wrap;
413
        q += dst_wrap;
414
    }
415
}
416

    
417
// RGB24 has optimized routines
418
#if !defined(FMT_RGB32) && !defined(FMT_RGB24)
419
/* alpha support */
420

    
421
static void glue(rgb32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
422
                                      int width, int height)
423
{
424
    const uint8_t *s;
425
    uint8_t *d;
426
    int src_wrap, dst_wrap, j, y;
427
    unsigned int v, r, g, b;
428
#ifdef RGBA_OUT
429
    unsigned int a;
430
#endif
431

    
432
    s = src->data[0];
433
    src_wrap = src->linesize[0] - width * 4;
434

    
435
    d = dst->data[0];
436
    dst_wrap = dst->linesize[0] - width * BPP;
437

    
438
    for(y=0;y<height;y++) {
439
        for(j = 0;j < width; j++) {
440
            v = ((const uint32_t *)(s))[0];
441
            r = (v >> 16) & 0xff;
442
            g = (v >> 8) & 0xff;
443
            b = v & 0xff;
444
#ifdef RGBA_OUT
445
            a = (v >> 24) & 0xff;
446
            RGBA_OUT(d, r, g, b, a);
447
#else
448
            RGB_OUT(d, r, g, b);
449
#endif
450
            s += 4;
451
            d += BPP;
452
        }
453
        s += src_wrap;
454
        d += dst_wrap;
455
    }
456
}
457

    
458
static void glue(RGB_NAME, _to_rgb32)(AVPicture *dst, const AVPicture *src,
459
                                       int width, int height)
460
{
461
    const uint8_t *s;
462
    uint8_t *d;
463
    int src_wrap, dst_wrap, j, y;
464
    unsigned int r, g, b;
465
#ifdef RGBA_IN
466
    unsigned int a;
467
#endif
468

    
469
    s = src->data[0];
470
    src_wrap = src->linesize[0] - width * BPP;
471

    
472
    d = dst->data[0];
473
    dst_wrap = dst->linesize[0] - width * 4;
474

    
475
    for(y=0;y<height;y++) {
476
        for(j = 0;j < width; j++) {
477
#ifdef RGBA_IN
478
            RGBA_IN(r, g, b, a, s);
479
            ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
480
#else
481
            RGB_IN(r, g, b, s);
482
            ((uint32_t *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b;
483
#endif
484
            d += 4;
485
            s += BPP;
486
        }
487
        s += src_wrap;
488
        d += dst_wrap;
489
    }
490
}
491

    
492
#endif /* !defined(FMT_RGB32) */
493

    
494
#ifndef FMT_RGB24
495

    
496
static void glue(rgb24_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
497
                                      int width, int height)
498
{
499
    const uint8_t *s;
500
    uint8_t *d;
501
    int src_wrap, dst_wrap, j, y;
502
    unsigned int r, g, b;
503

    
504
    s = src->data[0];
505
    src_wrap = src->linesize[0] - width * 3;
506

    
507
    d = dst->data[0];
508
    dst_wrap = dst->linesize[0] - width * BPP;
509

    
510
    for(y=0;y<height;y++) {
511
        for(j = 0;j < width; j++) {
512
            r = s[0];
513
            g = s[1];
514
            b = s[2];
515
            RGB_OUT(d, r, g, b);
516
            s += 3;
517
            d += BPP;
518
        }
519
        s += src_wrap;
520
        d += dst_wrap;
521
    }
522
}
523

    
524
static void glue(RGB_NAME, _to_rgb24)(AVPicture *dst, const AVPicture *src,
525
                                      int width, int height)
526
{
527
    const uint8_t *s;
528
    uint8_t *d;
529
    int src_wrap, dst_wrap, j, y;
530
    unsigned int r, g , b;
531

    
532
    s = src->data[0];
533
    src_wrap = src->linesize[0] - width * BPP;
534

    
535
    d = dst->data[0];
536
    dst_wrap = dst->linesize[0] - width * 3;
537

    
538
    for(y=0;y<height;y++) {
539
        for(j = 0;j < width; j++) {
540
            RGB_IN(r, g, b, s)
541
            d[0] = r;
542
            d[1] = g;
543
            d[2] = b;
544
            d += 3;
545
            s += BPP;
546
        }
547
        s += src_wrap;
548
        d += dst_wrap;
549
    }
550
}
551

    
552
#endif /* !FMT_RGB24 */
553

    
554
#ifdef FMT_RGB24
555

    
556
static void yuv444p_to_rgb24(AVPicture *dst, const AVPicture *src,
557
                             int width, int height)
558
{
559
    const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
560
    uint8_t *d, *d1;
561
    int w, y, cb, cr, r_add, g_add, b_add;
562
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
563
    unsigned int r, g, b;
564

    
565
    d = dst->data[0];
566
    y1_ptr = src->data[0];
567
    cb_ptr = src->data[1];
568
    cr_ptr = src->data[2];
569
    for(;height > 0; height --) {
570
        d1 = d;
571
        for(w = width; w > 0; w--) {
572
            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);
573

    
574
            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);
575
            RGB_OUT(d1, r, g, b);
576
            d1 += BPP;
577

    
578
            y1_ptr++;
579
            cb_ptr++;
580
            cr_ptr++;
581
        }
582
        d += dst->linesize[0];
583
        y1_ptr += src->linesize[0] - width;
584
        cb_ptr += src->linesize[1] - width;
585
        cr_ptr += src->linesize[2] - width;
586
    }
587
}
588

    
589
static void yuvj444p_to_rgb24(AVPicture *dst, const AVPicture *src,
590
                              int width, int height)
591
{
592
    const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
593
    uint8_t *d, *d1;
594
    int w, y, cb, cr, r_add, g_add, b_add;
595
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
596
    unsigned int r, g, b;
597

    
598
    d = dst->data[0];
599
    y1_ptr = src->data[0];
600
    cb_ptr = src->data[1];
601
    cr_ptr = src->data[2];
602
    for(;height > 0; height --) {
603
        d1 = d;
604
        for(w = width; w > 0; w--) {
605
            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);
606

    
607
            YUV_TO_RGB2(r, g, b, y1_ptr[0]);
608
            RGB_OUT(d1, r, g, b);
609
            d1 += BPP;
610

    
611
            y1_ptr++;
612
            cb_ptr++;
613
            cr_ptr++;
614
        }
615
        d += dst->linesize[0];
616
        y1_ptr += src->linesize[0] - width;
617
        cb_ptr += src->linesize[1] - width;
618
        cr_ptr += src->linesize[2] - width;
619
    }
620
}
621

    
622
static void rgb24_to_yuv444p(AVPicture *dst, const AVPicture *src,
623
                             int width, int height)
624
{
625
    int src_wrap, x, y;
626
    int r, g, b;
627
    uint8_t *lum, *cb, *cr;
628
    const uint8_t *p;
629

    
630
    lum = dst->data[0];
631
    cb = dst->data[1];
632
    cr = dst->data[2];
633

    
634
    src_wrap = src->linesize[0] - width * BPP;
635
    p = src->data[0];
636
    for(y=0;y<height;y++) {
637
        for(x=0;x<width;x++) {
638
            RGB_IN(r, g, b, p);
639
            lum[0] = RGB_TO_Y_CCIR(r, g, b);
640
            cb[0] = RGB_TO_U_CCIR(r, g, b, 0);
641
            cr[0] = RGB_TO_V_CCIR(r, g, b, 0);
642
            p += BPP;
643
            cb++;
644
            cr++;
645
            lum++;
646
        }
647
        p += src_wrap;
648
        lum += dst->linesize[0] - width;
649
        cb += dst->linesize[1] - width;
650
        cr += dst->linesize[2] - width;
651
    }
652
}
653

    
654
static void rgb24_to_yuvj420p(AVPicture *dst, const AVPicture *src,
655
                              int width, int height)
656
{
657
    int wrap, wrap3, width2;
658
    int r, g, b, r1, g1, b1, w;
659
    uint8_t *lum, *cb, *cr;
660
    const uint8_t *p;
661

    
662
    lum = dst->data[0];
663
    cb = dst->data[1];
664
    cr = dst->data[2];
665

    
666
    width2 = (width + 1) >> 1;
667
    wrap = dst->linesize[0];
668
    wrap3 = src->linesize[0];
669
    p = src->data[0];
670
    for(;height>=2;height -= 2) {
671
        for(w = width; w >= 2; w -= 2) {
672
            RGB_IN(r, g, b, p);
673
            r1 = r;
674
            g1 = g;
675
            b1 = b;
676
            lum[0] = RGB_TO_Y(r, g, b);
677

    
678
            RGB_IN(r, g, b, p + BPP);
679
            r1 += r;
680
            g1 += g;
681
            b1 += b;
682
            lum[1] = RGB_TO_Y(r, g, b);
683
            p += wrap3;
684
            lum += wrap;
685

    
686
            RGB_IN(r, g, b, p);
687
            r1 += r;
688
            g1 += g;
689
            b1 += b;
690
            lum[0] = RGB_TO_Y(r, g, b);
691

    
692
            RGB_IN(r, g, b, p + BPP);
693
            r1 += r;
694
            g1 += g;
695
            b1 += b;
696
            lum[1] = RGB_TO_Y(r, g, b);
697

    
698
            cb[0] = RGB_TO_U(r1, g1, b1, 2);
699
            cr[0] = RGB_TO_V(r1, g1, b1, 2);
700

    
701
            cb++;
702
            cr++;
703
            p += -wrap3 + 2 * BPP;
704
            lum += -wrap + 2;
705
        }
706
        if (w) {
707
            RGB_IN(r, g, b, p);
708
            r1 = r;
709
            g1 = g;
710
            b1 = b;
711
            lum[0] = RGB_TO_Y(r, g, b);
712
            p += wrap3;
713
            lum += wrap;
714
            RGB_IN(r, g, b, p);
715
            r1 += r;
716
            g1 += g;
717
            b1 += b;
718
            lum[0] = RGB_TO_Y(r, g, b);
719
            cb[0] = RGB_TO_U(r1, g1, b1, 1);
720
            cr[0] = RGB_TO_V(r1, g1, b1, 1);
721
            cb++;
722
            cr++;
723
            p += -wrap3 + BPP;
724
            lum += -wrap + 1;
725
        }
726
        p += wrap3 + (wrap3 - width * BPP);
727
        lum += wrap + (wrap - width);
728
        cb += dst->linesize[1] - width2;
729
        cr += dst->linesize[2] - width2;
730
    }
731
    /* handle odd height */
732
    if (height) {
733
        for(w = width; w >= 2; w -= 2) {
734
            RGB_IN(r, g, b, p);
735
            r1 = r;
736
            g1 = g;
737
            b1 = b;
738
            lum[0] = RGB_TO_Y(r, g, b);
739

    
740
            RGB_IN(r, g, b, p + BPP);
741
            r1 += r;
742
            g1 += g;
743
            b1 += b;
744
            lum[1] = RGB_TO_Y(r, g, b);
745
            cb[0] = RGB_TO_U(r1, g1, b1, 1);
746
            cr[0] = RGB_TO_V(r1, g1, b1, 1);
747
            cb++;
748
            cr++;
749
            p += 2 * BPP;
750
           lum += 2;
751
        }
752
        if (w) {
753
            RGB_IN(r, g, b, p);
754
            lum[0] = RGB_TO_Y(r, g, b);
755
            cb[0] = RGB_TO_U(r, g, b, 0);
756
            cr[0] = RGB_TO_V(r, g, b, 0);
757
        }
758
    }
759
}
760

    
761
static void rgb24_to_yuvj444p(AVPicture *dst, const AVPicture *src,
762
                              int width, int height)
763
{
764
    int src_wrap, x, y;
765
    int r, g, b;
766
    uint8_t *lum, *cb, *cr;
767
    const uint8_t *p;
768

    
769
    lum = dst->data[0];
770
    cb = dst->data[1];
771
    cr = dst->data[2];
772

    
773
    src_wrap = src->linesize[0] - width * BPP;
774
    p = src->data[0];
775
    for(y=0;y<height;y++) {
776
        for(x=0;x<width;x++) {
777
            RGB_IN(r, g, b, p);
778
            lum[0] = RGB_TO_Y(r, g, b);
779
            cb[0] = RGB_TO_U(r, g, b, 0);
780
            cr[0] = RGB_TO_V(r, g, b, 0);
781
            p += BPP;
782
            cb++;
783
            cr++;
784
            lum++;
785
        }
786
        p += src_wrap;
787
        lum += dst->linesize[0] - width;
788
        cb += dst->linesize[1] - width;
789
        cr += dst->linesize[2] - width;
790
    }
791
}
792

    
793
#endif /* FMT_RGB24 */
794

    
795
#if defined(FMT_RGB24) || defined(FMT_RGB32)
796

    
797
static void glue(RGB_NAME, _to_pal8)(AVPicture *dst, const AVPicture *src,
798
                                     int width, int height)
799
{
800
    const unsigned char *p;
801
    unsigned char *q;
802
    int dst_wrap, src_wrap;
803
    int x, y, has_alpha;
804
    unsigned int r, g, b;
805

    
806
    p = src->data[0];
807
    src_wrap = src->linesize[0] - BPP * width;
808

    
809
    q = dst->data[0];
810
    dst_wrap = dst->linesize[0] - width;
811
    has_alpha = 0;
812

    
813
    for(y=0;y<height;y++) {
814
        for(x=0;x<width;x++) {
815
#ifdef RGBA_IN
816
            {
817
                unsigned int a;
818
                RGBA_IN(r, g, b, a, p);
819
                /* crude approximation for alpha ! */
820
                if (a < 0x80) {
821
                    has_alpha = 1;
822
                    q[0] = TRANSP_INDEX;
823
                } else {
824
                    q[0] = gif_clut_index(r, g, b);
825
                }
826
            }
827
#else
828
            RGB_IN(r, g, b, p);
829
            q[0] = gif_clut_index(r, g, b);
830
#endif
831
            q++;
832
            p += BPP;
833
        }
834
        p += src_wrap;
835
        q += dst_wrap;
836
    }
837

    
838
    build_rgb_palette(dst->data[1], has_alpha);
839
}
840

    
841
#endif /* defined(FMT_RGB24) || defined(FMT_RGB32) */
842

    
843
#ifdef RGBA_IN
844

    
845
static int glue(get_alpha_info_, RGB_NAME)(const AVPicture *src,
846
                                           int width, int height)
847
{
848
    const unsigned char *p;
849
    int src_wrap, ret, x, y;
850
    unsigned int r, g, b, a;
851

    
852
    p = src->data[0];
853
    src_wrap = src->linesize[0] - BPP * width;
854
    ret = 0;
855
    for(y=0;y<height;y++) {
856
        for(x=0;x<width;x++) {
857
            RGBA_IN(r, g, b, a, p);
858
            if (a == 0x00) {
859
                ret |= FF_ALPHA_TRANSP;
860
            } else if (a != 0xff) {
861
                ret |= FF_ALPHA_SEMI_TRANSP;
862
            }
863
            p += BPP;
864
        }
865
        p += src_wrap;
866
    }
867
    return ret;
868
}
869

    
870
#endif /* RGBA_IN */
871

    
872
#undef RGB_IN
873
#undef RGBA_IN
874
#undef RGB_OUT
875
#undef RGBA_OUT
876
#undef BPP
877
#undef RGB_NAME
878
#undef FMT_RGB24
879
#undef FMT_RGB32