quicktime/cmodel_float.c

   1 #include "cmodel_permutation.h"
   2 #include "colormodels.h"
   3 #include "workarounds.h"
   4
   5 // ********************************** RGB FLOAT -> *******************************
   6
   7
   8
   9 static inline void transfer_RGB_FLOAT_to_RGB8(unsigned char *(*output), float *input)
  10 {
  11         unsigned char r, g, b;
  12         r = (unsigned char)(CLIP(input[0], 0, 1) * 0x3);
  13         g = (unsigned char)(CLIP(input[1], 0, 1) * 0x7);
  14         b = (unsigned char)(CLIP(input[2], 0, 1) * 0x3);
  15
  16         *(*output) = (r << 6) +
  17                              (g << 2) +
  18                              b;
  19         (*output)++;
  20 }
  21
  22 static inline void transfer_RGB_FLOAT_to_BGR565(unsigned char *(*output), float *input)
  23 {
  24         unsigned char r, g, b;
  25         r = (unsigned char)(CLIP(input[0], 0, 1) * 0x1f);
  26         g = (unsigned char)(CLIP(input[1], 0, 1) * 0x3f);
  27         b = (unsigned char)(CLIP(input[2], 0, 1) * 0x1f);
  28
  29         *(uint16_t*)(*output) = (b << 11) |
  30                 (g << 5) |
  31                 r;
  32         (*output) += 2;
  33 }
  34
  35 static inline void transfer_RGB_FLOAT_to_RGB565(unsigned char *(*output), float *input)
  36 {
  37         unsigned char r, g, b;
  38         r = (unsigned char)(CLIP(input[0], 0, 1) * 0x1f);
  39         g = (unsigned char)(CLIP(input[1], 0, 1) * 0x3f);
  40         b = (unsigned char)(CLIP(input[2], 0, 1) * 0x1f);
  41
  42         *(uint16_t*)(*output) = (r << 11) |
  43                 (g << 5) |
  44                 b;
  45         (*output) += 2;
  46 }
  47
  48 static inline void transfer_RGB_FLOAT_to_BGR888(unsigned char *(*output),
  49         float *input)
  50 {
  51         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
  52         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
  53         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
  54         *(*output)++ = b;
  55         *(*output)++ = g;
  56         *(*output)++ = r;
  57 }
  58
  59 static inline void transfer_RGB_FLOAT_to_RGB888(unsigned char *(*output),
  60         float *input)
  61 {
  62         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
  63         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
  64         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
  65         *(*output)++ = r;
  66         *(*output)++ = g;
  67         *(*output)++ = b;
  68 }
  69
  70 static inline void transfer_RGB_FLOAT_to_RGBA8888(unsigned char *(*output),
  71         float *input)
  72 {
  73         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
  74         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
  75         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
  76         *(*output)++ = r;
  77         *(*output)++ = g;
  78         *(*output)++ = b;
  79         *(*output)++ = 0xff;
  80 }
  81
  82 static inline void transfer_RGB_FLOAT_to_ARGB8888(unsigned char *(*output),
  83         float *input)
  84 {
  85         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
  86         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
  87         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
  88         *(*output)++ = 0xff;
  89         *(*output)++ = r;
  90         *(*output)++ = g;
  91         *(*output)++ = b;
  92 }
  93
  94 static inline void transfer_RGB_FLOAT_to_RGBA_FLOAT(float *(*output),
  95         float *input)
  96 {
  97         *(*output)++ = input[0];
  98         *(*output)++ = input[1];
  99         *(*output)++ = input[2];
 100         *(*output)++ = 1.0;
 101 }
 102
 103 static inline void transfer_RGB_FLOAT_to_BGR8888(unsigned char *(*output),
 104         float *input)
 105 {
 106         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
 107         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
 108         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
 109         *(*output)++ = b;
 110         *(*output)++ = g;
 111         *(*output)++ = r;
 112         (*output)++;
 113 }
 114
 115 static inline void transfer_RGB_FLOAT_to_YUV888(unsigned char *(*output),
 116         float *input)
 117 {
 118         int y, u, v, r, g, b;
 119         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 120         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 121         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 122
 123         RGB_TO_YUV16(y, u, v, r, g, b);
 124
 125         *(*output)++ = y >> 8;
 126         *(*output)++ = u >> 8;
 127         *(*output)++ = v >> 8;
 128 }
 129
 130 static inline void transfer_RGB_FLOAT_to_YUVA8888(unsigned char *(*output),
 131         float *input)
 132 {
 133         int y, u, v, r, g, b;
 134
 135         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 136         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 137         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 138
 139         RGB_TO_YUV16(y, u, v, r, g, b);
 140
 141         *(*output)++ = y >> 8;
 142         *(*output)++ = u >> 8;
 143         *(*output)++ = v >> 8;
 144         *(*output)++ = 255;
 145 }
 146
 147 static inline void transfer_RGB_FLOAT_to_YUV161616(uint16_t *(*output),
 148         float *input)
 149 {
 150         int y, u, v, r, g, b;
 151         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 152         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 153         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 154
 155         RGB_TO_YUV16(y, u, v, r, g, b);
 156
 157         *(*output)++ = quicktime_copy(y);
 158         *(*output)++ = quicktime_copy(u);
 159         *(*output)++ = quicktime_copy(v);
 160 }
 161
 162 static inline void transfer_RGB_FLOAT_to_YUVA16161616(uint16_t *(*output),
 163         float *input)
 164 {
 165         int y, u, v, r, g, b;
 166
 167         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 168         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 169         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 170
 171         RGB_TO_YUV16(y, u, v, r, g, b);
 172
 173         *(*output)++ = quicktime_copy(y);
 174         *(*output)++ = quicktime_copy(u);
 175         *(*output)++ = quicktime_copy(v);
 176         *(*output)++ = 0xffff;
 177 }
 178
 179
 180 static inline void transfer_RGB_FLOAT_to_YUV101010(unsigned char *(*output),
 181         float *input)
 182 {
 183         int r, g, b;
 184         int y, u, v;
 185
 186         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 187         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 188         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 189         RGB_TO_YUV16(y, u, v, r, g, b);
 190         WRITE_YUV101010(y, u, v);
 191 }
 192
 193 static inline void transfer_RGB_FLOAT_to_VYU888(unsigned char *(*output),
 194         float *input)
 195 {
 196         int y, u, v, r, g, b;
 197         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 198         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 199         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 200
 201         RGB_TO_YUV16(y, u, v, r, g, b);
 202
 203         *(*output)++ = v >> 8;
 204         *(*output)++ = y >> 8;
 205         *(*output)++ = u >> 8;
 206 }
 207
 208 static inline void transfer_RGB_FLOAT_to_UYVA8888(unsigned char *(*output),
 209         float *input)
 210 {
 211         int y, u, v, r, g, b;
 212
 213         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 214         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 215         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 216
 217         RGB_TO_YUV16(y, u, v, r, g, b);
 218
 219         *(*output)++ = u >> 8;
 220         *(*output)++ = y >> 8;
 221         *(*output)++ = v >> 8;
 222         *(*output)++ = 0xff;
 223 }
 224
 225
 226 static inline void transfer_RGB_FLOAT_to_YUV420P_YUV422P(unsigned char *output_y,
 227         unsigned char *output_u,
 228         unsigned char *output_v,
 229         float *input,
 230         int output_column)
 231 {
 232         int y, u, v, r, g, b;
 233         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 234         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 235         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 236
 237         RGB_TO_YUV16(y, u, v, r, g, b);
 238
 239         output_y[output_column] = y >> 8;
 240         output_u[output_column / 2] = u >> 8;
 241         output_v[output_column / 2] = v >> 8;
 242 }
 243
 244 static inline void transfer_RGB_FLOAT_to_YUV422(unsigned char *(*output),
 245         float *input,
 246         int j)
 247 {
 248         int y, u, v, r, g, b;
 249         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 250         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 251         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 252
 253         RGB_TO_YUV16(y, u, v, r, g, b);
 254         if(!(j & 1))
 255         {
 256 // Store U and V for even pixels only
 257                 (*output)[1] = u >> 8;
 258                 (*output)[3] = v >> 8;
 259                 (*output)[0] = y >> 8;
 260         }
 261         else
 262         {
 263 // Store Y and advance output for odd pixels only
 264                 (*output)[2] = y >> 8;
 265                 (*output) += 4;
 266         }
 267 }
 268
 269 static inline void transfer_RGB_FLOAT_to_YUV444P(unsigned char *output_y,
 270         unsigned char *output_u,
 271         unsigned char *output_v,
 272         float *input,
 273         int output_column)
 274 {
 275         int y, u, v, r, g, b;
 276         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 277         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 278         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 279
 280         RGB_TO_YUV16(y, u, v, r, g, b);
 281
 282         output_y[output_column] = y >> 8;
 283         output_u[output_column] = u >> 8;
 284         output_v[output_column] = v >> 8;
 285 }
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296 // ****************************** RGBA FLOAT -> *********************************
 297
 298 static inline void transfer_RGBA_FLOAT_to_RGB8(unsigned char *(*output),
 299         float *input)
 300 {
 301         uint32_t r, g, b, a;
 302         a = (uint32_t)(CLIP(input[3], 0, 1) * 0x10000);
 303         r = (uint32_t)(CLIP(input[0], 0, 1) * 0xff * a);
 304         g = (uint32_t)(CLIP(input[1], 0, 1) * 0xff * a);
 305         b = (uint32_t)(CLIP(input[2], 0, 1) * 0xff * a);
 306
 307         *(*output) = (unsigned char)(((r & 0xc00000) >> 16) +
 308                                 ((g & 0xe00000) >> 18) +
 309                                 ((b & 0xe00000) >> 21));
 310         (*output)++;
 311 }
 312
 313 static inline void transfer_RGBA_FLOAT_to_BGR565(unsigned char *(*output),
 314         float *input)
 315 {
 316         uint32_t r, g, b, a;
 317         a = (uint32_t)(CLIP(input[3], 0, 1) * 0x10000);
 318         r = (uint32_t)(CLIP(input[0], 0, 1) * 0xff * a);
 319         g = (uint32_t)(CLIP(input[1], 0, 1) * 0xff * a);
 320         b = (uint32_t)(CLIP(input[2], 0, 1) * 0xff * a);
 321
 322         *(uint16_t*)(*output) = (uint16_t)(((b & 0xf80000) >> 8) +
 323                                 ((g & 0xfc0000) >> 13) +
 324                                 ((r & 0xf80000) >> 19));
 325         (*output) += 2;
 326 }
 327
 328 static inline void transfer_RGBA_FLOAT_to_RGB565(unsigned char *(*output),
 329         float *input)
 330 {
 331         uint32_t r, g, b, a;
 332         a = (uint32_t)(CLIP(input[3], 0, 1) * 0x10000);
 333         r = (uint32_t)(CLIP(input[0], 0, 1) * 0xff * a);
 334         g = (uint32_t)(CLIP(input[1], 0, 1) * 0xff * a);
 335         b = (uint32_t)(CLIP(input[2], 0, 1) * 0xff * a);
 336
 337         *(uint16_t*)(*output) = (uint16_t)(((r & 0xf80000) >> 8) +
 338                                 ((g & 0xfc0000) >> 13) +
 339                                 ((b & 0xf80000) >> 19));
 340         (*output) += 2;
 341 }
 342
 343 static inline void transfer_RGBA_FLOAT_to_BGR888(unsigned char *(*output),
 344         float *input)
 345 {
 346         uint32_t r, g, b, a;
 347         a = (uint32_t)(CLIP(input[3], 0, 1) * 0xff);
 348         r = (uint32_t)(CLIP(input[0], 0, 1) * a);
 349         g = (uint32_t)(CLIP(input[1], 0, 1) * a);
 350         b = (uint32_t)(CLIP(input[2], 0, 1) * a);
 351
 352         *(*output)++ = (unsigned char)b;
 353         *(*output)++ = (unsigned char)g;
 354         *(*output)++ = (unsigned char)r;
 355 }
 356
 357 static inline void transfer_RGBA_FLOAT_to_RGB888(unsigned char *(*output),
 358         float *input)
 359 {
 360         uint32_t r, g, b, a;
 361         a = (uint32_t)(CLIP(input[3], 0, 1) * 0xff);
 362         r = (uint32_t)(CLIP(input[0], 0, 1) * a);
 363         g = (uint32_t)(CLIP(input[1], 0, 1) * a);
 364         b = (uint32_t)(CLIP(input[2], 0, 1) * a);
 365
 366         *(*output)++ = (unsigned char)r;
 367         *(*output)++ = (unsigned char)g;
 368         *(*output)++ = (unsigned char)b;
 369 }
 370
 371 static inline void transfer_RGBA_FLOAT_to_RGB_FLOAT(float *(*output),
 372         float *input)
 373 {
 374         float a;
 375         a = input[3];
 376
 377         *(*output)++ = input[0] * a;
 378         *(*output)++ = input[1] * a;
 379         *(*output)++ = input[2] * a;
 380 }
 381
 382
 383 static inline void transfer_RGBA_FLOAT_to_RGBA8888(unsigned char *(*output),
 384         float *input)
 385 {
 386         *(*output)++ = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
 387         *(*output)++ = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
 388         *(*output)++ = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
 389         *(*output)++ = (unsigned char)(CLIP(input[3], 0, 1) * 0xff);
 390 }
 391
 392 static inline void transfer_RGBA_FLOAT_to_ARGB8888(unsigned char *(*output),
 393         float *input)
 394 {
 395         *(*output)++ = (unsigned char)(CLIP(input[3], 0, 1) * 0xff);
 396         *(*output)++ = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
 397         *(*output)++ = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
 398         *(*output)++ = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
 399 }
 400
 401
 402 static inline void transfer_RGBA_FLOAT_to_BGR8888(unsigned char *(*output),
 403         float *input)
 404 {
 405         uint32_t r, g, b, a;
 406         a = (uint32_t)(CLIP(input[3], 0, 1) * 0xff);
 407         r = (uint32_t)(CLIP(input[0], 0, 1) * a);
 408         g = (uint32_t)(CLIP(input[1], 0, 1) * a);
 409         b = (uint32_t)(CLIP(input[2], 0, 1) * a);
 410
 411         *(*output)++ = (unsigned char)(b);
 412         *(*output)++ = (unsigned char)(g);
 413         *(*output)++ = (unsigned char)(r);
 414         *(*output)++;
 415 }
 416
 417 static inline void transfer_RGBA_FLOAT_to_YUV888(unsigned char *(*output),
 418         float *input)
 419 {
 420         int y, u, v, r, g, b, a;
 421         a = (int)(CLIP(input[3], 0, 1) * 0x101);
 422         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
 423         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
 424         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
 425
 426         RGB_TO_YUV16(y, u, v, r, g, b);
 427
 428         *(*output)++ = y >> 8;
 429         *(*output)++ = u >> 8;
 430         *(*output)++ = v >> 8;
 431 }
 432
 433 static inline void transfer_RGBA_FLOAT_to_YUVA8888(unsigned char *(*output),
 434         float *input)
 435 {
 436         int y, u, v, r, g, b, a;
 437
 438         a = (int)(CLIP(input[3], 0, 1) * 0xff);
 439         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 440         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 441         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 442
 443         RGB_TO_YUV16(y, u, v, r, g, b);
 444
 445         *(*output)++ = y >> 8;
 446         *(*output)++ = u >> 8;
 447         *(*output)++ = v >> 8;
 448         *(*output)++ = a;
 449 }
 450
 451 static inline void transfer_RGBA_FLOAT_to_YUV161616(uint16_t *(*output),
 452         float *input)
 453 {
 454         int y, u, v, r, g, b, a;
 455
 456         a = (int)(CLIP(input[3], 0, 1) * 0x101);
 457         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
 458         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
 459         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
 460
 461         RGB_TO_YUV16(y, u, v, r, g, b);
 462
 463 // GCC 3.3 optimization error
 464         *(*output)++ = quicktime_copy(y);
 465         *(*output)++ = quicktime_copy(u);
 466         *(*output)++ = quicktime_copy(v);
 467 }
 468
 469 static inline void transfer_RGBA_FLOAT_to_YUVA16161616(uint16_t *(*output),
 470         float *input)
 471 {
 472         int y, u, v, r, g, b, a;
 473
 474         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
 475         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
 476         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
 477         a = (int)(CLIP(input[3], 0, 1) * 0xffff);
 478
 479         RGB_TO_YUV16(y, u, v, r, g, b);
 480
 481 // GCC 3.3 optimization error
 482         *(*output)++ = quicktime_copy(y);
 483         *(*output)++ = quicktime_copy(u);
 484         *(*output)++ = quicktime_copy(v);
 485         *(*output)++ = quicktime_copy(a);
 486 }
 487
 488 static inline void transfer_RGBA_FLOAT_to_YUV101010(unsigned char *(*output),
 489         float *input)
 490 {
 491         int y, u, v, r, g, b, a;
 492
 493         a = (int)(CLIP(input[3], 0, 1) * 0x101);
 494         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
 495         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
 496         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
 497
 498         RGB_TO_YUV16(y, u, v, r, g, b);
 499         WRITE_YUV101010(y, u, v);
 500 }
 501
 502
 503 static inline void transfer_RGBA_FLOAT_to_YUV420P_YUV422P(unsigned char *output_y,
 504         unsigned char *output_u,
 505         unsigned char *output_v,
 506         float *input,
 507         int output_column)
 508 {
 509         int y, u, v, r, g, b, a;
 510         a = (int)(CLIP(input[3], 0, 1) * 0x101);
 511         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
 512         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
 513         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
 514
 515         RGB_TO_YUV16(y, u, v, r, g, b);
 516
 517         output_y[output_column] = y >> 8;
 518         output_u[output_column / 2] = u >> 8;
 519         output_v[output_column / 2] = v >> 8;
 520 }
 521
 522 static inline void transfer_RGBA_FLOAT_to_YUV422(unsigned char *(*output),
 523         float *input,
 524         int j)
 525 {
 526         int y, u, v, r, g, b;
 527         float a = CLIP(input[3], 0, 1);
 528         r = (int)(CLIP(input[0], 0, 1) * a * 0xffff);
 529         g = (int)(CLIP(input[1], 0, 1) * a * 0xffff);
 530         b = (int)(CLIP(input[2], 0, 1) * a * 0xffff);
 531
 532         RGB_TO_YUV16(y, u, v, r, g, b);
 533         if(!(j & 1))
 534         {
 535 // Store U and V for even pixels only
 536                 (*output)[1] = u >> 8;
 537                 (*output)[3] = v >> 8;
 538                 (*output)[0] = y >> 8;
 539         }
 540         else
 541         {
 542 // Store Y and advance output for odd pixels only
 543                 (*output)[2] = y >> 8;
 544                 (*output) += 4;
 545         }
 546 }
 547
 548
 549 static inline void transfer_RGBA_FLOAT_to_YUV444P(unsigned char *output_y,
 550         unsigned char *output_u,
 551         unsigned char *output_v,
 552         float *input,
 553         int output_column)
 554 {
 555         int y, u, v, r, g, b, a;
 556         a = (int)(CLIP(input[3], 0, 1) * 0x101);
 557         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
 558         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
 559         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
 560
 561         RGB_TO_YUV16(y, u, v, r, g, b);
 562
 563         output_y[output_column] = y >> 8;
 564         output_u[output_column] = u >> 8;
 565         output_v[output_column] = v >> 8;
 566 }
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582 #define TRANSFER_DEFAULT(output, \
 583         input, \
 584         y_in_offset, \
 585         u_in_offset, \
 586         v_in_offset, \
 587         input_column) \
 588 { \
 589         register int i, j; \
 590  \
 591         switch(in_colormodel) \
 592         { \
 593                 case BC_RGB_FLOAT: \
 594                         switch(out_colormodel) \
 595                         { \
 596                                 case BC_RGB8: \
 597                                         TRANSFER_FRAME_HEAD \
 598                                         transfer_RGB_FLOAT_to_RGB8((output), (float*)(input));      \
 599                                         TRANSFER_FRAME_TAIL \
 600                                         break; \
 601                                 case BC_BGR565: \
 602                                         TRANSFER_FRAME_HEAD \
 603                                         transfer_RGB_FLOAT_to_BGR565((output), (float*)(input));    \
 604                                         TRANSFER_FRAME_TAIL \
 605                                         break; \
 606                                 case BC_RGB565: \
 607                                         TRANSFER_FRAME_HEAD \
 608                                         transfer_RGB_FLOAT_to_RGB565((output), (float*)(input));    \
 609                                         TRANSFER_FRAME_TAIL \
 610                                         break; \
 611                                 case BC_BGR888: \
 612                                         TRANSFER_FRAME_HEAD \
 613                                         transfer_RGB_FLOAT_to_BGR888((output), (float*)(input));    \
 614                                         TRANSFER_FRAME_TAIL \
 615                                         break; \
 616                                 case BC_BGR8888: \
 617                                         TRANSFER_FRAME_HEAD \
 618                                         transfer_RGB_FLOAT_to_BGR8888((output), (float*)(input));   \
 619                                         TRANSFER_FRAME_TAIL \
 620                                         break; \
 621                                 case BC_RGB888: \
 622                                         TRANSFER_FRAME_HEAD \
 623                                         transfer_RGB_FLOAT_to_RGB888((output), (float*)(input));    \
 624                                         TRANSFER_FRAME_TAIL \
 625                                         break; \
 626                                 case BC_RGBA8888: \
 627                                         TRANSFER_FRAME_HEAD \
 628                                         transfer_RGB_FLOAT_to_RGBA8888((output), (float*)(input));    \
 629                                         TRANSFER_FRAME_TAIL \
 630                                         break; \
 631                                 case BC_ARGB8888: \
 632                                         TRANSFER_FRAME_HEAD \
 633                                         transfer_RGB_FLOAT_to_ARGB8888((output), (float*)(input));    \
 634                                         TRANSFER_FRAME_TAIL \
 635                                         break; \
 636                                 case BC_RGBA_FLOAT: \
 637                                         TRANSFER_FRAME_HEAD \
 638                                         transfer_RGB_FLOAT_to_RGBA_FLOAT((float**)(output), (float*)(input));    \
 639                                         TRANSFER_FRAME_TAIL \
 640                                         break; \
 641                                 case BC_YUV888: \
 642                                         TRANSFER_FRAME_HEAD \
 643                                         transfer_RGB_FLOAT_to_YUV888((output), (float*)(input));   \
 644                                         TRANSFER_FRAME_TAIL \
 645                                         break; \
 646                                 case BC_YUVA8888: \
 647                                         TRANSFER_FRAME_HEAD \
 648                                         transfer_RGB_FLOAT_to_YUVA8888((output), (float*)(input));   \
 649                                         TRANSFER_FRAME_TAIL \
 650                                         break; \
 651                                 case BC_YUV161616: \
 652                                         TRANSFER_FRAME_HEAD \
 653                                         transfer_RGB_FLOAT_to_YUV161616((uint16_t**)(output), (float*)(input));   \
 654                                         TRANSFER_FRAME_TAIL \
 655                                         break; \
 656                                 case BC_YUVA16161616: \
 657                                         TRANSFER_FRAME_HEAD \
 658                                         transfer_RGB_FLOAT_to_YUVA16161616((uint16_t**)(output), (float*)(input));   \
 659                                         TRANSFER_FRAME_TAIL \
 660                                         break; \
 661                                 case BC_YUV101010: \
 662                                         TRANSFER_FRAME_HEAD \
 663                                         transfer_RGB_FLOAT_to_YUV101010((output), (float*)(input));   \
 664                                         TRANSFER_FRAME_TAIL \
 665                                         break; \
 666                                 case BC_YUV420P: \
 667                                         TRANSFER_YUV420P_OUT_HEAD \
 668                                         transfer_RGB_FLOAT_to_YUV420P_YUV422P(output_y, \
 669                                                 output_u, \
 670                                                 output_v, \
 671                                                 (float*)(input), \
 672                                                 j); \
 673                                         TRANSFER_FRAME_TAIL \
 674                                         break; \
 675                                 case BC_YUV422P: \
 676                                         TRANSFER_YUV422P_OUT_HEAD \
 677                                         transfer_RGB_FLOAT_to_YUV420P_YUV422P(output_y, \
 678                                                 output_u, \
 679                                                 output_v, \
 680                                                 (float*)(input), \
 681                                                 j); \
 682                                         TRANSFER_FRAME_TAIL \
 683                                         break; \
 684                                 case BC_YUV422: \
 685                                         TRANSFER_FRAME_HEAD \
 686                                         transfer_RGB_FLOAT_to_YUV422((output), \
 687                                                 (float*)(input), \
 688                                                 j); \
 689                                         TRANSFER_FRAME_TAIL \
 690                                         break; \
 691                                 case BC_YUV444P: \
 692                                         TRANSFER_YUV444P_OUT_HEAD \
 693                                         transfer_RGB_FLOAT_to_YUV444P(output_y, \
 694                                                 output_u, \
 695                                                 output_v, \
 696                                                 (float*)(input), \
 697                                                 j); \
 698                                         TRANSFER_FRAME_TAIL \
 699                                         break; \
 700                         } \
 701                         break; \
 702  \
 703                 case BC_RGBA_FLOAT: \
 704                         switch(out_colormodel) \
 705                         { \
 706                                 case BC_RGB8: \
 707                                         TRANSFER_FRAME_HEAD \
 708                                         transfer_RGBA_FLOAT_to_RGB8((output), (float*)(input)); \
 709                                         TRANSFER_FRAME_TAIL \
 710                                         break; \
 711                                 case BC_BGR565: \
 712                                         TRANSFER_FRAME_HEAD \
 713                                         transfer_RGBA_FLOAT_to_BGR565((output), (float*)(input)); \
 714                                         TRANSFER_FRAME_TAIL \
 715                                         break; \
 716                                 case BC_RGB565: \
 717                                         TRANSFER_FRAME_HEAD \
 718                                         transfer_RGBA_FLOAT_to_RGB565((output), (float*)(input)); \
 719                                         TRANSFER_FRAME_TAIL \
 720                                         break; \
 721                                 case BC_BGR888:      \
 722                                         TRANSFER_FRAME_HEAD \
 723                                         transfer_RGBA_FLOAT_to_BGR888((output), (float*)(input)); \
 724                                         TRANSFER_FRAME_TAIL \
 725                                         break; \
 726                                 case BC_BGR8888: \
 727                                         TRANSFER_FRAME_HEAD \
 728                                         transfer_RGBA_FLOAT_to_BGR8888((output), (float*)(input)); \
 729                                         TRANSFER_FRAME_TAIL \
 730                                         break; \
 731                                 case BC_RGB888: \
 732                                         TRANSFER_FRAME_HEAD \
 733                                         transfer_RGBA_FLOAT_to_RGB888((output), (float*)(input)); \
 734                                         TRANSFER_FRAME_TAIL \
 735                                         break; \
 736                                 case BC_RGB_FLOAT: \
 737                                         TRANSFER_FRAME_HEAD \
 738                                         transfer_RGBA_FLOAT_to_RGB_FLOAT((float**)(output), (float*)(input)); \
 739                                         TRANSFER_FRAME_TAIL \
 740                                         break; \
 741                                 case BC_RGBA8888: \
 742                                         TRANSFER_FRAME_HEAD \
 743                                         transfer_RGBA_FLOAT_to_RGBA8888((output), (float*)(input)); \
 744                                         TRANSFER_FRAME_TAIL \
 745                                         break; \
 746                                 case BC_ARGB8888: \
 747                                         TRANSFER_FRAME_HEAD \
 748                                         transfer_RGBA_FLOAT_to_ARGB8888((output), (float*)(input)); \
 749                                         TRANSFER_FRAME_TAIL \
 750                                         break; \
 751                                 case BC_YUV888: \
 752                                         TRANSFER_FRAME_HEAD \
 753                                         transfer_RGBA_FLOAT_to_YUV888((output), (float*)(input));   \
 754                                         TRANSFER_FRAME_TAIL \
 755                                         break; \
 756                                 case BC_YUVA8888: \
 757                                         TRANSFER_FRAME_HEAD \
 758                                         transfer_RGBA_FLOAT_to_YUVA8888((output), (float*)(input));   \
 759                                         TRANSFER_FRAME_TAIL \
 760                                         break; \
 761                                 case BC_YUV161616: \
 762                                         TRANSFER_FRAME_HEAD \
 763                                         transfer_RGBA_FLOAT_to_YUV161616((uint16_t**)(output), (float*)(input));   \
 764                                         TRANSFER_FRAME_TAIL \
 765                                         break; \
 766                                 case BC_YUVA16161616: \
 767                                         TRANSFER_FRAME_HEAD \
 768                                         transfer_RGBA_FLOAT_to_YUVA16161616((uint16_t**)(output), (float*)(input));  \
 769                                         TRANSFER_FRAME_TAIL \
 770                                         break; \
 771                                 case BC_YUV101010: \
 772                                         TRANSFER_FRAME_HEAD \
 773                                         transfer_RGBA_FLOAT_to_YUV101010((output), (float*)(input)); \
 774                                         TRANSFER_FRAME_TAIL \
 775                                         break; \
 776                                 case BC_YUV420P: \
 777                                         TRANSFER_YUV420P_OUT_HEAD \
 778                                         transfer_RGBA_FLOAT_to_YUV420P_YUV422P(output_y, \
 779                                                 output_u, \
 780                                                 output_v, \
 781                                                 (float*)(input), \
 782                                                 j); \
 783                                         TRANSFER_FRAME_TAIL \
 784                                         break; \
 785                                 case BC_YUV422P: \
 786                                         TRANSFER_YUV422P_OUT_HEAD \
 787                                         transfer_RGBA_FLOAT_to_YUV420P_YUV422P(output_y, \
 788                                                 output_u, \
 789                                                 output_v, \
 790                                                 (float*)(input), \
 791                                                 j); \
 792                                         TRANSFER_FRAME_TAIL \
 793                                         break; \
 794                                 case BC_YUV422: \
 795                                         TRANSFER_FRAME_HEAD \
 796                                         transfer_RGBA_FLOAT_to_YUV422((output), \
 797                                                 (float*)(input), \
 798                                                 j); \
 799                                         TRANSFER_FRAME_TAIL \
 800                                         break; \
 801                                 case BC_YUV444P: \
 802                                         TRANSFER_YUV444P_OUT_HEAD \
 803                                         transfer_RGBA_FLOAT_to_YUV444P(output_y, \
 804                                                 output_u, \
 805                                                 output_v, \
 806                                                 (float*)(input), \
 807                                                 j); \
 808                                         TRANSFER_FRAME_TAIL \
 809                                         break; \
 810                         } \
 811                         break; \
 812         } \
 813 }
 814
 815
 816
 817 void cmodel_float(PERMUTATION_ARGS)
 818 {
 819         if(scale)
 820         {
 821                 TRANSFER_DEFAULT(&output_row,
 822                         input_row + column_table[j] * in_pixelsize,
 823                         0,
 824                         0,
 825                         0,
 826                         0);
 827         }
 828         else
 829         {
 830                 TRANSFER_DEFAULT(&output_row,
 831                         input_row + j * in_pixelsize,
 832                         0,
 833                         0,
 834                         0,
 835                         0);
 836         }
 837 }
 838