git.sesse.net Git - ffmpeg/blob - libavcodec/imgconvert_template.h

   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