gst/ffmpegcolorspace/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, 0xffU)
  22 #endif
  23
  24 static void glue (uyvy422_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
  25                                         int width, int height)
  26 {
  27     uint8_t *s, *d, *d1, *s1;
  28     int w, y, cb, cr, r_add, g_add, b_add;
  29     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  30     unsigned int r, g, b;
  31
  32     d = dst->data[0];
  33     s = src->data[0];
  34     for(;height > 0; height --) {
  35         d1 = d;
  36         s1 = s;
  37         for(w = width; w >= 2; w -= 2) {
  38             YUV_TO_RGB1_CCIR(s1[0], s1[2]);
  39
  40             YUV_TO_RGB2_CCIR(r, g, b, s1[1]);
  41             RGB_OUT(d1, r, g, b);
  42             d1 += BPP;
  43
  44             YUV_TO_RGB2_CCIR(r, g, b, s1[3]);
  45             RGB_OUT(d1, r, g, b);
  46             d1 += BPP;
  47
  48             s1 += 4;
  49         }
  50
  51         if (w) {
  52             YUV_TO_RGB1_CCIR(s1[0], s1[2]);
  53
  54             YUV_TO_RGB2_CCIR(r, g, b, s1[1]);
  55             RGB_OUT(d1, r, g, b);
  56         }
  57
  58         d += dst->linesize[0];
  59         s += src->linesize[0];
  60     }
  61 }
  62
  63 static void glue (yuv422_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
  64                                         int width, int height)
  65 {
  66     uint8_t *s, *d, *d1, *s1;
  67     int w, y, cb, cr, r_add, g_add, b_add;
  68     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  69     unsigned int r, g, b;
  70
  71     d = dst->data[0];
  72     s = src->data[0];
  73     for(;height > 0; height --) {
  74         d1 = d;
  75         s1 = s;
  76         for(w = width; w >= 2; w -= 2) {
  77             YUV_TO_RGB1_CCIR(s1[1], s1[3]);
  78
  79             YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
  80             RGB_OUT(d1, r, g, b);
  81             d1 += BPP;
  82
  83             YUV_TO_RGB2_CCIR(r, g, b, s1[2]);
  84             RGB_OUT(d1, r, g, b);
  85             d1 += BPP;
  86
  87             s1 += 4;
  88         }
  89
  90         if (w) {
  91             YUV_TO_RGB1_CCIR(s1[1], s1[3]);
  92
  93             YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
  94             RGB_OUT(d1, r, g, b);
  95         }
  96
  97         d += dst->linesize[0];
  98         s += src->linesize[0];
  99     }
 100 }
 101
 102 static void glue (yvyu422_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 103                                         int width, int height)
 104 {
 105     uint8_t *s, *d, *d1, *s1;
 106     int w, y, cb, cr, r_add, g_add, b_add;
 107     uint8_t *cm = cropTbl + MAX_NEG_CROP;
 108     unsigned int r, g, b;
 109
 110     d = dst->data[0];
 111     s = src->data[0];
 112     for(;height > 0; height --) {
 113         d1 = d;
 114         s1 = s;
 115         for(w = width; w >= 2; w -= 2) {
 116             YUV_TO_RGB1_CCIR(s1[3], s1[1]);
 117
 118             YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
 119             RGB_OUT(d1, r, g, b);
 120             d1 += BPP;
 121
 122             YUV_TO_RGB2_CCIR(r, g, b, s1[2]);
 123             RGB_OUT(d1, r, g, b);
 124             d1 += BPP;
 125
 126             s1 += 4;
 127         }
 128
 129         if (w) {
 130             YUV_TO_RGB1_CCIR(s1[3], s1[1]);
 131
 132             YUV_TO_RGB2_CCIR(r, g, b, s1[0]);
 133             RGB_OUT(d1, r, g, b);
 134         }
 135
 136         d += dst->linesize[0];
 137         s += src->linesize[0];
 138     }
 139 }
 140
 141 static void glue (yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 142                                         int width, int height)
 143 {
 144   const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
 145   uint8_t *d, *d1, *d2;
 146   int w, y, cb, cr, r_add, g_add, b_add, width2;
 147   uint8_t *cm = cropTbl + MAX_NEG_CROP;
 148   unsigned int r, g, b;
 149
 150   d = dst->data[0];
 151   y1_ptr = src->data[0];
 152   cb_ptr = src->data[1];
 153   cr_ptr = src->data[2];
 154   width2 = (width + 1) >> 1;
 155   for (; height >= 2; height -= 2) {
 156     d1 = d;
 157     d2 = d + dst->linesize[0];
 158     y2_ptr = y1_ptr + src->linesize[0];
 159     for (w = width; w >= 2; w -= 2) {
 160       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 161       /* output 4 pixels */
 162       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 163       RGB_OUT (d1, r, g, b);
 164
 165       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 166       RGB_OUT (d1 + BPP, r, g, b);
 167
 168       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 169       RGB_OUT (d2, r, g, b);
 170
 171       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
 172       RGB_OUT (d2 + BPP, r, g, b);
 173
 174       d1 += 2 * BPP;
 175       d2 += 2 * BPP;
 176
 177       y1_ptr += 2;
 178       y2_ptr += 2;
 179       cb_ptr++;
 180       cr_ptr++;
 181     }
 182     /* handle odd width */
 183     if (w) {
 184       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 185       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 186       RGB_OUT (d1, r, g, b);
 187
 188       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 189       RGB_OUT (d2, r, g, b);
 190       d1 += BPP;
 191       d2 += BPP;
 192       y1_ptr++;
 193       y2_ptr++;
 194       cb_ptr++;
 195       cr_ptr++;
 196     }
 197     d += 2 * dst->linesize[0];
 198     y1_ptr += 2 * src->linesize[0] - width;
 199     cb_ptr += src->linesize[1] - width2;
 200     cr_ptr += src->linesize[2] - width2;
 201   }
 202   /* handle odd height */
 203   if (height) {
 204     d1 = d;
 205     for (w = width; w >= 2; w -= 2) {
 206       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 207       /* output 2 pixels */
 208       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 209       RGB_OUT (d1, r, g, b);
 210
 211       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 212       RGB_OUT (d1 + BPP, r, g, b);
 213
 214       d1 += 2 * BPP;
 215
 216       y1_ptr += 2;
 217       cb_ptr++;
 218       cr_ptr++;
 219     }
 220     /* handle width */
 221     if (w) {
 222       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 223       /* output 2 pixel */
 224       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 225       RGB_OUT (d1, r, g, b);
 226       d1 += BPP;
 227
 228       y1_ptr++;
 229       cb_ptr++;
 230       cr_ptr++;
 231     }
 232   }
 233 }
 234
 235 #ifndef RGBA_OUT
 236 #define RGBA_OUT_(d, r, g, b, a) RGB_OUT(d, r, g, b)
 237 #define YUVA_TO_A(d, a)
 238 #else
 239 #define RGBA_OUT_(d, r, g, b, a) RGBA_OUT(d, r, g, b, a)
 240 #define YUVA_TO_A(d, a) do { d = a; } while (0);
 241 #endif
 242
 243 static void glue (yuva420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,
 244                                         int width, int height)
 245 {
 246   const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *a1_ptr, *a2_ptr;
 247   uint8_t *d, *d1, *d2;
 248   int w, y, cb, cr, r_add, g_add, b_add, width2;
 249   uint8_t *cm = cropTbl + MAX_NEG_CROP;
 250   unsigned int r, g, b;
 251 #ifdef RGBA_OUT
 252   unsigned int a = 0;
 253 #endif
 254
 255   d = dst->data[0];
 256   y1_ptr = src->data[0];
 257   cb_ptr = src->data[1];
 258   cr_ptr = src->data[2];
 259   a1_ptr = src->data[3];
 260   width2 = (width + 1) >> 1;
 261   for (; height >= 2; height -= 2) {
 262     d1 = d;
 263     d2 = d + dst->linesize[0];
 264     y2_ptr = y1_ptr + src->linesize[0];
 265     a2_ptr = a1_ptr + src->linesize[3];
 266     for (w = width; w >= 2; w -= 2) {
 267       YUVA_TO_A (a, a1_ptr[0]);
 268       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 269       /* output 4 pixels */
 270       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 271       RGBA_OUT_ (d1, r, g, b, a);
 272
 273       YUVA_TO_A (a, a1_ptr[1]);
 274       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 275       RGBA_OUT_ (d1 + BPP, r, g, b, a);
 276
 277       YUVA_TO_A (a, a2_ptr[0]);
 278       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 279       RGBA_OUT_ (d2, r, g, b, a);
 280
 281       YUVA_TO_A (a, a2_ptr[1]);
 282       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
 283       RGBA_OUT_ (d2 + BPP, r, g, b, a);
 284
 285       d1 += 2 * BPP;
 286       d2 += 2 * BPP;
 287
 288       y1_ptr += 2;
 289       y2_ptr += 2;
 290       cb_ptr++;
 291       cr_ptr++;
 292       a1_ptr += 2;
 293       a2_ptr += 2;
 294     }
 295     /* handle odd width */
 296     if (w) {
 297       YUVA_TO_A (a, a1_ptr[0]);
 298       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 299       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 300       RGBA_OUT_ (d1, r, g, b, a);
 301
 302       YUVA_TO_A (a, a2_ptr[0]);
 303       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 304       RGBA_OUT_ (d2, r, g, b, a);
 305       d1 += BPP;
 306       d2 += BPP;
 307       y1_ptr++;
 308       y2_ptr++;
 309       cb_ptr++;
 310       cr_ptr++;
 311       a1_ptr++;
 312       a2_ptr++;
 313     }
 314     d += 2 * dst->linesize[0];
 315     y1_ptr += 2 * src->linesize[0] - width;
 316     cb_ptr += src->linesize[1] - width2;
 317     cr_ptr += src->linesize[2] - width2;
 318     a1_ptr += 2 * src->linesize[3] - width;
 319   }
 320   /* handle odd height */
 321   if (height) {
 322     d1 = d;
 323     for (w = width; w >= 2; w -= 2) {
 324       YUVA_TO_A (a, a1_ptr[0]);
 325       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 326       /* output 2 pixels */
 327       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 328       RGBA_OUT_ (d1, r, g, b, a);
 329
 330       YUVA_TO_A (a, a1_ptr[1]);
 331       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 332       RGBA_OUT_ (d1 + BPP, r, g, b, a);
 333
 334       d1 += 2 * BPP;
 335
 336       y1_ptr += 2;
 337       cb_ptr++;
 338       cr_ptr++;
 339       a1_ptr += 2;
 340     }
 341     /* handle width */
 342     if (w) {
 343       YUVA_TO_A (a, a1_ptr[0]);
 344       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
 345       /* output 2 pixel */
 346       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 347       RGBA_OUT_ (d1, r, g, b, a);
 348       d1 += BPP;
 349
 350       y1_ptr++;
 351       cb_ptr++;
 352       cr_ptr++;
 353       a1_ptr++;
 354     }
 355   }
 356 }
 357
 358 static void glue (nv12_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
 359     int width, int height)
 360 {
 361   const uint8_t *y1_ptr, *y2_ptr, *c_ptr;
 362   uint8_t *d, *d1, *d2;
 363   int w, y, cb, cr, r_add, g_add, b_add;
 364   uint8_t *cm = cropTbl + MAX_NEG_CROP;
 365   unsigned int r, g, b;
 366   int c_wrap = src->linesize[1] - ((width + 1) & ~0x01);
 367
 368   d = dst->data[0];
 369   y1_ptr = src->data[0];
 370   c_ptr = src->data[1];
 371   for (; height >= 2; height -= 2) {
 372     d1 = d;
 373     d2 = d + dst->linesize[0];
 374     y2_ptr = y1_ptr + src->linesize[0];
 375     for (w = width; w >= 2; w -= 2) {
 376       YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
 377       /* output 4 pixels */
 378       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 379       RGB_OUT (d1, r, g, b);
 380
 381       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 382       RGB_OUT (d1 + BPP, r, g, b);
 383
 384       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 385       RGB_OUT (d2, r, g, b);
 386
 387       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
 388       RGB_OUT (d2 + BPP, r, g, b);
 389
 390       d1 += 2 * BPP;
 391       d2 += 2 * BPP;
 392
 393       y1_ptr += 2;
 394       y2_ptr += 2;
 395       c_ptr += 2;
 396     }
 397     /* handle odd width */
 398     if (w) {
 399       YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
 400       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 401       RGB_OUT (d1, r, g, b);
 402
 403       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 404       RGB_OUT (d2, r, g, b);
 405       d1 += BPP;
 406       d2 += BPP;
 407       y1_ptr++;
 408       y2_ptr++;
 409       c_ptr += 2;
 410     }
 411     d += 2 * dst->linesize[0];
 412     y1_ptr += 2 * src->linesize[0] - width;
 413     c_ptr += c_wrap;
 414   }
 415   /* handle odd height */
 416   if (height) {
 417     d1 = d;
 418     for (w = width; w >= 2; w -= 2) {
 419       YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
 420       /* output 2 pixels */
 421       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 422       RGB_OUT (d1, r, g, b);
 423
 424       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 425       RGB_OUT (d1 + BPP, r, g, b);
 426
 427       d1 += 2 * BPP;
 428
 429       y1_ptr += 2;
 430       c_ptr += 2;
 431     }
 432     /* handle odd width */
 433     if (w) {
 434       YUV_TO_RGB1_CCIR (c_ptr[0], c_ptr[1]);
 435       /* output 1 pixel */
 436       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 437       RGB_OUT (d1, r, g, b);
 438       d1 += BPP;
 439
 440       y1_ptr++;
 441       c_ptr += 2;
 442     }
 443   }
 444 }
 445
 446 static void glue (nv21_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
 447     int width, int height)
 448 {
 449   const uint8_t *y1_ptr, *y2_ptr, *c_ptr;
 450   uint8_t *d, *d1, *d2;
 451   int w, y, cb, cr, r_add, g_add, b_add;
 452   uint8_t *cm = cropTbl + MAX_NEG_CROP;
 453   unsigned int r, g, b;
 454   int c_wrap = src->linesize[1] - ((width + 1) & ~0x01);
 455
 456   d = dst->data[0];
 457   y1_ptr = src->data[0];
 458   c_ptr = src->data[1];
 459   for (; height >= 2; height -= 2) {
 460     d1 = d;
 461     d2 = d + dst->linesize[0];
 462     y2_ptr = y1_ptr + src->linesize[0];
 463     for (w = width; w >= 2; w -= 2) {
 464       YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
 465       /* output 4 pixels */
 466       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 467       RGB_OUT (d1, r, g, b);
 468
 469       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 470       RGB_OUT (d1 + BPP, r, g, b);
 471
 472       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 473       RGB_OUT (d2, r, g, b);
 474
 475       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[1]);
 476       RGB_OUT (d2 + BPP, r, g, b);
 477
 478       d1 += 2 * BPP;
 479       d2 += 2 * BPP;
 480
 481       y1_ptr += 2;
 482       y2_ptr += 2;
 483       c_ptr += 2;
 484     }
 485     /* handle odd width */
 486     if (w) {
 487       YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
 488       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 489       RGB_OUT (d1, r, g, b);
 490
 491       YUV_TO_RGB2_CCIR (r, g, b, y2_ptr[0]);
 492       RGB_OUT (d2, r, g, b);
 493       d1 += BPP;
 494       d2 += BPP;
 495       y1_ptr++;
 496       y2_ptr++;
 497       c_ptr += 2;
 498     }
 499     d += 2 * dst->linesize[0];
 500     y1_ptr += 2 * src->linesize[0] - width;
 501     c_ptr += c_wrap;
 502   }
 503   /* handle odd height */
 504   if (height) {
 505     d1 = d;
 506     for (w = width; w >= 2; w -= 2) {
 507       YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
 508       /* output 2 pixels */
 509       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 510       RGB_OUT (d1, r, g, b);
 511
 512       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[1]);
 513       RGB_OUT (d1 + BPP, r, g, b);
 514
 515       d1 += 2 * BPP;
 516
 517       y1_ptr += 2;
 518       c_ptr += 2;
 519     }
 520     /* handle odd width */
 521     if (w) {
 522       YUV_TO_RGB1_CCIR (c_ptr[1], c_ptr[0]);
 523       /* output 1 pixel */
 524       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
 525       RGB_OUT (d1, r, g, b);
 526       d1 += BPP;
 527
 528       y1_ptr++;
 529       c_ptr += 2;
 530     }
 531   }
 532 }
 533
 534 static void glue (yuvj420p_to_, RGB_NAME) (AVPicture * dst,
 535     const AVPicture * src, int width, int height)
 536 {
 537   const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;
 538   uint8_t *d, *d1, *d2;
 539   int w, y, cb, cr, r_add, g_add, b_add, width2;
 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   width2 = (width + 1) >> 1;
 548   for (; height >= 2; height -= 2) {
 549     d1 = d;
 550     d2 = d + dst->linesize[0];
 551     y2_ptr = y1_ptr + src->linesize[0];
 552     for (w = width; w >= 2; w -= 2) {
 553       YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
 554       /* output 4 pixels */
 555       YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
 556       RGB_OUT (d1, r, g, b);
 557
 558       YUV_TO_RGB2 (r, g, b, y1_ptr[1]);
 559       RGB_OUT (d1 + BPP, r, g, b);
 560
 561       YUV_TO_RGB2 (r, g, b, y2_ptr[0]);
 562       RGB_OUT (d2, r, g, b);
 563
 564       YUV_TO_RGB2 (r, g, b, y2_ptr[1]);
 565       RGB_OUT (d2 + BPP, r, g, b);
 566
 567       d1 += 2 * BPP;
 568       d2 += 2 * BPP;
 569
 570       y1_ptr += 2;
 571       y2_ptr += 2;
 572       cb_ptr++;
 573       cr_ptr++;
 574     }
 575     /* handle odd width */
 576     if (w) {
 577       YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
 578       YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
 579       RGB_OUT (d1, r, g, b);
 580
 581       YUV_TO_RGB2 (r, g, b, y2_ptr[0]);
 582       RGB_OUT (d2, r, g, b);
 583       d1 += BPP;
 584       d2 += BPP;
 585       y1_ptr++;
 586       y2_ptr++;
 587       cb_ptr++;
 588       cr_ptr++;
 589     }
 590     d += 2 * dst->linesize[0];
 591     y1_ptr += 2 * src->linesize[0] - width;
 592     cb_ptr += src->linesize[1] - width2;
 593     cr_ptr += src->linesize[2] - width2;
 594   }
 595   /* handle odd height */
 596   if (height) {
 597     d1 = d;
 598     for (w = width; w >= 2; w -= 2) {
 599       YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
 600       /* output 2 pixels */
 601       YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
 602       RGB_OUT (d1, r, g, b);
 603
 604       YUV_TO_RGB2 (r, g, b, y1_ptr[1]);
 605       RGB_OUT (d1 + BPP, r, g, b);
 606
 607       d1 += 2 * BPP;
 608
 609       y1_ptr += 2;
 610       cb_ptr++;
 611       cr_ptr++;
 612     }
 613     /* handle width */
 614     if (w) {
 615       YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
 616       /* output 2 pixels */
 617       YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
 618       RGB_OUT (d1, r, g, b);
 619       d1 += BPP;
 620
 621       y1_ptr++;
 622       cb_ptr++;
 623       cr_ptr++;
 624     }
 625   }
 626 }
 627
 628 static void glue (y800_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
 629     int width, int height)
 630 {
 631   const unsigned char *p;
 632   unsigned char *q;
 633   uint8_t *cm = cropTbl + MAX_NEG_CROP;
 634   int r, dst_wrap, src_wrap;
 635   int x, y;
 636
 637   p = src->data[0];
 638   src_wrap = src->linesize[0] - width;
 639
 640   q = dst->data[0];
 641   dst_wrap = dst->linesize[0] - BPP * width;
 642
 643   for (y = 0; y < height; y++) {
 644     for (x = 0; x < width; x++) {
 645       r = Y_CCIR_TO_JPEG (p[0]);
 646       RGB_OUT (q, r, r, r);
 647       q += BPP;
 648       p++;
 649     }
 650     p += src_wrap;
 651     q += dst_wrap;
 652   }
 653 }
 654
 655 static void glue (y16_to_, RGB_NAME) (AVPicture * dst,
 656     const AVPicture * src, int width, int height)
 657 {
 658   const unsigned char *p;
 659   unsigned char *q;
 660   uint8_t *cm = cropTbl + MAX_NEG_CROP;
 661   int r, dst_wrap, src_wrap;
 662   int x, y;
 663
 664   p = src->data[0];
 665   src_wrap = src->linesize[0] - 2 * width;
 666
 667   q = dst->data[0];
 668   dst_wrap = dst->linesize[0] - BPP * width;
 669
 670   for (y = 0; y < height; y++) {
 671     for (x = 0; x < width; x++) {
 672       r = Y_CCIR_TO_JPEG (GST_READ_UINT16_LE (p) >> 8);
 673       RGB_OUT (q, r, r, r);
 674       q += BPP;
 675       p += 2;
 676     }
 677     p += src_wrap;
 678     q += dst_wrap;
 679   }
 680 }
 681
 682 static void glue (RGB_NAME, _to_yuv420p) (AVPicture * dst,
 683     const AVPicture * src, int width, int height)
 684 {
 685   int wrap, wrap3, width2;
 686   int r, g, b, r1, g1, b1, w;
 687   uint8_t *lum, *cb, *cr;
 688   const uint8_t *p;
 689
 690   lum = dst->data[0];
 691   cb = dst->data[1];
 692   cr = dst->data[2];
 693
 694   width2 = (width + 1) >> 1;
 695   wrap = dst->linesize[0];
 696   wrap3 = src->linesize[0];
 697   p = src->data[0];
 698   for (; height >= 2; height -= 2) {
 699     for (w = width; w >= 2; w -= 2) {
 700       RGB_IN (r, g, b, p);
 701       r1 = r;
 702       g1 = g;
 703       b1 = b;
 704       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 705
 706       RGB_IN (r, g, b, p + BPP);
 707       r1 += r;
 708       g1 += g;
 709       b1 += b;
 710       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 711       p += wrap3;
 712       lum += wrap;
 713
 714       RGB_IN (r, g, b, p);
 715       r1 += r;
 716       g1 += g;
 717       b1 += b;
 718       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 719
 720       RGB_IN (r, g, b, p + BPP);
 721       r1 += r;
 722       g1 += g;
 723       b1 += b;
 724       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 725
 726       cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 2);
 727       cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 2);
 728
 729
 730       cb++;
 731       cr++;
 732       p += -wrap3 + 2 * BPP;
 733       lum += -wrap + 2;
 734     }
 735     if (w) {
 736       RGB_IN (r, g, b, p);
 737       r1 = r;
 738       g1 = g;
 739       b1 = b;
 740       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 741       p += wrap3;
 742       lum += wrap;
 743       RGB_IN (r, g, b, p);
 744       r1 += r;
 745       g1 += g;
 746       b1 += b;
 747       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 748       cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
 749       cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
 750       cb++;
 751       cr++;
 752       p += -wrap3 + BPP;
 753       lum += -wrap + 1;
 754     }
 755     p += wrap3 + (wrap3 - width * BPP);
 756     lum += wrap + (wrap - width);
 757     cb += dst->linesize[1] - width2;
 758     cr += dst->linesize[2] - width2;
 759   }
 760   /* handle odd height */
 761   if (height) {
 762     for (w = width; w >= 2; w -= 2) {
 763       RGB_IN (r, g, b, p);
 764       r1 = r;
 765       g1 = g;
 766       b1 = b;
 767       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 768
 769       RGB_IN (r, g, b, p + BPP);
 770       r1 += r;
 771       g1 += g;
 772       b1 += b;
 773       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 774       cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
 775       cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
 776       cb++;
 777       cr++;
 778       p += 2 * BPP;
 779       lum += 2;
 780     }
 781     if (w) {
 782       RGB_IN (r, g, b, p);
 783       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 784       cb[0] = RGB_TO_U_CCIR (r, g, b, 0);
 785       cr[0] = RGB_TO_V_CCIR (r, g, b, 0);
 786     }
 787   }
 788 }
 789
 790 #ifndef RGBA_IN
 791 #define RGBA_IN_(r, g, b, a, p) RGB_IN(r, g, b, p)
 792 #else
 793 #define RGBA_IN_(r, g, b, a, p) RGBA_IN(r, g, b, a, p)
 794 #endif
 795
 796 static void glue (RGB_NAME, _to_yuva420p) (AVPicture * dst,
 797     const AVPicture * src, int width, int height)
 798 {
 799   int wrap, wrap3, width2;
 800   int r, g, b, r1, g1, b1, w, ra = 255;
 801   uint8_t *lum, *cb, *cr, *a;
 802   const uint8_t *p;
 803
 804   lum = dst->data[0];
 805   cb = dst->data[1];
 806   cr = dst->data[2];
 807   a = dst->data[3];
 808
 809   width2 = (width + 1) >> 1;
 810   wrap = dst->linesize[0];
 811   wrap3 = src->linesize[0];
 812   p = src->data[0];
 813   for (; height >= 2; height -= 2) {
 814     for (w = width; w >= 2; w -= 2) {
 815       RGBA_IN_ (r, g, b, ra, p);
 816       r1 = r;
 817       g1 = g;
 818       b1 = b;
 819       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 820       a[0] = ra;
 821
 822       RGBA_IN_ (r, g, b, ra, p + BPP);
 823       r1 += r;
 824       g1 += g;
 825       b1 += b;
 826       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 827       a[1] = ra;
 828       p += wrap3;
 829       lum += wrap;
 830       a += wrap;
 831
 832       RGBA_IN_ (r, g, b, ra, p);
 833       r1 += r;
 834       g1 += g;
 835       b1 += b;
 836       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 837       a[0] = ra;
 838
 839       RGBA_IN_ (r, g, b, ra, p + BPP);
 840       r1 += r;
 841       g1 += g;
 842       b1 += b;
 843       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 844       a[1] = ra;
 845
 846       cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 2);
 847       cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 2);
 848
 849       cb++;
 850       cr++;
 851       p += -wrap3 + 2 * BPP;
 852       lum += -wrap + 2;
 853       a += -wrap + 2;
 854     }
 855     if (w) {
 856       RGBA_IN_ (r, g, b, ra, p);
 857       r1 = r;
 858       g1 = g;
 859       b1 = b;
 860       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 861       a[0] = ra;
 862       p += wrap3;
 863       lum += wrap;
 864       a += wrap;
 865       RGBA_IN_ (r, g, b, ra, p);
 866       r1 += r;
 867       g1 += g;
 868       b1 += b;
 869       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 870       a[0] = ra;
 871       cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
 872       cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
 873       cb++;
 874       cr++;
 875       p += -wrap3 + BPP;
 876       lum += -wrap + 1;
 877       a += -wrap + 1;
 878     }
 879     p += wrap3 + (wrap3 - width * BPP);
 880     lum += wrap + (wrap - width);
 881     a += wrap + (wrap - width);
 882     cb += dst->linesize[1] - width2;
 883     cr += dst->linesize[2] - width2;
 884   }
 885   /* handle odd height */
 886   if (height) {
 887     for (w = width; w >= 2; w -= 2) {
 888       RGBA_IN_ (r, g, b, ra, p);
 889       r1 = r;
 890       g1 = g;
 891       b1 = b;
 892       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 893       a[0] = ra;
 894
 895       RGBA_IN_ (r, g, b, ra, p + BPP);
 896       r1 += r;
 897       g1 += g;
 898       b1 += b;
 899       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 900       a[1] = ra;
 901       cb[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
 902       cr[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
 903       cb++;
 904       cr++;
 905       p += 2 * BPP;
 906       lum += 2;
 907       a += 2;
 908     }
 909     if (w) {
 910       RGBA_IN_ (r, g, b, ra, p);
 911       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 912       a[0] = ra;
 913       cb[0] = RGB_TO_U_CCIR (r, g, b, 0);
 914       cr[0] = RGB_TO_V_CCIR (r, g, b, 0);
 915     }
 916   }
 917 }
 918
 919 static void glue (RGB_NAME, _to_nv12) (AVPicture * dst, const AVPicture * src,
 920     int width, int height)
 921 {
 922   int wrap, wrap3;
 923   int r, g, b, r1, g1, b1, w;
 924   uint8_t *lum, *c;
 925   const uint8_t *p;
 926
 927   lum = dst->data[0];
 928   c = dst->data[1];
 929
 930   wrap = dst->linesize[0];
 931   wrap3 = src->linesize[0];
 932   p = src->data[0];
 933   for (; height >= 2; height -= 2) {
 934     for (w = width; w >= 2; w -= 2) {
 935       RGB_IN (r, g, b, p);
 936       r1 = r;
 937       g1 = g;
 938       b1 = b;
 939       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 940
 941       RGB_IN (r, g, b, p + BPP);
 942       r1 += r;
 943       g1 += g;
 944       b1 += b;
 945       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 946       p += wrap3;
 947       lum += wrap;
 948
 949       RGB_IN (r, g, b, p);
 950       r1 += r;
 951       g1 += g;
 952       b1 += b;
 953       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 954
 955       RGB_IN (r, g, b, p + BPP);
 956       r1 += r;
 957       g1 += g;
 958       b1 += b;
 959       lum[1] = RGB_TO_Y_CCIR (r, g, b);
 960
 961       c[0] = RGB_TO_U_CCIR (r1, g1, b1, 2);
 962       c[1] = RGB_TO_V_CCIR (r1, g1, b1, 2);
 963
 964
 965       c += 2;
 966       p += -wrap3 + 2 * BPP;
 967       lum += -wrap + 2;
 968     }
 969     /* handle odd width */
 970     if (w) {
 971       RGB_IN (r, g, b, p);
 972       r1 = r;
 973       g1 = g;
 974       b1 = b;
 975       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 976       p += wrap3;
 977       lum += wrap;
 978       RGB_IN (r, g, b, p);
 979       r1 += r;
 980       g1 += g;
 981       b1 += b;
 982       lum[0] = RGB_TO_Y_CCIR (r, g, b);
 983       c[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
 984       c[1] = RGB_TO_V_CCIR (r1, g1, b1, 1);
 985       p += -wrap3 + BPP;
 986       lum += -wrap + 1;
 987     }
 988     p += wrap3 + (wrap3 - width * BPP);
 989     lum += wrap + (wrap - width);
 990     c += dst->linesize[1] - (width & ~1);
 991   }
 992   /* handle odd height */
 993   if (height) {
 994     for (w = width; w >= 2; w -= 2) {
 995       RGB_IN (r, g, b, p);
 996       r1 = r;
 997       g1 = g;
 998       b1 = b;
 999       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1000
1001       RGB_IN (r, g, b, p + BPP);
1002       r1 += r;
1003       g1 += g;
1004       b1 += b;
1005       lum[1] = RGB_TO_Y_CCIR (r, g, b);
1006       c[0] = RGB_TO_U_CCIR (r1, g1, b1, 1);
1007       c[1] = RGB_TO_V_CCIR (r1, g1, b1, 1);
1008       c += 2;
1009       p += 2 * BPP;
1010       lum += 2;
1011     }
1012     /* handle odd width */
1013     if (w) {
1014       RGB_IN (r, g, b, p);
1015       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1016       c[0] = RGB_TO_U_CCIR (r, g, b, 0);
1017       c[1] = RGB_TO_V_CCIR (r, g, b, 0);
1018     }
1019   }
1020 }
1021
1022 static void glue (RGB_NAME, _to_nv21) (AVPicture * dst, const AVPicture * src,
1023     int width, int height)
1024 {
1025   int wrap, wrap3;
1026   int r, g, b, r1, g1, b1, w;
1027   uint8_t *lum, *c;
1028   const uint8_t *p;
1029
1030   lum = dst->data[0];
1031   c = dst->data[1];
1032
1033   wrap = dst->linesize[0];
1034   wrap3 = src->linesize[0];
1035   p = src->data[0];
1036   for (; height >= 2; height -= 2) {
1037     for (w = width; w >= 2; w -= 2) {
1038       RGB_IN (r, g, b, p);
1039       r1 = r;
1040       g1 = g;
1041       b1 = b;
1042       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1043
1044       RGB_IN (r, g, b, p + BPP);
1045       r1 += r;
1046       g1 += g;
1047       b1 += b;
1048       lum[1] = RGB_TO_Y_CCIR (r, g, b);
1049       p += wrap3;
1050       lum += wrap;
1051
1052       RGB_IN (r, g, b, p);
1053       r1 += r;
1054       g1 += g;
1055       b1 += b;
1056       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1057
1058       RGB_IN (r, g, b, p + BPP);
1059       r1 += r;
1060       g1 += g;
1061       b1 += b;
1062       lum[1] = RGB_TO_Y_CCIR (r, g, b);
1063
1064       c[1] = RGB_TO_U_CCIR (r1, g1, b1, 2);
1065       c[0] = RGB_TO_V_CCIR (r1, g1, b1, 2);
1066
1067
1068       c += 2;
1069       p += -wrap3 + 2 * BPP;
1070       lum += -wrap + 2;
1071     }
1072     /* handle odd width */
1073     if (w) {
1074       RGB_IN (r, g, b, p);
1075       r1 = r;
1076       g1 = g;
1077       b1 = b;
1078       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1079       p += wrap3;
1080       lum += wrap;
1081       RGB_IN (r, g, b, p);
1082       r1 += r;
1083       g1 += g;
1084       b1 += b;
1085       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1086       c[1] = RGB_TO_U_CCIR (r1, g1, b1, 1);
1087       c[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
1088       p += -wrap3 + BPP;
1089       lum += -wrap + 1;
1090     }
1091     p += wrap3 + (wrap3 - width * BPP);
1092     lum += wrap + (wrap - width);
1093     c += dst->linesize[1] - (width & ~1);
1094   }
1095   /* handle odd height */
1096   if (height) {
1097     for (w = width; w >= 2; w -= 2) {
1098       RGB_IN (r, g, b, p);
1099       r1 = r;
1100       g1 = g;
1101       b1 = b;
1102       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1103
1104       RGB_IN (r, g, b, p + BPP);
1105       r1 += r;
1106       g1 += g;
1107       b1 += b;
1108       lum[1] = RGB_TO_Y_CCIR (r, g, b);
1109       c[1] = RGB_TO_U_CCIR (r1, g1, b1, 1);
1110       c[0] = RGB_TO_V_CCIR (r1, g1, b1, 1);
1111       c += 2;
1112       p += 2 * BPP;
1113       lum += 2;
1114     }
1115     /* handle odd width */
1116     if (w) {
1117       RGB_IN (r, g, b, p);
1118       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1119       c[1] = RGB_TO_U_CCIR (r, g, b, 0);
1120       c[0] = RGB_TO_V_CCIR (r, g, b, 0);
1121     }
1122   }
1123 }
1124
1125 static void glue (RGB_NAME, _to_gray) (AVPicture * dst, const AVPicture * src,
1126     int width, int height)
1127 {
1128   const unsigned char *p;
1129   unsigned char *q;
1130   int r, g, b, dst_wrap, src_wrap;
1131   int x, y;
1132
1133   p = src->data[0];
1134   src_wrap = src->linesize[0] - BPP * width;
1135
1136   q = dst->data[0];
1137   dst_wrap = dst->linesize[0] - width;
1138
1139   for (y = 0; y < height; y++) {
1140     for (x = 0; x < width; x++) {
1141       RGB_IN (r, g, b, p);
1142       q[0] = RGB_TO_Y (r, g, b);
1143       q++;
1144       p += BPP;
1145     }
1146     p += src_wrap;
1147     q += dst_wrap;
1148   }
1149 }
1150
1151 static void glue (RGB_NAME, _to_y800) (AVPicture * dst, const AVPicture * src,
1152     int width, int height)
1153 {
1154   const unsigned char *p;
1155   unsigned char *q;
1156   int r, g, b, dst_wrap, src_wrap;
1157   int x, y;
1158
1159   p = src->data[0];
1160   src_wrap = src->linesize[0] - BPP * width;
1161
1162   q = dst->data[0];
1163   dst_wrap = dst->linesize[0] - width;
1164
1165   for (y = 0; y < height; y++) {
1166     for (x = 0; x < width; x++) {
1167       RGB_IN (r, g, b, p);
1168       q[0] = RGB_TO_Y_CCIR (r, g, b);
1169       q++;
1170       p += BPP;
1171     }
1172     p += src_wrap;
1173     q += dst_wrap;
1174   }
1175 }
1176
1177 static void glue (RGB_NAME, _to_y16) (AVPicture * dst,
1178     const AVPicture * src, int width, int height)
1179 {
1180   const unsigned char *p;
1181   unsigned char *q;
1182   int r, g, b, dst_wrap, src_wrap;
1183   int x, y;
1184
1185   p = src->data[0];
1186   src_wrap = src->linesize[0] - BPP * width;
1187
1188   q = dst->data[0];
1189   dst_wrap = dst->linesize[0] - 2 * width;
1190
1191   for (y = 0; y < height; y++) {
1192     for (x = 0; x < width; x++) {
1193       RGB_IN (r, g, b, p);
1194       GST_WRITE_UINT16_LE (q, RGB_TO_Y_CCIR (r, g, b) << 8);
1195       q += 2;
1196       p += BPP;
1197     }
1198     p += src_wrap;
1199     q += dst_wrap;
1200   }
1201 }
1202
1203 static void glue (gray_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1204     int width, int height)
1205 {
1206   const unsigned char *p;
1207   unsigned char *q;
1208   int r, dst_wrap, src_wrap;
1209   int x, y;
1210
1211   p = src->data[0];
1212   src_wrap = src->linesize[0] - width;
1213
1214   q = dst->data[0];
1215   dst_wrap = dst->linesize[0] - BPP * width;
1216
1217   for (y = 0; y < height; y++) {
1218     for (x = 0; x < width; x++) {
1219       r = p[0];
1220       RGB_OUT (q, r, r, r);
1221       q += BPP;
1222       p++;
1223     }
1224     p += src_wrap;
1225     q += dst_wrap;
1226   }
1227 }
1228
1229 static void glue (RGB_NAME, _to_gray16_l) (AVPicture * dst,
1230     const AVPicture * src, int width, int height)
1231 {
1232   const unsigned char *p;
1233   unsigned char *q;
1234   int r, g, b, dst_wrap, src_wrap;
1235   int x, y;
1236
1237   p = src->data[0];
1238   src_wrap = src->linesize[0] - BPP * width;
1239
1240   q = dst->data[0];
1241   dst_wrap = dst->linesize[0] - 2 * width;
1242
1243   for (y = 0; y < height; y++) {
1244     for (x = 0; x < width; x++) {
1245       RGB_IN (r, g, b, p);
1246       GST_WRITE_UINT16_LE (q, RGB_TO_Y (r, g, b) << 8);
1247       q += 2;
1248       p += BPP;
1249     }
1250     p += src_wrap;
1251     q += dst_wrap;
1252   }
1253 }
1254
1255 static void glue (gray16_l_to_, RGB_NAME) (AVPicture * dst,
1256     const AVPicture * src, int width, int height)
1257 {
1258   const unsigned char *p;
1259   unsigned char *q;
1260   int r, dst_wrap, src_wrap;
1261   int x, y;
1262
1263   p = src->data[0];
1264   src_wrap = src->linesize[0] - 2 * width;
1265
1266   q = dst->data[0];
1267   dst_wrap = dst->linesize[0] - BPP * width;
1268
1269   for (y = 0; y < height; y++) {
1270     for (x = 0; x < width; x++) {
1271       r = GST_READ_UINT16_LE (p) >> 8;
1272       RGB_OUT (q, r, r, r);
1273       q += BPP;
1274       p += 2;
1275     }
1276     p += src_wrap;
1277     q += dst_wrap;
1278   }
1279 }
1280
1281 static void glue (RGB_NAME, _to_gray16_b) (AVPicture * dst,
1282     const AVPicture * src, int width, int height)
1283 {
1284   const unsigned char *p;
1285   unsigned char *q;
1286   int r, g, b, dst_wrap, src_wrap;
1287   int x, y;
1288
1289   p = src->data[0];
1290   src_wrap = src->linesize[0] - BPP * width;
1291
1292   q = dst->data[0];
1293   dst_wrap = dst->linesize[0] - 2 * width;
1294
1295   for (y = 0; y < height; y++) {
1296     for (x = 0; x < width; x++) {
1297       RGB_IN (r, g, b, p);
1298       GST_WRITE_UINT16_BE (q, RGB_TO_Y (r, g, b) << 8);
1299       q += 2;
1300       p += BPP;
1301     }
1302     p += src_wrap;
1303     q += dst_wrap;
1304   }
1305 }
1306
1307 static void glue (gray16_b_to_, RGB_NAME) (AVPicture * dst,
1308     const AVPicture * src, int width, int height)
1309 {
1310   const unsigned char *p;
1311   unsigned char *q;
1312   int r, dst_wrap, src_wrap;
1313   int x, y;
1314
1315   p = src->data[0];
1316   src_wrap = src->linesize[0] - 2 * width;
1317
1318   q = dst->data[0];
1319   dst_wrap = dst->linesize[0] - BPP * width;
1320
1321   for (y = 0; y < height; y++) {
1322     for (x = 0; x < width; x++) {
1323       r = GST_READ_UINT16_BE (p) >> 8;
1324       RGB_OUT (q, r, r, r);
1325       q += BPP;
1326       p += 2;
1327     }
1328     p += src_wrap;
1329     q += dst_wrap;
1330   }
1331 }
1332
1333 static void glue (pal8_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1334     int width, int height)
1335 {
1336   const unsigned char *p;
1337   unsigned char *q;
1338   int r, g, b, dst_wrap, src_wrap;
1339   int x, y;
1340   uint32_t v;
1341   const uint32_t *palette;
1342
1343   p = src->data[0];
1344   src_wrap = src->linesize[0] - width;
1345   palette = (uint32_t *) src->data[1];
1346
1347   q = dst->data[0];
1348   dst_wrap = dst->linesize[0] - BPP * width;
1349
1350   for (y = 0; y < height; y++) {
1351     for (x = 0; x < width; x++) {
1352       v = palette[p[0]];
1353       r = (v >> 16) & 0xff;
1354       g = (v >> 8) & 0xff;
1355       b = (v) & 0xff;
1356 #ifdef RGBA_OUT
1357       {
1358         int a;
1359         a = (v >> 24) & 0xff;
1360         RGBA_OUT (q, r, g, b, a);
1361       }
1362 #else
1363       RGB_OUT (q, r, g, b);
1364 #endif
1365       q += BPP;
1366       p++;
1367     }
1368     p += src_wrap;
1369     q += dst_wrap;
1370   }
1371 }
1372
1373 #if !defined(FMT_RGBA32) && defined(RGBA_OUT)
1374 /* alpha support */
1375
1376 static void glue (rgba32_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1377     int width, int height)
1378 {
1379   const uint8_t *s;
1380   uint8_t *d;
1381   int src_wrap, dst_wrap, j, y;
1382   unsigned int v, r, g, b, a;
1383
1384   s = src->data[0];
1385   src_wrap = src->linesize[0] - width * 4;
1386
1387   d = dst->data[0];
1388   dst_wrap = dst->linesize[0] - width * BPP;
1389
1390   for (y = 0; y < height; y++) {
1391     for (j = 0; j < width; j++) {
1392       v = ((const uint32_t *) (s))[0];
1393       a = (v >> 24) & 0xff;
1394       r = (v >> 16) & 0xff;
1395       g = (v >> 8) & 0xff;
1396       b = v & 0xff;
1397       RGBA_OUT (d, r, g, b, a);
1398       s += 4;
1399       d += BPP;
1400     }
1401     s += src_wrap;
1402     d += dst_wrap;
1403   }
1404 }
1405
1406 static void glue (RGB_NAME, _to_rgba32) (AVPicture * dst, const AVPicture * src,
1407     int width, int height)
1408 {
1409   const uint8_t *s;
1410   uint8_t *d;
1411   int src_wrap, dst_wrap, j, y;
1412   unsigned int r, g, b, a;
1413
1414   s = src->data[0];
1415   src_wrap = src->linesize[0] - width * BPP;
1416
1417   d = dst->data[0];
1418   dst_wrap = dst->linesize[0] - width * 4;
1419
1420   for (y = 0; y < height; y++) {
1421     for (j = 0; j < width; j++) {
1422       RGBA_IN (r, g, b, a, s);
1423       ((uint32_t *) (d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
1424       d += 4;
1425       s += BPP;
1426     }
1427     s += src_wrap;
1428     d += dst_wrap;
1429   }
1430 }
1431 #endif /* !defined(FMT_RGBA32) && defined(RGBA_OUT) */
1432
1433 #if defined(FMT_RGBA32)
1434
1435 #if !defined(rgba32_fcts_done)
1436 #define rgba32_fcts_done
1437
1438 static void
1439 ayuv4444_to_rgba32 (AVPicture * dst, const AVPicture * src,
1440     int width, int height)
1441 {
1442   uint8_t *s, *d, *d1, *s1;
1443   int w, y, cb, cr, r_add, g_add, b_add;
1444   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1445   unsigned int r, g, b, a;
1446
1447   d = dst->data[0];
1448   s = src->data[0];
1449   for (; height > 0; height--) {
1450     d1 = d;
1451     s1 = s;
1452     for (w = width; w > 0; w--) {
1453       a = s1[0];
1454       YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1455
1456       YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1457       RGBA_OUT (d1, r, g, b, a);
1458       d1 += BPP;
1459       s1 += 4;
1460     }
1461     d += dst->linesize[0];
1462     s += src->linesize[0];
1463   }
1464 }
1465
1466 static void
1467 rgba32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1468     int width, int height)
1469 {
1470   int src_wrap, dst_wrap, x, y;
1471   int r, g, b, a;
1472   uint8_t *d;
1473   const uint8_t *p;
1474
1475   src_wrap = src->linesize[0] - width * BPP;
1476   dst_wrap = dst->linesize[0] - width * 4;
1477   d = dst->data[0];
1478   p = src->data[0];
1479   for (y = 0; y < height; y++) {
1480     for (x = 0; x < width; x++) {
1481       RGBA_IN (r, g, b, a, p);
1482       d[0] = a;
1483       d[1] = RGB_TO_Y_CCIR (r, g, b);
1484       d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1485       d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1486       p += BPP;
1487       d += 4;
1488     }
1489     p += src_wrap;
1490     d += dst_wrap;
1491   }
1492 }
1493
1494 #endif /* !defined(rgba32_fcts_done) */
1495
1496 #endif /* defined(FMT_RGBA32) */
1497
1498 #if defined(FMT_BGRA32)
1499 #if !defined(bgra32_fcts_done)
1500 #define bgra32_fcts_done
1501
1502 static void
1503 bgra32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1504     int width, int height)
1505 {
1506   int src_wrap, dst_wrap, x, y;
1507   int r, g, b, a;
1508   uint8_t *d;
1509   const uint8_t *p;
1510
1511   src_wrap = src->linesize[0] - width * BPP;
1512   dst_wrap = dst->linesize[0] - width * 4;
1513   d = dst->data[0];
1514   p = src->data[0];
1515   for (y = 0; y < height; y++) {
1516     for (x = 0; x < width; x++) {
1517       RGBA_IN (r, g, b, a, p);
1518       d[0] = a;
1519       d[1] = RGB_TO_Y_CCIR (r, g, b);
1520       d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1521       d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1522       p += BPP;
1523       d += 4;
1524     }
1525     p += src_wrap;
1526     d += dst_wrap;
1527   }
1528 }
1529
1530 static void
1531 ayuv4444_to_bgra32 (AVPicture * dst, const AVPicture * src,
1532     int width, int height)
1533 {
1534   uint8_t *s, *d, *d1, *s1;
1535   int w, y, cb, cr, r_add, g_add, b_add;
1536   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1537   unsigned int r, g, b, a;
1538
1539   d = dst->data[0];
1540   s = src->data[0];
1541   for (; height > 0; height--) {
1542     d1 = d;
1543     s1 = s;
1544     for (w = width; w > 0; w--) {
1545       a = s1[0];
1546       YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1547
1548       YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1549       RGBA_OUT (d1, r, g, b, a);
1550       d1 += BPP;
1551       s1 += 4;
1552     }
1553     d += dst->linesize[0];
1554     s += src->linesize[0];
1555   }
1556 }
1557
1558 #endif /* !defined(bgra32_fcts_done) */
1559
1560 #endif /* defined(FMT_BGRA32) */
1561
1562 #if defined(FMT_ARGB32)
1563
1564 #if !defined(argb32_fcts_done)
1565 #define argb32_fcts_done
1566
1567 static void
1568 ayuv4444_to_argb32 (AVPicture * dst, const AVPicture * src,
1569     int width, int height)
1570 {
1571   uint8_t *s, *d, *d1, *s1;
1572   int w, y, cb, cr, r_add, g_add, b_add;
1573   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1574   unsigned int r, g, b, a;
1575
1576   d = dst->data[0];
1577   s = src->data[0];
1578   for (; height > 0; height--) {
1579     d1 = d;
1580     s1 = s;
1581     for (w = width; w > 0; w--) {
1582       a = s1[0];
1583       YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1584
1585       YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1586       RGBA_OUT (d1, r, g, b, a);
1587       d1 += BPP;
1588       s1 += 4;
1589     }
1590     d += dst->linesize[0];
1591     s += src->linesize[0];
1592   }
1593 }
1594
1595 static void
1596 argb32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1597     int width, int height)
1598 {
1599   int src_wrap, dst_wrap, x, y;
1600   int r, g, b, a;
1601   uint8_t *d;
1602   const uint8_t *p;
1603
1604   src_wrap = src->linesize[0] - width * BPP;
1605   dst_wrap = dst->linesize[0] - width * 4;
1606   d = dst->data[0];
1607   p = src->data[0];
1608   for (y = 0; y < height; y++) {
1609     for (x = 0; x < width; x++) {
1610       RGBA_IN (r, g, b, a, p);
1611       d[0] = a;
1612       d[1] = RGB_TO_Y_CCIR (r, g, b);
1613       d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1614       d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1615       p += BPP;
1616       d += 4;
1617     }
1618     p += src_wrap;
1619     d += dst_wrap;
1620   }
1621 }
1622
1623 #endif /* !defined(argb32_fcts_done) */
1624
1625 #endif /* defined(FMT_ARGB32) */
1626
1627 #if defined(FMT_ABGR32)
1628 #if !defined(abgr32_fcts_done)
1629 #define abgr32_fcts_done
1630
1631 static void
1632 abgr32_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
1633     int width, int height)
1634 {
1635   int src_wrap, dst_wrap, x, y;
1636   int r, g, b, a;
1637   uint8_t *d;
1638   const uint8_t *p;
1639
1640   src_wrap = src->linesize[0] - width * BPP;
1641   dst_wrap = dst->linesize[0] - width * 4;
1642   d = dst->data[0];
1643   p = src->data[0];
1644   for (y = 0; y < height; y++) {
1645     for (x = 0; x < width; x++) {
1646       RGBA_IN (r, g, b, a, p);
1647       d[0] = a;
1648       d[1] = RGB_TO_Y_CCIR (r, g, b);
1649       d[2] = RGB_TO_U_CCIR (r, g, b, 0);
1650       d[3] = RGB_TO_V_CCIR (r, g, b, 0);
1651       p += BPP;
1652       d += 4;
1653     }
1654     p += src_wrap;
1655     d += dst_wrap;
1656   }
1657 }
1658
1659 static void
1660 ayuv4444_to_abgr32 (AVPicture * dst, const AVPicture * src,
1661     int width, int height)
1662 {
1663   uint8_t *s, *d, *d1, *s1;
1664   int w, y, cb, cr, r_add, g_add, b_add;
1665   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1666   unsigned int r, g, b, a;
1667
1668   d = dst->data[0];
1669   s = src->data[0];
1670   for (; height > 0; height--) {
1671     d1 = d;
1672     s1 = s;
1673     for (w = width; w > 0; w--) {
1674       a = s1[0];
1675       YUV_TO_RGB1_CCIR (s1[2], s1[3]);
1676
1677       YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
1678       RGBA_OUT (d1, r, g, b, a);
1679       d1 += BPP;
1680       s1 += 4;
1681     }
1682     d += dst->linesize[0];
1683     s += src->linesize[0];
1684   }
1685 }
1686
1687 #endif /* !defined(abgr32_fcts_done) */
1688
1689 #endif /* defined(FMT_ABGR32) */
1690
1691 #ifndef FMT_RGB24
1692
1693 static void glue (rgb24_to_, RGB_NAME) (AVPicture * dst, const AVPicture * src,
1694     int width, int height)
1695 {
1696   const uint8_t *s;
1697   uint8_t *d;
1698   int src_wrap, dst_wrap, j, y;
1699   unsigned int r, g, b;
1700
1701   s = src->data[0];
1702   src_wrap = src->linesize[0] - width * 3;
1703
1704   d = dst->data[0];
1705   dst_wrap = dst->linesize[0] - width * BPP;
1706
1707   for (y = 0; y < height; y++) {
1708     for (j = 0; j < width; j++) {
1709       r = s[0];
1710       g = s[1];
1711       b = s[2];
1712       RGB_OUT (d, r, g, b);
1713       s += 3;
1714       d += BPP;
1715     }
1716     s += src_wrap;
1717     d += dst_wrap;
1718   }
1719 }
1720
1721 static void glue (RGB_NAME, _to_rgb24) (AVPicture * dst, const AVPicture * src,
1722     int width, int height)
1723 {
1724   const uint8_t *s;
1725   uint8_t *d;
1726   int src_wrap, dst_wrap, j, y;
1727   unsigned int r, g, b;
1728
1729   s = src->data[0];
1730   src_wrap = src->linesize[0] - width * BPP;
1731
1732   d = dst->data[0];
1733   dst_wrap = dst->linesize[0] - width * 3;
1734
1735   for (y = 0; y < height; y++) {
1736     for (j = 0; j < width; j++) {
1737       RGB_IN (r, g, b, s)
1738           d[0] = r;
1739       d[1] = g;
1740       d[2] = b;
1741       d += 3;
1742       s += BPP;
1743     }
1744     s += src_wrap;
1745     d += dst_wrap;
1746   }
1747 }
1748
1749 #endif /* !FMT_RGB24 */
1750
1751 #ifdef FMT_RGB24
1752
1753 static void
1754 yuv444p_to_rgb24 (AVPicture * dst, const AVPicture * src, int width, int height)
1755 {
1756   const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
1757   uint8_t *d, *d1;
1758   int w, y, cb, cr, r_add, g_add, b_add;
1759   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1760   unsigned int r, g, b;
1761
1762   d = dst->data[0];
1763   y1_ptr = src->data[0];
1764   cb_ptr = src->data[1];
1765   cr_ptr = src->data[2];
1766   for (; height > 0; height--) {
1767     d1 = d;
1768     for (w = width; w > 0; w--) {
1769       YUV_TO_RGB1_CCIR (cb_ptr[0], cr_ptr[0]);
1770
1771       YUV_TO_RGB2_CCIR (r, g, b, y1_ptr[0]);
1772       RGB_OUT (d1, r, g, b);
1773       d1 += BPP;
1774
1775       y1_ptr++;
1776       cb_ptr++;
1777       cr_ptr++;
1778     }
1779     d += dst->linesize[0];
1780     y1_ptr += src->linesize[0] - width;
1781     cb_ptr += src->linesize[1] - width;
1782     cr_ptr += src->linesize[2] - width;
1783   }
1784 }
1785
1786 static void
1787 yuvj444p_to_rgb24 (AVPicture * dst, const AVPicture * src,
1788     int width, int height)
1789 {
1790   const uint8_t *y1_ptr, *cb_ptr, *cr_ptr;
1791   uint8_t *d, *d1;
1792   int w, y, cb, cr, r_add, g_add, b_add;
1793   uint8_t *cm = cropTbl + MAX_NEG_CROP;
1794   unsigned int r, g, b;
1795
1796   d = dst->data[0];
1797   y1_ptr = src->data[0];
1798   cb_ptr = src->data[1];
1799   cr_ptr = src->data[2];
1800   for (; height > 0; height--) {
1801     d1 = d;
1802     for (w = width; w > 0; w--) {
1803       YUV_TO_RGB1 (cb_ptr[0], cr_ptr[0]);
1804
1805       YUV_TO_RGB2 (r, g, b, y1_ptr[0]);
1806       RGB_OUT (d1, r, g, b);
1807       d1 += BPP;
1808
1809       y1_ptr++;
1810       cb_ptr++;
1811       cr_ptr++;
1812     }
1813     d += dst->linesize[0];
1814     y1_ptr += src->linesize[0] - width;
1815     cb_ptr += src->linesize[1] - width;
1816     cr_ptr += src->linesize[2] - width;
1817   }
1818 }
1819
1820 static void
1821 rgb24_to_yuv444p (AVPicture * dst, const AVPicture * src, int width, int height)
1822 {
1823   int src_wrap, x, y;
1824   int r, g, b;
1825   uint8_t *lum, *cb, *cr;
1826   const uint8_t *p;
1827
1828   lum = dst->data[0];
1829   cb = dst->data[1];
1830   cr = dst->data[2];
1831
1832   src_wrap = src->linesize[0] - width * BPP;
1833   p = src->data[0];
1834   for (y = 0; y < height; y++) {
1835     for (x = 0; x < width; x++) {
1836       RGB_IN (r, g, b, p);
1837       lum[0] = RGB_TO_Y_CCIR (r, g, b);
1838       cb[0] = RGB_TO_U_CCIR (r, g, b, 0);
1839       cr[0] = RGB_TO_V_CCIR (r, g, b, 0);
1840       p += BPP;
1841       cb++;
1842       cr++;
1843       lum++;
1844     }
1845     p += src_wrap;
1846     lum += dst->linesize[0] - width;
1847     cb += dst->linesize[1] - width;
1848     cr += dst->linesize[2] - width;
1849   }
1850 }
1851
1852 static void
1853 rgb24_to_yuvj420p (AVPicture * dst, const AVPicture * src,
1854     int width, int height)
1855 {
1856   int wrap, wrap3, width2;
1857   int r, g, b, r1, g1, b1, w;
1858   uint8_t *lum, *cb, *cr;
1859   const uint8_t *p;
1860
1861   lum = dst->data[0];
1862   cb = dst->data[1];
1863   cr = dst->data[2];
1864
1865   width2 = (width + 1) >> 1;
1866   wrap = dst->linesize[0];
1867   wrap3 = src->linesize[0];
1868   p = src->data[0];
1869   for (; height >= 2; height -= 2) {
1870     for (w = width; w >= 2; w -= 2) {
1871       RGB_IN (r, g, b, p);
1872       r1 = r;
1873       g1 = g;
1874       b1 = b;
1875       lum[0] = RGB_TO_Y (r, g, b);
1876
1877       RGB_IN (r, g, b, p + BPP);
1878       r1 += r;
1879       g1 += g;
1880       b1 += b;
1881       lum[1] = RGB_TO_Y (r, g, b);
1882       p += wrap3;
1883       lum += wrap;
1884
1885       RGB_IN (r, g, b, p);
1886       r1 += r;
1887       g1 += g;
1888       b1 += b;
1889       lum[0] = RGB_TO_Y (r, g, b);
1890
1891       RGB_IN (r, g, b, p + BPP);
1892       r1 += r;
1893       g1 += g;
1894       b1 += b;
1895       lum[1] = RGB_TO_Y (r, g, b);
1896
1897       cb[0] = RGB_TO_U (r1, g1, b1, 2);
1898       cr[0] = RGB_TO_V (r1, g1, b1, 2);
1899
1900       cb++;
1901       cr++;
1902       p += -wrap3 + 2 * BPP;
1903       lum += -wrap + 2;
1904     }
1905     if (w) {
1906       RGB_IN (r, g, b, p);
1907       r1 = r;
1908       g1 = g;
1909       b1 = b;
1910       lum[0] = RGB_TO_Y (r, g, b);
1911       p += wrap3;
1912       lum += wrap;
1913       RGB_IN (r, g, b, p);
1914       r1 += r;
1915       g1 += g;
1916       b1 += b;
1917       lum[0] = RGB_TO_Y (r, g, b);
1918       cb[0] = RGB_TO_U (r1, g1, b1, 1);
1919       cr[0] = RGB_TO_V (r1, g1, b1, 1);
1920       cb++;
1921       cr++;
1922       p += -wrap3 + BPP;
1923       lum += -wrap + 1;
1924     }
1925     p += wrap3 + (wrap3 - width * BPP);
1926     lum += wrap + (wrap - width);
1927     cb += dst->linesize[1] - width2;
1928     cr += dst->linesize[2] - width2;
1929   }
1930   /* handle odd height */
1931   if (height) {
1932     for (w = width; w >= 2; w -= 2) {
1933       RGB_IN (r, g, b, p);
1934       r1 = r;
1935       g1 = g;
1936       b1 = b;
1937       lum[0] = RGB_TO_Y (r, g, b);
1938
1939       RGB_IN (r, g, b, p + BPP);
1940       r1 += r;
1941       g1 += g;
1942       b1 += b;
1943       lum[1] = RGB_TO_Y (r, g, b);
1944       cb[0] = RGB_TO_U (r1, g1, b1, 1);
1945       cr[0] = RGB_TO_V (r1, g1, b1, 1);
1946       cb++;
1947       cr++;
1948       p += 2 * BPP;
1949       lum += 2;
1950     }
1951     if (w) {
1952       RGB_IN (r, g, b, p);
1953       lum[0] = RGB_TO_Y (r, g, b);
1954       cb[0] = RGB_TO_U (r, g, b, 0);
1955       cr[0] = RGB_TO_V (r, g, b, 0);
1956     }
1957   }
1958 }
1959
1960 static void
1961 rgb24_to_yuvj444p (AVPicture * dst, const AVPicture * src,
1962     int width, int height)
1963 {
1964   int src_wrap, x, y;
1965   int r, g, b;
1966   uint8_t *lum, *cb, *cr;
1967   const uint8_t *p;
1968
1969   lum = dst->data[0];
1970   cb = dst->data[1];
1971   cr = dst->data[2];
1972
1973   src_wrap = src->linesize[0] - width * BPP;
1974   p = src->data[0];
1975   for (y = 0; y < height; y++) {
1976     for (x = 0; x < width; x++) {
1977       RGB_IN (r, g, b, p);
1978       lum[0] = RGB_TO_Y (r, g, b);
1979       cb[0] = RGB_TO_U (r, g, b, 0);
1980       cr[0] = RGB_TO_V (r, g, b, 0);
1981       p += BPP;
1982       cb++;
1983       cr++;
1984       lum++;
1985     }
1986     p += src_wrap;
1987     lum += dst->linesize[0] - width;
1988     cb += dst->linesize[1] - width;
1989     cr += dst->linesize[2] - width;
1990   }
1991 }
1992
1993 static void
1994 ayuv4444_to_rgb24 (AVPicture * dst, const AVPicture * src,
1995     int width, int height)
1996 {
1997   uint8_t *s, *d, *d1, *s1;
1998   int w, y, cb, cr, r_add, g_add, b_add;
1999   uint8_t *cm = cropTbl + MAX_NEG_CROP;
2000   unsigned int r, g, b;
2001
2002   d = dst->data[0];
2003   s = src->data[0];
2004   for (; height > 0; height--) {
2005     d1 = d;
2006     s1 = s;
2007     for (w = width; w > 0; w--) {
2008       YUV_TO_RGB1_CCIR (s1[2], s1[3]);
2009
2010       YUV_TO_RGB2_CCIR (r, g, b, s1[1]);
2011       RGB_OUT (d1, r, g, b);
2012       d1 += BPP;
2013       s1 += 4;
2014     }
2015     d += dst->linesize[0];
2016     s += src->linesize[0];
2017   }
2018 }
2019
2020 static void
2021 rgb24_to_ayuv4444 (AVPicture * dst, const AVPicture * src,
2022     int width, int height)
2023 {
2024   int src_wrap, dst_wrap, x, y;
2025   int r, g, b;
2026   uint8_t *d;
2027   const uint8_t *p;
2028
2029   src_wrap = src->linesize[0] - width * BPP;
2030   dst_wrap = dst->linesize[0] - width * 4;
2031   d = dst->data[0];
2032   p = src->data[0];
2033   for (y = 0; y < height; y++) {
2034     for (x = 0; x < width; x++) {
2035       RGB_IN (r, g, b, p);
2036       d[0] = 0xff;
2037       d[1] = RGB_TO_Y_CCIR (r, g, b);
2038       d[2] = RGB_TO_U_CCIR (r, g, b, 0);
2039       d[3] = RGB_TO_V_CCIR (r, g, b, 0);
2040       p += BPP;
2041       d += 4;
2042     }
2043     p += src_wrap;
2044     d += dst_wrap;
2045   }
2046 }
2047
2048 static void
2049 v308_to_rgb24 (AVPicture * dst, const AVPicture * src, int width, int height)
2050 {
2051   uint8_t *s, *d, *d1, *s1;
2052   int w, y, cb, cr, r_add, g_add, b_add;
2053   uint8_t *cm = cropTbl + MAX_NEG_CROP;
2054   unsigned int r, g, b;
2055
2056   d = dst->data[0];
2057   s = src->data[0];
2058   for (; height > 0; height--) {
2059     d1 = d;
2060     s1 = s;
2061     for (w = width; w > 0; w--) {
2062       YUV_TO_RGB1_CCIR (s1[1], s1[2]);
2063
2064       YUV_TO_RGB2_CCIR (r, g, b, s1[0]);
2065       RGB_OUT (d1, r, g, b);
2066       d1 += BPP;
2067       s1 += 3;
2068     }
2069     d += dst->linesize[0];
2070     s += src->linesize[0];
2071   }
2072 }
2073
2074 static void
2075 rgb24_to_v308 (AVPicture * dst, const AVPicture * src, int width, int height)
2076 {
2077   int src_wrap, dst_wrap, x, y;
2078   int r, g, b;
2079   uint8_t *d;
2080   const uint8_t *p;
2081
2082   src_wrap = src->linesize[0] - width * BPP;
2083   dst_wrap = dst->linesize[0] - width * 3;
2084   d = dst->data[0];
2085   p = src->data[0];
2086   for (y = 0; y < height; y++) {
2087     for (x = 0; x < width; x++) {
2088       RGB_IN (r, g, b, p);
2089       d[0] = RGB_TO_Y_CCIR (r, g, b);
2090       d[1] = RGB_TO_U_CCIR (r, g, b, 0);
2091       d[2] = RGB_TO_V_CCIR (r, g, b, 0);
2092       p += BPP;
2093       d += 3;
2094     }
2095     p += src_wrap;
2096     d += dst_wrap;
2097   }
2098 }
2099 #endif /* FMT_RGB24 */
2100
2101 #if defined(FMT_RGB24) || defined(FMT_RGBA32)
2102
2103 static void glue (RGB_NAME, _to_pal8) (AVPicture * dst, const AVPicture * src,
2104     int width, int height)
2105 {
2106   const unsigned char *p;
2107   unsigned char *q;
2108   int dst_wrap, src_wrap;
2109   int x, y, has_alpha;
2110   unsigned int r, g, b;
2111
2112   p = src->data[0];
2113   src_wrap = src->linesize[0] - BPP * width;
2114
2115   q = dst->data[0];
2116   dst_wrap = dst->linesize[0] - width;
2117   has_alpha = 0;
2118
2119   for (y = 0; y < height; y++) {
2120     for (x = 0; x < width; x++) {
2121 #ifdef RGBA_IN
2122       {
2123         unsigned int a;
2124         RGBA_IN (r, g, b, a, p);
2125         /* crude approximation for alpha ! */
2126         if (a < 0x80) {
2127           has_alpha = 1;
2128           q[0] = TRANSP_INDEX;
2129         } else {
2130           q[0] = gif_clut_index (r, g, b);
2131         }
2132       }
2133 #else
2134       RGB_IN (r, g, b, p);
2135       q[0] = gif_clut_index (r, g, b);
2136 #endif
2137       q++;
2138       p += BPP;
2139     }
2140     p += src_wrap;
2141     q += dst_wrap;
2142   }
2143
2144   build_rgb_palette (dst->data[1], has_alpha);
2145 }
2146
2147 #endif /* defined(FMT_RGB24) || defined(FMT_RGBA32) */
2148
2149 #ifdef RGBA_IN
2150
2151 static int glue (get_alpha_info_, RGB_NAME) (const AVPicture * src,
2152     int width, int height)
2153 {
2154   const unsigned char *p;
2155   int src_wrap, ret, x, y;
2156   unsigned int G_GNUC_UNUSED r, G_GNUC_UNUSED g, G_GNUC_UNUSED b, a;
2157
2158   p = src->data[0];
2159   src_wrap = src->linesize[0] - BPP * width;
2160   ret = 0;
2161   for (y = 0; y < height; y++) {
2162     for (x = 0; x < width; x++) {
2163       RGBA_IN (r, g, b, a, p);
2164       if (a == 0x00) {
2165         ret |= FF_ALPHA_TRANSP;
2166       } else if (a != 0xff) {
2167         ret |= FF_ALPHA_SEMI_TRANSP;
2168       }
2169       p += BPP;
2170     }
2171     p += src_wrap;
2172   }
2173   return ret;
2174 }
2175
2176 #endif /* RGBA_IN */
2177
2178 #undef RGB_IN
2179 #undef RGBA_IN
2180 #undef RGB_OUT
2181 #undef RGBA_OUT
2182 #undef BPP
2183 #undef RGB_NAME
2184 #undef FMT_RGB24
2185 #undef FMT_RGBA32
2186 #undef YUVA_TO_A
2187 #undef RGBA_OUT_
2188 #undef RGBA_IN_