git.sesse.net Git - ffmpeg/blob - postproc/rgb2rgb.c

   1 /*
   2  *
   3  *  rgb2rgb.c, Software RGB to RGB convertor
   4  *  pluralize by Software PAL8 to RGB convertor
   5  *               Software YUV to YUV convertor
   6  *               Software YUV to RGB convertor
   7  *  Written by Nick Kurshev.
   8  *  palette & yuv & runtime cpu stuff by Michael (michaelni@gmx.at) (under GPL)
   9  */
  10 #include <inttypes.h>
  11 #include "../config.h"
  12 #include "rgb2rgb.h"
  13 #include "../cpudetect.h"
  14
  15 #ifdef ARCH_X86
  16 #define CAN_COMPILE_X86_ASM
  17 #endif
  18
  19 #ifdef CAN_COMPILE_X86_ASM
  20 static const uint64_t mask32b  __attribute__((aligned(8))) = 0x000000FF000000FFULL;
  21 static const uint64_t mask32g  __attribute__((aligned(8))) = 0x0000FF000000FF00ULL;
  22 static const uint64_t mask32r  __attribute__((aligned(8))) = 0x00FF000000FF0000ULL;
  23 static const uint64_t mask32   __attribute__((aligned(8))) = 0x00FFFFFF00FFFFFFULL;
  24 static const uint64_t mask24l  __attribute__((aligned(8))) = 0x0000000000FFFFFFULL;
  25 static const uint64_t mask24h  __attribute__((aligned(8))) = 0x0000FFFFFF000000ULL;
  26 static const uint64_t mask24hh  __attribute__((aligned(8))) = 0xffff000000000000ULL;
  27 static const uint64_t mask24hhh  __attribute__((aligned(8))) = 0xffffffff00000000ULL;
  28 static const uint64_t mask24hhhh  __attribute__((aligned(8))) = 0xffffffffffff0000ULL;
  29 static const uint64_t mask15b  __attribute__((aligned(8))) = 0x001F001F001F001FULL; /* 00000000 00011111  xxB */
  30 static const uint64_t mask15rg __attribute__((aligned(8))) = 0x7FE07FE07FE07FE0ULL; /* 01111111 11100000  RGx */
  31 static const uint64_t mask15s  __attribute__((aligned(8))) = 0xFFE0FFE0FFE0FFE0ULL;
  32 static const uint64_t red_16mask  __attribute__((aligned(8))) = 0x0000f8000000f800ULL;
  33 static const uint64_t green_16mask __attribute__((aligned(8)))= 0x000007e0000007e0ULL;
  34 static const uint64_t blue_16mask __attribute__((aligned(8))) = 0x0000001f0000001fULL;
  35 static const uint64_t red_15mask  __attribute__((aligned(8))) = 0x00007c000000f800ULL;
  36 static const uint64_t green_15mask __attribute__((aligned(8)))= 0x000003e0000007e0ULL;
  37 static const uint64_t blue_15mask __attribute__((aligned(8))) = 0x0000001f0000001fULL;
  38 #if 0
  39 static volatile uint64_t __attribute__((aligned(8))) b5Dither;
  40 static volatile uint64_t __attribute__((aligned(8))) g5Dither;
  41 static volatile uint64_t __attribute__((aligned(8))) g6Dither;
  42 static volatile uint64_t __attribute__((aligned(8))) r5Dither;
  43
  44 static uint64_t __attribute__((aligned(8))) dither4[2]={
  45         0x0103010301030103LL,
  46         0x0200020002000200LL,};
  47
  48 static uint64_t __attribute__((aligned(8))) dither8[2]={
  49         0x0602060206020602LL,
  50         0x0004000400040004LL,};
  51 #endif
  52 #endif
  53
  54 #define RGB2YUV_SHIFT 8
  55 #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
  56 #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
  57 #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
  58 #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
  59 #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
  60 #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
  61 #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
  62 #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
  63 #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
  64
  65 //Note: we have C, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
  66 //Plain C versions
  67 #undef HAVE_MMX
  68 #undef HAVE_MMX2
  69 #undef HAVE_3DNOW
  70 #undef ARCH_X86
  71 #define RENAME(a) a ## _C
  72 #include "rgb2rgb_template.c"
  73
  74 #ifdef CAN_COMPILE_X86_ASM
  75
  76 //MMX versions
  77 #undef RENAME
  78 #define HAVE_MMX
  79 #undef HAVE_MMX2
  80 #undef HAVE_3DNOW
  81 #define ARCH_X86
  82 #define RENAME(a) a ## _MMX
  83 #include "rgb2rgb_template.c"
  84
  85 //MMX2 versions
  86 #undef RENAME
  87 #define HAVE_MMX
  88 #define HAVE_MMX2
  89 #undef HAVE_3DNOW
  90 #define ARCH_X86
  91 #define RENAME(a) a ## _MMX2
  92 #include "rgb2rgb_template.c"
  93
  94 //3DNOW versions
  95 #undef RENAME
  96 #define HAVE_MMX
  97 #undef HAVE_MMX2
  98 #define HAVE_3DNOW
  99 #define ARCH_X86
 100 #define RENAME(a) a ## _3DNow
 101 #include "rgb2rgb_template.c"
 102
 103 #endif //CAN_COMPILE_X86_ASM
 104
 105 void rgb24to32(const uint8_t *src,uint8_t *dst,unsigned src_size)
 106 {
 107 #ifdef CAN_COMPILE_X86_ASM
 108         // ordered per speed fasterst first
 109         if(gCpuCaps.hasMMX2)
 110                 rgb24to32_MMX2(src, dst, src_size);
 111         else if(gCpuCaps.has3DNow)
 112                 rgb24to32_3DNow(src, dst, src_size);
 113         else if(gCpuCaps.hasMMX)
 114                 rgb24to32_MMX(src, dst, src_size);
 115         else
 116                 rgb24to32_C(src, dst, src_size);
 117 #else
 118                 rgb24to32_C(src, dst, src_size);
 119 #endif
 120 }
 121
 122 void rgb32to24(const uint8_t *src,uint8_t *dst,unsigned src_size)
 123 {
 124 #ifdef CAN_COMPILE_X86_ASM
 125         // ordered per speed fasterst first
 126         if(gCpuCaps.hasMMX2)
 127                 rgb32to24_MMX2(src, dst, src_size);
 128         else if(gCpuCaps.has3DNow)
 129                 rgb32to24_3DNow(src, dst, src_size);
 130         else if(gCpuCaps.hasMMX)
 131                 rgb32to24_MMX(src, dst, src_size);
 132         else
 133                 rgb32to24_C(src, dst, src_size);
 134 #else
 135                 rgb32to24_C(src, dst, src_size);
 136 #endif
 137 }
 138
 139 /*
 140  Original by Strepto/Astral
 141  ported to gcc & bugfixed : A'rpi
 142  MMX2, 3DNOW optimization by Nick Kurshev
 143  32bit c version, and and&add trick by Michael Niedermayer
 144 */
 145 void rgb15to16(const uint8_t *src,uint8_t *dst,unsigned src_size)
 146 {
 147 #ifdef CAN_COMPILE_X86_ASM
 148         // ordered per speed fasterst first
 149         if(gCpuCaps.hasMMX2)
 150                 rgb15to16_MMX2(src, dst, src_size);
 151         else if(gCpuCaps.has3DNow)
 152                 rgb15to16_3DNow(src, dst, src_size);
 153         else if(gCpuCaps.hasMMX)
 154                 rgb15to16_MMX(src, dst, src_size);
 155         else
 156                 rgb15to16_C(src, dst, src_size);
 157 #else
 158                 rgb15to16_C(src, dst, src_size);
 159 #endif
 160 }
 161
 162 /**
 163  * Pallete is assumed to contain bgr32
 164  */
 165 void palette8torgb32(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
 166 {
 167         unsigned i;
 168         for(i=0; i<num_pixels; i++)
 169                 ((unsigned *)dst)[i] = ((unsigned *)palette)[ src[i] ];
 170 }
 171
 172 /**
 173  * Pallete is assumed to contain bgr32
 174  */
 175 void palette8torgb24(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
 176 {
 177         unsigned i;
 178 /*
 179         writes 1 byte o much and might cause alignment issues on some architectures?
 180         for(i=0; i<num_pixels; i++)
 181                 ((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ];
 182 */
 183         for(i=0; i<num_pixels; i++)
 184         {
 185                 //FIXME slow?
 186                 dst[0]= palette[ src[i]*4+0 ];
 187                 dst[1]= palette[ src[i]*4+1 ];
 188                 dst[2]= palette[ src[i]*4+2 ];
 189                 dst+= 3;
 190         }
 191 }
 192
 193 void rgb32to16(const uint8_t *src, uint8_t *dst, unsigned src_size)
 194 {
 195 #ifdef CAN_COMPILE_X86_ASM
 196         // ordered per speed fasterst first
 197         if(gCpuCaps.hasMMX2)
 198                 rgb32to16_MMX2(src, dst, src_size);
 199         else if(gCpuCaps.has3DNow)
 200                 rgb32to16_3DNow(src, dst, src_size);
 201         else if(gCpuCaps.hasMMX)
 202                 rgb32to16_MMX(src, dst, src_size);
 203         else
 204                 rgb32to16_C(src, dst, src_size);
 205 #else
 206                 rgb32to16_C(src, dst, src_size);
 207 #endif
 208 }
 209
 210 void rgb32to15(const uint8_t *src, uint8_t *dst, unsigned src_size)
 211 {
 212 #ifdef CAN_COMPILE_X86_ASM
 213         // ordered per speed fasterst first
 214         if(gCpuCaps.hasMMX2)
 215                 rgb32to15_MMX2(src, dst, src_size);
 216         else if(gCpuCaps.has3DNow)
 217                 rgb32to15_3DNow(src, dst, src_size);
 218         else if(gCpuCaps.hasMMX)
 219                 rgb32to15_MMX(src, dst, src_size);
 220         else
 221                 rgb32to15_C(src, dst, src_size);
 222 #else
 223                 rgb32to15_C(src, dst, src_size);
 224 #endif
 225 }
 226
 227 void rgb24to16(const uint8_t *src, uint8_t *dst, unsigned src_size)
 228 {
 229 #ifdef CAN_COMPILE_X86_ASM
 230         // ordered per speed fasterst first
 231         if(gCpuCaps.hasMMX2)
 232                 rgb24to16_MMX2(src, dst, src_size);
 233         else if(gCpuCaps.has3DNow)
 234                 rgb24to16_3DNow(src, dst, src_size);
 235         else if(gCpuCaps.hasMMX)
 236                 rgb24to16_MMX(src, dst, src_size);
 237         else
 238                 rgb24to16_C(src, dst, src_size);
 239 #else
 240                 rgb24to16_C(src, dst, src_size);
 241 #endif
 242 }
 243
 244 void rgb24to15(const uint8_t *src, uint8_t *dst, unsigned src_size)
 245 {
 246 #ifdef CAN_COMPILE_X86_ASM
 247         // ordered per speed fasterst first
 248         if(gCpuCaps.hasMMX2)
 249                 rgb24to15_MMX2(src, dst, src_size);
 250         else if(gCpuCaps.has3DNow)
 251                 rgb24to15_3DNow(src, dst, src_size);
 252         else if(gCpuCaps.hasMMX)
 253                 rgb24to15_MMX(src, dst, src_size);
 254         else
 255                 rgb24to15_C(src, dst, src_size);
 256 #else
 257                 rgb24to15_C(src, dst, src_size);
 258 #endif
 259 }
 260
 261 /**
 262  * Palette is assumed to contain bgr16, see rgb32to16 to convert the palette
 263  */
 264 void palette8torgb16(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
 265 {
 266         unsigned i;
 267         for(i=0; i<num_pixels; i++)
 268                 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];
 269 }
 270
 271 /**
 272  * Pallete is assumed to contain bgr15, see rgb32to15 to convert the palette
 273  */
 274 void palette8torgb15(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
 275 {
 276         unsigned i;
 277         for(i=0; i<num_pixels; i++)
 278                 ((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];
 279 }
 280
 281 void rgb32tobgr32(const uint8_t *src, uint8_t *dst, unsigned int src_size)
 282 {
 283 #ifdef CAN_COMPILE_X86_ASM
 284         // ordered per speed fasterst first
 285         if(gCpuCaps.hasMMX2)
 286                 rgb32tobgr32_MMX2(src, dst, src_size);
 287         else if(gCpuCaps.has3DNow)
 288                 rgb32tobgr32_3DNow(src, dst, src_size);
 289         else if(gCpuCaps.hasMMX)
 290                 rgb32tobgr32_MMX(src, dst, src_size);
 291         else
 292                 rgb32tobgr32_C(src, dst, src_size);
 293 #else
 294                 rgb32tobgr32_C(src, dst, src_size);
 295 #endif
 296 }
 297
 298 /**
 299  *
 300  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
 301  * problem for anyone then tell me, and ill fix it)
 302  */
 303 void yv12toyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
 304         unsigned int width, unsigned int height,
 305         unsigned int lumStride, unsigned int chromStride, unsigned int dstStride)
 306 {
 307 #ifdef CAN_COMPILE_X86_ASM
 308         // ordered per speed fasterst first
 309         if(gCpuCaps.hasMMX2)
 310                 yv12toyuy2_MMX2(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
 311         else if(gCpuCaps.has3DNow)
 312                 yv12toyuy2_3DNow(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
 313         else if(gCpuCaps.hasMMX)
 314                 yv12toyuy2_MMX(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
 315         else
 316                 yv12toyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
 317 #else
 318                 yv12toyuy2_C(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride);
 319 #endif
 320 }
 321
 322 /**
 323  *
 324  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
 325  * problem for anyone then tell me, and ill fix it)
 326  */
 327 void yuy2toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 328         unsigned int width, unsigned int height,
 329         unsigned int lumStride, unsigned int chromStride, unsigned int srcStride)
 330 {
 331 #ifdef CAN_COMPILE_X86_ASM
 332         // ordered per speed fasterst first
 333         if(gCpuCaps.hasMMX2)
 334                 yuy2toyv12_MMX2(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 335         else if(gCpuCaps.has3DNow)
 336                 yuy2toyv12_3DNow(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 337         else if(gCpuCaps.hasMMX)
 338                 yuy2toyv12_MMX(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 339         else
 340                 yuy2toyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 341 #else
 342                 yuy2toyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 343 #endif
 344 }
 345
 346 /**
 347  *
 348  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
 349  * problem for anyone then tell me, and ill fix it)
 350  * chrominance data is only taken from every secound line others are ignored FIXME write HQ version
 351  */
 352 void uyvytoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 353         unsigned int width, unsigned int height,
 354         unsigned int lumStride, unsigned int chromStride, unsigned int srcStride)
 355 {
 356 #ifdef CAN_COMPILE_X86_ASM
 357         // ordered per speed fasterst first
 358         if(gCpuCaps.hasMMX2)
 359                 uyvytoyv12_MMX2(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 360         else if(gCpuCaps.has3DNow)
 361                 uyvytoyv12_3DNow(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 362         else if(gCpuCaps.hasMMX)
 363                 uyvytoyv12_MMX(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 364         else
 365                 uyvytoyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 366 #else
 367                 uyvytoyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 368 #endif
 369 }
 370
 371 /**
 372  *
 373  * height should be a multiple of 2 and width should be a multiple of 2 (if this is a
 374  * problem for anyone then tell me, and ill fix it)
 375  * chrominance data is only taken from every secound line others are ignored FIXME write HQ version
 376  */
 377 void rgb24toyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 378         unsigned int width, unsigned int height,
 379         unsigned int lumStride, unsigned int chromStride, unsigned int srcStride)
 380 {
 381 #ifdef CAN_COMPILE_X86_ASM
 382         // ordered per speed fasterst first
 383         if(gCpuCaps.hasMMX2)
 384                 rgb24toyv12_MMX2(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 385         else if(gCpuCaps.has3DNow)
 386                 rgb24toyv12_3DNow(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 387         else if(gCpuCaps.hasMMX)
 388                 rgb24toyv12_MMX(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 389         else
 390                 rgb24toyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 391 #else
 392                 rgb24toyv12_C(src, ydst, udst, vdst, width,  height, lumStride, chromStride, srcStride);
 393 #endif
 394 }