quicktime/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