git.sesse.net Git - ffmpeg/blob - libswscale/rgb2rgb_template.c

   1 /*
   2  * software RGB to RGB converter
   3  * pluralize by software PAL8 to RGB converter
   4  *              software YUV to YUV converter
   5  *              software YUV to RGB converter
   6  * Written by Nick Kurshev.
   7  * palette & YUV & runtime CPU stuff by Michael (michaelni@gmx.at)
   8  * lot of big-endian byte order fixes by Alex Beregszaszi
   9  *
  10  * This file is part of FFmpeg.
  11  *
  12  * FFmpeg is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * FFmpeg is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with FFmpeg; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  */
  26
  27 #include <stddef.h>
  28
  29 static inline void rgb24tobgr32_c(const uint8_t *src, uint8_t *dst, int src_size)
  30 {
  31     uint8_t *dest = dst;
  32     const uint8_t *s = src;
  33     const uint8_t *end;
  34     end = s + src_size;
  35
  36     while (s < end) {
  37 #if HAVE_BIGENDIAN
  38         /* RGB24 (= R,G,B) -> RGB32 (= A,B,G,R) */
  39         *dest++ = 255;
  40         *dest++ = s[2];
  41         *dest++ = s[1];
  42         *dest++ = s[0];
  43         s+=3;
  44 #else
  45         *dest++ = *s++;
  46         *dest++ = *s++;
  47         *dest++ = *s++;
  48         *dest++ = 255;
  49 #endif
  50     }
  51 }
  52
  53 static inline void rgb32tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
  54 {
  55     uint8_t *dest = dst;
  56     const uint8_t *s = src;
  57     const uint8_t *end;
  58
  59     end = s + src_size;
  60
  61     while (s < end) {
  62 #if HAVE_BIGENDIAN
  63         /* RGB32 (= A,B,G,R) -> RGB24 (= R,G,B) */
  64         s++;
  65         dest[2] = *s++;
  66         dest[1] = *s++;
  67         dest[0] = *s++;
  68         dest += 3;
  69 #else
  70         *dest++ = *s++;
  71         *dest++ = *s++;
  72         *dest++ = *s++;
  73         s++;
  74 #endif
  75     }
  76 }
  77
  78 /*
  79  original by Strepto/Astral
  80  ported to gcc & bugfixed: A'rpi
  81  MMX2, 3DNOW optimization by Nick Kurshev
  82  32-bit C version, and and&add trick by Michael Niedermayer
  83 */
  84 static inline void rgb15to16_c(const uint8_t *src, uint8_t *dst, int src_size)
  85 {
  86     register const uint8_t* s=src;
  87     register uint8_t* d=dst;
  88     register const uint8_t *end;
  89     const uint8_t *mm_end;
  90     end = s + src_size;
  91     mm_end = end - 3;
  92     while (s < mm_end) {
  93         register unsigned x= *((const uint32_t *)s);
  94         *((uint32_t *)d) = (x&0x7FFF7FFF) + (x&0x7FE07FE0);
  95         d+=4;
  96         s+=4;
  97     }
  98     if (s < end) {
  99         register unsigned short x= *((const uint16_t *)s);
 100         *((uint16_t *)d) = (x&0x7FFF) + (x&0x7FE0);
 101     }
 102 }
 103
 104 static inline void rgb16to15_c(const uint8_t *src, uint8_t *dst, int src_size)
 105 {
 106     register const uint8_t* s=src;
 107     register uint8_t* d=dst;
 108     register const uint8_t *end;
 109     const uint8_t *mm_end;
 110     end = s + src_size;
 111
 112     mm_end = end - 3;
 113     while (s < mm_end) {
 114         register uint32_t x= *((const uint32_t*)s);
 115         *((uint32_t *)d) = ((x>>1)&0x7FE07FE0) | (x&0x001F001F);
 116         s+=4;
 117         d+=4;
 118     }
 119     if (s < end) {
 120         register uint16_t x= *((const uint16_t*)s);
 121         *((uint16_t *)d) = ((x>>1)&0x7FE0) | (x&0x001F);
 122     }
 123 }
 124
 125 static inline void rgb32to16_c(const uint8_t *src, uint8_t *dst, int src_size)
 126 {
 127     const uint8_t *s = src;
 128     const uint8_t *end;
 129     uint16_t *d = (uint16_t *)dst;
 130     end = s + src_size;
 131
 132     while (s < end) {
 133         register int rgb = *(const uint32_t*)s; s += 4;
 134         *d++ = ((rgb&0xFF)>>3) + ((rgb&0xFC00)>>5) + ((rgb&0xF80000)>>8);
 135     }
 136 }
 137
 138 static inline void rgb32tobgr16_c(const uint8_t *src, uint8_t *dst, int src_size)
 139 {
 140     const uint8_t *s = src;
 141     const uint8_t *end;
 142     uint16_t *d = (uint16_t *)dst;
 143     end = s + src_size;
 144     while (s < end) {
 145         register int rgb = *(const uint32_t*)s; s += 4;
 146         *d++ = ((rgb&0xF8)<<8) + ((rgb&0xFC00)>>5) + ((rgb&0xF80000)>>19);
 147     }
 148 }
 149
 150 static inline void rgb32to15_c(const uint8_t *src, uint8_t *dst, int src_size)
 151 {
 152     const uint8_t *s = src;
 153     const uint8_t *end;
 154     uint16_t *d = (uint16_t *)dst;
 155     end = s + src_size;
 156     while (s < end) {
 157         register int rgb = *(const uint32_t*)s; s += 4;
 158         *d++ = ((rgb&0xFF)>>3) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>9);
 159     }
 160 }
 161
 162 static inline void rgb32tobgr15_c(const uint8_t *src, uint8_t *dst, int src_size)
 163 {
 164     const uint8_t *s = src;
 165     const uint8_t *end;
 166     uint16_t *d = (uint16_t *)dst;
 167     end = s + src_size;
 168     while (s < end) {
 169         register int rgb = *(const uint32_t*)s; s += 4;
 170         *d++ = ((rgb&0xF8)<<7) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>19);
 171     }
 172 }
 173
 174 static inline void rgb24tobgr16_c(const uint8_t *src, uint8_t *dst, int src_size)
 175 {
 176     const uint8_t *s = src;
 177     const uint8_t *end;
 178     uint16_t *d = (uint16_t *)dst;
 179     end = s + src_size;
 180     while (s < end) {
 181         const int b = *s++;
 182         const int g = *s++;
 183         const int r = *s++;
 184         *d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
 185     }
 186 }
 187
 188 static inline void rgb24to16_c(const uint8_t *src, uint8_t *dst, int src_size)
 189 {
 190     const uint8_t *s = src;
 191     const uint8_t *end;
 192     uint16_t *d = (uint16_t *)dst;
 193     end = s + src_size;
 194     while (s < end) {
 195         const int r = *s++;
 196         const int g = *s++;
 197         const int b = *s++;
 198         *d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
 199     }
 200 }
 201
 202 static inline void rgb24tobgr15_c(const uint8_t *src, uint8_t *dst, int src_size)
 203 {
 204     const uint8_t *s = src;
 205     const uint8_t *end;
 206     uint16_t *d = (uint16_t *)dst;
 207     end = s + src_size;
 208     while (s < end) {
 209         const int b = *s++;
 210         const int g = *s++;
 211         const int r = *s++;
 212         *d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
 213     }
 214 }
 215
 216 static inline void rgb24to15_c(const uint8_t *src, uint8_t *dst, int src_size)
 217 {
 218     const uint8_t *s = src;
 219     const uint8_t *end;
 220     uint16_t *d = (uint16_t *)dst;
 221     end = s + src_size;
 222     while (s < end) {
 223         const int r = *s++;
 224         const int g = *s++;
 225         const int b = *s++;
 226         *d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
 227     }
 228 }
 229
 230 static inline void rgb15tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
 231 {
 232     const uint16_t *end;
 233     uint8_t *d = dst;
 234     const uint16_t *s = (const uint16_t*)src;
 235     end = s + src_size/2;
 236     while (s < end) {
 237         register uint16_t bgr;
 238         bgr = *s++;
 239         *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
 240         *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
 241         *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
 242     }
 243 }
 244
 245 static inline void rgb16tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
 246 {
 247     const uint16_t *end;
 248     uint8_t *d = (uint8_t *)dst;
 249     const uint16_t *s = (const uint16_t *)src;
 250     end = s + src_size/2;
 251     while (s < end) {
 252         register uint16_t bgr;
 253         bgr = *s++;
 254         *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
 255         *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
 256         *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
 257     }
 258 }
 259
 260 static inline void rgb15to32_c(const uint8_t *src, uint8_t *dst, int src_size)
 261 {
 262     const uint16_t *end;
 263     uint8_t *d = dst;
 264     const uint16_t *s = (const uint16_t *)src;
 265     end = s + src_size/2;
 266     while (s < end) {
 267         register uint16_t bgr;
 268         bgr = *s++;
 269 #if HAVE_BIGENDIAN
 270         *d++ = 255;
 271         *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
 272         *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
 273         *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
 274 #else
 275         *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
 276         *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
 277         *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
 278         *d++ = 255;
 279 #endif
 280     }
 281 }
 282
 283 static inline void rgb16to32_c(const uint8_t *src, uint8_t *dst, int src_size)
 284 {
 285     const uint16_t *end;
 286     uint8_t *d = dst;
 287     const uint16_t *s = (const uint16_t*)src;
 288     end = s + src_size/2;
 289     while (s < end) {
 290         register uint16_t bgr;
 291         bgr = *s++;
 292 #if HAVE_BIGENDIAN
 293         *d++ = 255;
 294         *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
 295         *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
 296         *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
 297 #else
 298         *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
 299         *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
 300         *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
 301         *d++ = 255;
 302 #endif
 303     }
 304 }
 305
 306 static inline void shuffle_bytes_2103_c(const uint8_t *src, uint8_t *dst, int src_size)
 307 {
 308     int idx = 15 - src_size;
 309     const uint8_t *s = src-idx;
 310     uint8_t *d = dst-idx;
 311     for (; idx<15; idx+=4) {
 312         register int v = *(const uint32_t *)&s[idx], g = v & 0xff00ff00;
 313         v &= 0xff00ff;
 314         *(uint32_t *)&d[idx] = (v>>16) + g + (v<<16);
 315     }
 316 }
 317
 318 static inline void rgb24tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
 319 {
 320     unsigned i;
 321     for (i=0; i<src_size; i+=3) {
 322         register uint8_t x;
 323         x          = src[i + 2];
 324         dst[i + 1] = src[i + 1];
 325         dst[i + 2] = src[i + 0];
 326         dst[i + 0] = x;
 327     }
 328 }
 329
 330 static inline void yuvPlanartoyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
 331                                      const uint8_t *vsrc, uint8_t *dst,
 332                                      int width, int height,
 333                                      int lumStride, int chromStride,
 334                                      int dstStride, int vertLumPerChroma)
 335 {
 336     int y;
 337     const int chromWidth = width >> 1;
 338     for (y=0; y<height; y++) {
 339 #if HAVE_FAST_64BIT
 340         int i;
 341         uint64_t *ldst = (uint64_t *) dst;
 342         const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
 343         for (i = 0; i < chromWidth; i += 2) {
 344             uint64_t k, l;
 345             k = yc[0] + (uc[0] << 8) +
 346                 (yc[1] << 16) + (vc[0] << 24);
 347             l = yc[2] + (uc[1] << 8) +
 348                 (yc[3] << 16) + (vc[1] << 24);
 349             *ldst++ = k + (l << 32);
 350             yc += 4;
 351             uc += 2;
 352             vc += 2;
 353         }
 354
 355 #else
 356         int i, *idst = (int32_t *) dst;
 357         const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
 358         for (i = 0; i < chromWidth; i++) {
 359 #if HAVE_BIGENDIAN
 360             *idst++ = (yc[0] << 24)+ (uc[0] << 16) +
 361                 (yc[1] << 8) + (vc[0] << 0);
 362 #else
 363             *idst++ = yc[0] + (uc[0] << 8) +
 364                 (yc[1] << 16) + (vc[0] << 24);
 365 #endif
 366             yc += 2;
 367             uc++;
 368             vc++;
 369         }
 370 #endif
 371         if ((y&(vertLumPerChroma-1)) == vertLumPerChroma-1) {
 372             usrc += chromStride;
 373             vsrc += chromStride;
 374         }
 375         ysrc += lumStride;
 376         dst  += dstStride;
 377     }
 378 }
 379
 380 /**
 381  * Height should be a multiple of 2 and width should be a multiple of 16.
 382  * (If this is a problem for anyone then tell me, and I will fix it.)
 383  */
 384 static inline void yv12toyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
 385                                 const uint8_t *vsrc, uint8_t *dst,
 386                                 int width, int height,
 387                                 int lumStride, int chromStride,
 388                                 int dstStride)
 389 {
 390     //FIXME interpolate chroma
 391     yuvPlanartoyuy2_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
 392                       chromStride, dstStride, 2);
 393 }
 394
 395 static inline void yuvPlanartouyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
 396                                      const uint8_t *vsrc, uint8_t *dst,
 397                                      int width, int height,
 398                                      int lumStride, int chromStride,
 399                                      int dstStride, int vertLumPerChroma)
 400 {
 401     int y;
 402     const int chromWidth = width >> 1;
 403     for (y=0; y<height; y++) {
 404 #if HAVE_FAST_64BIT
 405         int i;
 406         uint64_t *ldst = (uint64_t *) dst;
 407         const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
 408         for (i = 0; i < chromWidth; i += 2) {
 409             uint64_t k, l;
 410             k = uc[0] + (yc[0] << 8) +
 411                 (vc[0] << 16) + (yc[1] << 24);
 412             l = uc[1] + (yc[2] << 8) +
 413                 (vc[1] << 16) + (yc[3] << 24);
 414             *ldst++ = k + (l << 32);
 415             yc += 4;
 416             uc += 2;
 417             vc += 2;
 418         }
 419
 420 #else
 421         int i, *idst = (int32_t *) dst;
 422         const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
 423         for (i = 0; i < chromWidth; i++) {
 424 #if HAVE_BIGENDIAN
 425             *idst++ = (uc[0] << 24)+ (yc[0] << 16) +
 426                 (vc[0] << 8) + (yc[1] << 0);
 427 #else
 428             *idst++ = uc[0] + (yc[0] << 8) +
 429                (vc[0] << 16) + (yc[1] << 24);
 430 #endif
 431             yc += 2;
 432             uc++;
 433             vc++;
 434         }
 435 #endif
 436         if ((y&(vertLumPerChroma-1)) == vertLumPerChroma-1) {
 437             usrc += chromStride;
 438             vsrc += chromStride;
 439         }
 440         ysrc += lumStride;
 441         dst += dstStride;
 442     }
 443 }
 444
 445 /**
 446  * Height should be a multiple of 2 and width should be a multiple of 16
 447  * (If this is a problem for anyone then tell me, and I will fix it.)
 448  */
 449 static inline void yv12touyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
 450                                 const uint8_t *vsrc, uint8_t *dst,
 451                                 int width, int height,
 452                                 int lumStride, int chromStride,
 453                                 int dstStride)
 454 {
 455     //FIXME interpolate chroma
 456     yuvPlanartouyvy_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
 457                       chromStride, dstStride, 2);
 458 }
 459
 460 /**
 461  * Width should be a multiple of 16.
 462  */
 463 static inline void yuv422ptouyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
 464                                    const uint8_t *vsrc, uint8_t *dst,
 465                                    int width, int height,
 466                                    int lumStride, int chromStride,
 467                                    int dstStride)
 468 {
 469     yuvPlanartouyvy_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
 470                       chromStride, dstStride, 1);
 471 }
 472
 473 /**
 474  * Width should be a multiple of 16.
 475  */
 476 static inline void yuv422ptoyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
 477                                    const uint8_t *vsrc, uint8_t *dst,
 478                                    int width, int height,
 479                                    int lumStride, int chromStride,
 480                                    int dstStride)
 481 {
 482     yuvPlanartoyuy2_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
 483                       chromStride, dstStride, 1);
 484 }
 485
 486 /**
 487  * Height should be a multiple of 2 and width should be a multiple of 16.
 488  * (If this is a problem for anyone then tell me, and I will fix it.)
 489  */
 490 static inline void yuy2toyv12_c(const uint8_t *src, uint8_t *ydst,
 491                                 uint8_t *udst, uint8_t *vdst,
 492                                 int width, int height,
 493                                 int lumStride, int chromStride,
 494                                 int srcStride)
 495 {
 496     int y;
 497     const int chromWidth = width >> 1;
 498     for (y=0; y<height; y+=2) {
 499         int i;
 500         for (i=0; i<chromWidth; i++) {
 501             ydst[2*i+0]     = src[4*i+0];
 502             udst[i]     = src[4*i+1];
 503             ydst[2*i+1]     = src[4*i+2];
 504             vdst[i]     = src[4*i+3];
 505         }
 506         ydst += lumStride;
 507         src  += srcStride;
 508
 509         for (i=0; i<chromWidth; i++) {
 510             ydst[2*i+0]     = src[4*i+0];
 511             ydst[2*i+1]     = src[4*i+2];
 512         }
 513         udst += chromStride;
 514         vdst += chromStride;
 515         ydst += lumStride;
 516         src  += srcStride;
 517     }
 518 }
 519
 520 static inline void planar2x_c(const uint8_t *src, uint8_t *dst, int srcWidth,
 521                               int srcHeight, int srcStride, int dstStride)
 522 {
 523     int x,y;
 524
 525     dst[0]= src[0];
 526
 527     // first line
 528     for (x=0; x<srcWidth-1; x++) {
 529         dst[2*x+1]= (3*src[x] +   src[x+1])>>2;
 530         dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;
 531     }
 532     dst[2*srcWidth-1]= src[srcWidth-1];
 533
 534     dst+= dstStride;
 535
 536     for (y=1; y<srcHeight; y++) {
 537         const int mmxSize = 1;
 538
 539         dst[0        ]= (3*src[0] +   src[srcStride])>>2;
 540         dst[dstStride]= (  src[0] + 3*src[srcStride])>>2;
 541
 542         for (x=mmxSize-1; x<srcWidth-1; x++) {
 543             dst[2*x          +1]= (3*src[x+0] +   src[x+srcStride+1])>>2;
 544             dst[2*x+dstStride+2]= (  src[x+0] + 3*src[x+srcStride+1])>>2;
 545             dst[2*x+dstStride+1]= (  src[x+1] + 3*src[x+srcStride  ])>>2;
 546             dst[2*x          +2]= (3*src[x+1] +   src[x+srcStride  ])>>2;
 547         }
 548         dst[srcWidth*2 -1            ]= (3*src[srcWidth-1] +   src[srcWidth-1 + srcStride])>>2;
 549         dst[srcWidth*2 -1 + dstStride]= (  src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
 550
 551         dst+=dstStride*2;
 552         src+=srcStride;
 553     }
 554
 555     // last line
 556     dst[0]= src[0];
 557
 558     for (x=0; x<srcWidth-1; x++) {
 559         dst[2*x+1]= (3*src[x] +   src[x+1])>>2;
 560         dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;
 561     }
 562     dst[2*srcWidth-1]= src[srcWidth-1];
 563 }
 564
 565 /**
 566  * Height should be a multiple of 2 and width should be a multiple of 16.
 567  * (If this is a problem for anyone then tell me, and I will fix it.)
 568  * Chrominance data is only taken from every second line, others are ignored.
 569  * FIXME: Write HQ version.
 570  */
 571 static inline void uyvytoyv12_c(const uint8_t *src, uint8_t *ydst,
 572                                 uint8_t *udst, uint8_t *vdst,
 573                                 int width, int height,
 574                                 int lumStride, int chromStride,
 575                                 int srcStride)
 576 {
 577     int y;
 578     const int chromWidth = width >> 1;
 579     for (y=0; y<height; y+=2) {
 580         int i;
 581         for (i=0; i<chromWidth; i++) {
 582             udst[i]     = src[4*i+0];
 583             ydst[2*i+0] = src[4*i+1];
 584             vdst[i]     = src[4*i+2];
 585             ydst[2*i+1] = src[4*i+3];
 586         }
 587         ydst += lumStride;
 588         src  += srcStride;
 589
 590         for (i=0; i<chromWidth; i++) {
 591             ydst[2*i+0] = src[4*i+1];
 592             ydst[2*i+1] = src[4*i+3];
 593         }
 594         udst += chromStride;
 595         vdst += chromStride;
 596         ydst += lumStride;
 597         src  += srcStride;
 598     }
 599 }
 600
 601 /**
 602  * Height should be a multiple of 2 and width should be a multiple of 2.
 603  * (If this is a problem for anyone then tell me, and I will fix it.)
 604  * Chrominance data is only taken from every second line,
 605  * others are ignored in the C version.
 606  * FIXME: Write HQ version.
 607  */
 608 void rgb24toyv12_c(const uint8_t *src, uint8_t *ydst, uint8_t *udst,
 609                    uint8_t *vdst, int width, int height, int lumStride,
 610                    int chromStride, int srcStride)
 611 {
 612     int y;
 613     const int chromWidth = width >> 1;
 614     y=0;
 615     for (; y<height; y+=2) {
 616         int i;
 617         for (i=0; i<chromWidth; i++) {
 618             unsigned int b = src[6*i+0];
 619             unsigned int g = src[6*i+1];
 620             unsigned int r = src[6*i+2];
 621
 622             unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
 623             unsigned int V  =  ((RV*r + GV*g + BV*b)>>RGB2YUV_SHIFT) + 128;
 624             unsigned int U  =  ((RU*r + GU*g + BU*b)>>RGB2YUV_SHIFT) + 128;
 625
 626             udst[i]     = U;
 627             vdst[i]     = V;
 628             ydst[2*i]   = Y;
 629
 630             b = src[6*i+3];
 631             g = src[6*i+4];
 632             r = src[6*i+5];
 633
 634             Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
 635             ydst[2*i+1]     = Y;
 636         }
 637         ydst += lumStride;
 638         src  += srcStride;
 639
 640         if(y+1 == height)
 641             break;
 642
 643         for (i=0; i<chromWidth; i++) {
 644             unsigned int b = src[6*i+0];
 645             unsigned int g = src[6*i+1];
 646             unsigned int r = src[6*i+2];
 647
 648             unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
 649
 650             ydst[2*i]     = Y;
 651
 652             b = src[6*i+3];
 653             g = src[6*i+4];
 654             r = src[6*i+5];
 655
 656             Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
 657             ydst[2*i+1]     = Y;
 658         }
 659         udst += chromStride;
 660         vdst += chromStride;
 661         ydst += lumStride;
 662         src  += srcStride;
 663     }
 664 }
 665
 666 static void interleaveBytes_c(const uint8_t *src1, const uint8_t *src2,
 667                               uint8_t *dest, int width,
 668                               int height, int src1Stride,
 669                               int src2Stride, int dstStride)
 670 {
 671     int h;
 672
 673     for (h=0; h < height; h++) {
 674         int w;
 675         for (w=0; w < width; w++) {
 676             dest[2*w+0] = src1[w];
 677             dest[2*w+1] = src2[w];
 678         }
 679         dest += dstStride;
 680         src1 += src1Stride;
 681         src2 += src2Stride;
 682     }
 683 }
 684
 685 static inline void vu9_to_vu12_c(const uint8_t *src1, const uint8_t *src2,
 686                                  uint8_t *dst1, uint8_t *dst2,
 687                                  int width, int height,
 688                                  int srcStride1, int srcStride2,
 689                                  int dstStride1, int dstStride2)
 690 {
 691     int y;
 692     int x,w,h;
 693     w=width/2; h=height/2;
 694     for (y=0;y<h;y++) {
 695         const uint8_t* s1=src1+srcStride1*(y>>1);
 696         uint8_t* d=dst1+dstStride1*y;
 697         x=0;
 698         for (;x<w;x++) d[2*x]=d[2*x+1]=s1[x];
 699     }
 700     for (y=0;y<h;y++) {
 701         const uint8_t* s2=src2+srcStride2*(y>>1);
 702         uint8_t* d=dst2+dstStride2*y;
 703         x=0;
 704         for (;x<w;x++) d[2*x]=d[2*x+1]=s2[x];
 705     }
 706 }
 707
 708 static inline void yvu9_to_yuy2_c(const uint8_t *src1, const uint8_t *src2,
 709                                   const uint8_t *src3, uint8_t *dst,
 710                                   int width, int height,
 711                                   int srcStride1, int srcStride2,
 712                                   int srcStride3, int dstStride)
 713 {
 714     int x;
 715     int y,w,h;
 716     w=width/2; h=height;
 717     for (y=0;y<h;y++) {
 718         const uint8_t* yp=src1+srcStride1*y;
 719         const uint8_t* up=src2+srcStride2*(y>>2);
 720         const uint8_t* vp=src3+srcStride3*(y>>2);
 721         uint8_t* d=dst+dstStride*y;
 722         x=0;
 723         for (; x<w; x++) {
 724             const int x2 = x<<2;
 725             d[8*x+0] = yp[x2];
 726             d[8*x+1] = up[x];
 727             d[8*x+2] = yp[x2+1];
 728             d[8*x+3] = vp[x];
 729             d[8*x+4] = yp[x2+2];
 730             d[8*x+5] = up[x];
 731             d[8*x+6] = yp[x2+3];
 732             d[8*x+7] = vp[x];
 733         }
 734     }
 735 }
 736
 737 static void extract_even_c(const uint8_t *src, uint8_t *dst, int count)
 738 {
 739     dst +=   count;
 740     src += 2*count;
 741     count= - count;
 742
 743     while(count<0) {
 744         dst[count]= src[2*count];
 745         count++;
 746     }
 747 }
 748
 749 static void extract_even2_c(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
 750                             int count)
 751 {
 752     dst0+=   count;
 753     dst1+=   count;
 754     src += 4*count;
 755     count= - count;
 756     while(count<0) {
 757         dst0[count]= src[4*count+0];
 758         dst1[count]= src[4*count+2];
 759         count++;
 760     }
 761 }
 762
 763 static void extract_even2avg_c(const uint8_t *src0, const uint8_t *src1,
 764                                uint8_t *dst0, uint8_t *dst1, int count)
 765 {
 766     dst0 +=   count;
 767     dst1 +=   count;
 768     src0 += 4*count;
 769     src1 += 4*count;
 770     count= - count;
 771     while(count<0) {
 772         dst0[count]= (src0[4*count+0]+src1[4*count+0])>>1;
 773         dst1[count]= (src0[4*count+2]+src1[4*count+2])>>1;
 774         count++;
 775     }
 776 }
 777
 778 static void extract_odd2_c(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
 779                            int count)
 780 {
 781     dst0+=   count;
 782     dst1+=   count;
 783     src += 4*count;
 784     count= - count;
 785     src++;
 786     while(count<0) {
 787         dst0[count]= src[4*count+0];
 788         dst1[count]= src[4*count+2];
 789         count++;
 790     }
 791 }
 792
 793 static void extract_odd2avg_c(const uint8_t *src0, const uint8_t *src1,
 794                               uint8_t *dst0, uint8_t *dst1, int count)
 795 {
 796     dst0 +=   count;
 797     dst1 +=   count;
 798     src0 += 4*count;
 799     src1 += 4*count;
 800     count= - count;
 801     src0++;
 802     src1++;
 803     while(count<0) {
 804         dst0[count]= (src0[4*count+0]+src1[4*count+0])>>1;
 805         dst1[count]= (src0[4*count+2]+src1[4*count+2])>>1;
 806         count++;
 807     }
 808 }
 809
 810 static void yuyvtoyuv420_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 811                            const uint8_t *src, int width, int height,
 812                            int lumStride, int chromStride, int srcStride)
 813 {
 814     int y;
 815     const int chromWidth= -((-width)>>1);
 816
 817     for (y=0; y<height; y++) {
 818         extract_even_c(src, ydst, width);
 819         if(y&1) {
 820             extract_odd2avg_c(src - srcStride, src, udst, vdst, chromWidth);
 821             udst+= chromStride;
 822             vdst+= chromStride;
 823         }
 824
 825         src += srcStride;
 826         ydst+= lumStride;
 827     }
 828 }
 829
 830 static void yuyvtoyuv422_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 831                            const uint8_t *src, int width, int height,
 832                            int lumStride, int chromStride, int srcStride)
 833 {
 834     int y;
 835     const int chromWidth= -((-width)>>1);
 836
 837     for (y=0; y<height; y++) {
 838         extract_even_c(src, ydst, width);
 839         extract_odd2_c(src, udst, vdst, chromWidth);
 840
 841         src += srcStride;
 842         ydst+= lumStride;
 843         udst+= chromStride;
 844         vdst+= chromStride;
 845     }
 846 }
 847
 848 static void uyvytoyuv420_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 849                            const uint8_t *src, int width, int height,
 850                            int lumStride, int chromStride, int srcStride)
 851 {
 852     int y;
 853     const int chromWidth= -((-width)>>1);
 854
 855     for (y=0; y<height; y++) {
 856         extract_even_c(src + 1, ydst, width);
 857         if(y&1) {
 858             extract_even2avg_c(src - srcStride, src, udst, vdst, chromWidth);
 859             udst+= chromStride;
 860             vdst+= chromStride;
 861         }
 862
 863         src += srcStride;
 864         ydst+= lumStride;
 865     }
 866 }
 867
 868 static void uyvytoyuv422_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 869                            const uint8_t *src, int width, int height,
 870                            int lumStride, int chromStride, int srcStride)
 871 {
 872     int y;
 873     const int chromWidth= -((-width)>>1);
 874
 875     for (y=0; y<height; y++) {
 876         extract_even_c(src + 1, ydst, width);
 877         extract_even2_c(src, udst, vdst, chromWidth);
 878
 879         src += srcStride;
 880         ydst+= lumStride;
 881         udst+= chromStride;
 882         vdst+= chromStride;
 883     }
 884 }
 885
 886 static inline void rgb2rgb_init_c(void)
 887 {
 888     rgb15to16          = rgb15to16_c;
 889     rgb15tobgr24       = rgb15tobgr24_c;
 890     rgb15to32          = rgb15to32_c;
 891     rgb16tobgr24       = rgb16tobgr24_c;
 892     rgb16to32          = rgb16to32_c;
 893     rgb16to15          = rgb16to15_c;
 894     rgb24tobgr16       = rgb24tobgr16_c;
 895     rgb24tobgr15       = rgb24tobgr15_c;
 896     rgb24tobgr32       = rgb24tobgr32_c;
 897     rgb32to16          = rgb32to16_c;
 898     rgb32to15          = rgb32to15_c;
 899     rgb32tobgr24       = rgb32tobgr24_c;
 900     rgb24to15          = rgb24to15_c;
 901     rgb24to16          = rgb24to16_c;
 902     rgb24tobgr24       = rgb24tobgr24_c;
 903     shuffle_bytes_2103 = shuffle_bytes_2103_c;
 904     rgb32tobgr16       = rgb32tobgr16_c;
 905     rgb32tobgr15       = rgb32tobgr15_c;
 906     yv12toyuy2         = yv12toyuy2_c;
 907     yv12touyvy         = yv12touyvy_c;
 908     yuv422ptoyuy2      = yuv422ptoyuy2_c;
 909     yuv422ptouyvy      = yuv422ptouyvy_c;
 910     yuy2toyv12         = yuy2toyv12_c;
 911     planar2x           = planar2x_c;
 912     rgb24toyv12        = rgb24toyv12_c;
 913     interleaveBytes    = interleaveBytes_c;
 914     vu9_to_vu12        = vu9_to_vu12_c;
 915     yvu9_to_yuy2       = yvu9_to_yuy2_c;
 916
 917     uyvytoyuv420       = uyvytoyuv420_c;
 918     uyvytoyuv422       = uyvytoyuv422_c;
 919     yuyvtoyuv420       = yuyvtoyuv420_c;
 920     yuyvtoyuv422       = yuyvtoyuv422_c;
 921 }