cinelerra-5.0/quicktime/cmodel_float.c

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