← Back to branch summary

~ubuntu-branches/ubuntu/feisty/avidemux/feisty

« back to all changes in this revision

Viewing changes to adm_lavcodec/imgconvert_template.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
adm_lavcodec/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