Cinelerra: hvirtual/quicktime/cmodel

00001 #include "cmodel_permutation.h"
00002 #include "colormodels.h"
00003 #include "workarounds.h"
00004 
00005 // ********************************** RGB FLOAT -> *******************************
00006 
00007 
00008 
00009 static inline void transfer_RGB_FLOAT_to_RGB8(unsigned char *(*output), float *input)
00010 {
00011         unsigned char r, g, b;
00012         r = (unsigned char)(CLIP(input[0], 0, 1) * 0x3);
00013         g = (unsigned char)(CLIP(input[1], 0, 1) * 0x7);
00014         b = (unsigned char)(CLIP(input[2], 0, 1) * 0x3);
00015 
00016         *(*output) = (r << 6) +
00017                              (g << 2) +
00018                              b;
00019         (*output)++;
00020 }
00021 
00022 static inline void transfer_RGB_FLOAT_to_BGR565(unsigned char *(*output), float *input)
00023 {
00024         unsigned char r, g, b;
00025         r = (unsigned char)(CLIP(input[0], 0, 1) * 0x1f);
00026         g = (unsigned char)(CLIP(input[1], 0, 1) * 0x3f);
00027         b = (unsigned char)(CLIP(input[2], 0, 1) * 0x1f);
00028 
00029         *(uint16_t*)(*output) = (b << 11) |
00030                 (g << 5) |
00031                 r;
00032         (*output) += 2;
00033 }
00034 
00035 static inline void transfer_RGB_FLOAT_to_RGB565(unsigned char *(*output), float *input)
00036 {
00037         unsigned char r, g, b;
00038         r = (unsigned char)(CLIP(input[0], 0, 1) * 0x1f);
00039         g = (unsigned char)(CLIP(input[1], 0, 1) * 0x3f);
00040         b = (unsigned char)(CLIP(input[2], 0, 1) * 0x1f);
00041 
00042         *(uint16_t*)(*output) = (r << 11) |
00043                 (g << 5) |
00044                 b;
00045         (*output) += 2;
00046 }
00047 
00048 static inline void transfer_RGB_FLOAT_to_BGR888(unsigned char *(*output), 
00049         float *input)
00050 {
00051         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00052         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00053         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00054         *(*output)++ = b;
00055         *(*output)++ = g;
00056         *(*output)++ = r;
00057 }
00058 
00059 static inline void transfer_RGB_FLOAT_to_RGB888(unsigned char *(*output), 
00060         float *input)
00061 {
00062         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00063         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00064         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00065         *(*output)++ = r;
00066         *(*output)++ = g;
00067         *(*output)++ = b;
00068 }
00069 
00070 static inline void transfer_RGB_FLOAT_to_RGBA8888(unsigned char *(*output), 
00071         float *input)
00072 {
00073         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00074         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00075         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00076         *(*output)++ = r;
00077         *(*output)++ = g;
00078         *(*output)++ = b;
00079         *(*output)++ = 0xff;
00080 }
00081 
00082 static inline void transfer_RGB_FLOAT_to_ARGB8888(unsigned char *(*output), 
00083         float *input)
00084 {
00085         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00086         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00087         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00088         *(*output)++ = 0xff;
00089         *(*output)++ = r;
00090         *(*output)++ = g;
00091         *(*output)++ = b;
00092 }
00093 
00094 static inline void transfer_RGB_FLOAT_to_RGBA_FLOAT(float *(*output), 
00095         float *input)
00096 {
00097         *(*output)++ = input[0];
00098         *(*output)++ = input[1];
00099         *(*output)++ = input[2];
00100         *(*output)++ = 1.0;
00101 }
00102 
00103 static inline void transfer_RGB_FLOAT_to_BGR8888(unsigned char *(*output), 
00104         float *input)
00105 {
00106         unsigned char r = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00107         unsigned char g = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00108         unsigned char b = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00109         *(*output)++ = b;
00110         *(*output)++ = g;
00111         *(*output)++ = r;
00112         (*output)++;
00113 }
00114 
00115 static inline void transfer_RGB_FLOAT_to_YUV888(unsigned char *(*output), 
00116         float *input)
00117 {
00118         int y, u, v, r, g, b;
00119         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00120         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00121         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00122 
00123         RGB_TO_YUV16(y, u, v, r, g, b);
00124 
00125         *(*output)++ = y >> 8;
00126         *(*output)++ = u >> 8;
00127         *(*output)++ = v >> 8;
00128 }
00129 
00130 static inline void transfer_RGB_FLOAT_to_YUVA8888(unsigned char *(*output), 
00131         float *input)
00132 {
00133         int y, u, v, r, g, b;
00134 
00135         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00136         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00137         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00138 
00139         RGB_TO_YUV16(y, u, v, r, g, b);
00140 
00141         *(*output)++ = y >> 8;
00142         *(*output)++ = u >> 8;
00143         *(*output)++ = v >> 8;
00144         *(*output)++ = 255;
00145 }
00146 
00147 static inline void transfer_RGB_FLOAT_to_YUV161616(uint16_t *(*output), 
00148         float *input)
00149 {
00150         int y, u, v, r, g, b;
00151         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00152         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00153         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00154 
00155         RGB_TO_YUV16(y, u, v, r, g, b);
00156 
00157         *(*output)++ = quicktime_copy(y);
00158         *(*output)++ = quicktime_copy(u);
00159         *(*output)++ = quicktime_copy(v);
00160 }
00161 
00162 static inline void transfer_RGB_FLOAT_to_YUVA16161616(uint16_t *(*output), 
00163         float *input)
00164 {
00165         int y, u, v, r, g, b;
00166 
00167         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00168         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00169         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00170 
00171         RGB_TO_YUV16(y, u, v, r, g, b);
00172 
00173         *(*output)++ = quicktime_copy(y);
00174         *(*output)++ = quicktime_copy(u);
00175         *(*output)++ = quicktime_copy(v);
00176         *(*output)++ = 0xffff;
00177 }
00178 
00179 
00180 static inline void transfer_RGB_FLOAT_to_YUV101010(unsigned char *(*output), 
00181         float *input)
00182 {
00183         int r, g, b;
00184         int y, u, v;
00185 
00186         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00187         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00188         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00189         RGB_TO_YUV16(y, u, v, r, g, b);
00190         WRITE_YUV101010(y, u, v);
00191 }
00192 
00193 static inline void transfer_RGB_FLOAT_to_VYU888(unsigned char *(*output), 
00194         float *input)
00195 {
00196         int y, u, v, r, g, b;
00197         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00198         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00199         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00200 
00201         RGB_TO_YUV16(y, u, v, r, g, b);
00202 
00203         *(*output)++ = v >> 8;
00204         *(*output)++ = y >> 8;
00205         *(*output)++ = u >> 8;
00206 }
00207 
00208 static inline void transfer_RGB_FLOAT_to_UYVA8888(unsigned char *(*output), 
00209         float *input)
00210 {
00211         int y, u, v, r, g, b;
00212 
00213         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00214         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00215         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00216 
00217         RGB_TO_YUV16(y, u, v, r, g, b);
00218 
00219         *(*output)++ = u >> 8;
00220         *(*output)++ = y >> 8;
00221         *(*output)++ = v >> 8;
00222         *(*output)++ = 0xff;
00223 }
00224 
00225 
00226 static inline void transfer_RGB_FLOAT_to_YUV420P_YUV422P(unsigned char *output_y, 
00227         unsigned char *output_u, 
00228         unsigned char *output_v, 
00229         float *input,
00230         int output_column)
00231 {
00232         int y, u, v, r, g, b;
00233         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00234         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00235         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00236 
00237         RGB_TO_YUV16(y, u, v, r, g, b);
00238 
00239         output_y[output_column] = y >> 8;
00240         output_u[output_column / 2] = u >> 8;
00241         output_v[output_column / 2] = v >> 8;
00242 }
00243 
00244 static inline void transfer_RGB_FLOAT_to_YUV422(unsigned char *(*output),
00245         float *input,
00246         int j)
00247 {
00248         int y, u, v, r, g, b;
00249         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00250         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00251         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00252 
00253         RGB_TO_YUV16(y, u, v, r, g, b);
00254         if(!(j & 1))
00255         {
00256 // Store U and V for even pixels only
00257                 (*output)[1] = u >> 8;
00258                 (*output)[3] = v >> 8;
00259                 (*output)[0] = y >> 8;
00260         }
00261         else
00262         {
00263 // Store Y and advance output for odd pixels only
00264                 (*output)[2] = y >> 8;
00265                 (*output) += 4;
00266         }
00267 }
00268 
00269 static inline void transfer_RGB_FLOAT_to_YUV444P(unsigned char *output_y, 
00270         unsigned char *output_u, 
00271         unsigned char *output_v, 
00272         float *input,
00273         int output_column)
00274 {
00275         int y, u, v, r, g, b;
00276         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00277         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00278         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00279 
00280         RGB_TO_YUV16(y, u, v, r, g, b);
00281 
00282         output_y[output_column] = y >> 8;
00283         output_u[output_column] = u >> 8;
00284         output_v[output_column] = v >> 8;
00285 }
00286 
00287 
00288 
00289 
00290 
00291 
00292 
00293 
00294 
00295 
00296 // ****************************** RGBA FLOAT -> *********************************
00297 
00298 static inline void transfer_RGBA_FLOAT_to_RGB8(unsigned char *(*output), 
00299         float *input)
00300 {
00301         uint32_t r, g, b, a;
00302         a = (uint32_t)(CLIP(input[3], 0, 1) * 0x10000);
00303         r = (uint32_t)(CLIP(input[0], 0, 1) * 0xff * a);
00304         g = (uint32_t)(CLIP(input[1], 0, 1) * 0xff * a);
00305         b = (uint32_t)(CLIP(input[2], 0, 1) * 0xff * a);
00306 
00307         *(*output) = (unsigned char)(((r & 0xc00000) >> 16) + 
00308                                 ((g & 0xe00000) >> 18) + 
00309                                 ((b & 0xe00000) >> 21));
00310         (*output)++;
00311 }
00312 
00313 static inline void transfer_RGBA_FLOAT_to_BGR565(unsigned char *(*output), 
00314         float *input)
00315 {
00316         uint32_t r, g, b, a;
00317         a = (uint32_t)(CLIP(input[3], 0, 1) * 0x10000);
00318         r = (uint32_t)(CLIP(input[0], 0, 1) * 0xff * a);
00319         g = (uint32_t)(CLIP(input[1], 0, 1) * 0xff * a);
00320         b = (uint32_t)(CLIP(input[2], 0, 1) * 0xff * a);
00321 
00322         *(uint16_t*)(*output) = (uint16_t)(((b & 0xf80000) >> 8) + 
00323                                 ((g & 0xfc0000) >> 13) + 
00324                                 ((r & 0xf80000) >> 19));
00325         (*output) += 2;
00326 }
00327 
00328 static inline void transfer_RGBA_FLOAT_to_RGB565(unsigned char *(*output), 
00329         float *input)
00330 {
00331         uint32_t r, g, b, a;
00332         a = (uint32_t)(CLIP(input[3], 0, 1) * 0x10000);
00333         r = (uint32_t)(CLIP(input[0], 0, 1) * 0xff * a);
00334         g = (uint32_t)(CLIP(input[1], 0, 1) * 0xff * a);
00335         b = (uint32_t)(CLIP(input[2], 0, 1) * 0xff * a);
00336 
00337         *(uint16_t*)(*output) = (uint16_t)(((r & 0xf80000) >> 8) + 
00338                                 ((g & 0xfc0000) >> 13) + 
00339                                 ((b & 0xf80000) >> 19));
00340         (*output) += 2;
00341 }
00342 
00343 static inline void transfer_RGBA_FLOAT_to_BGR888(unsigned char *(*output), 
00344         float *input)
00345 {
00346         uint32_t r, g, b, a;
00347         a = (uint32_t)(CLIP(input[3], 0, 1) * 0xff);
00348         r = (uint32_t)(CLIP(input[0], 0, 1) * a);
00349         g = (uint32_t)(CLIP(input[1], 0, 1) * a);
00350         b = (uint32_t)(CLIP(input[2], 0, 1) * a);
00351 
00352         *(*output)++ = (unsigned char)b;
00353         *(*output)++ = (unsigned char)g;
00354         *(*output)++ = (unsigned char)r;
00355 }
00356 
00357 static inline void transfer_RGBA_FLOAT_to_RGB888(unsigned char *(*output), 
00358         float *input)
00359 {
00360         uint32_t r, g, b, a;
00361         a = (uint32_t)(CLIP(input[3], 0, 1) * 0xff);
00362         r = (uint32_t)(CLIP(input[0], 0, 1) * a);
00363         g = (uint32_t)(CLIP(input[1], 0, 1) * a);
00364         b = (uint32_t)(CLIP(input[2], 0, 1) * a);
00365 
00366         *(*output)++ = (unsigned char)r;
00367         *(*output)++ = (unsigned char)g;
00368         *(*output)++ = (unsigned char)b;
00369 }
00370 
00371 static inline void transfer_RGBA_FLOAT_to_RGB_FLOAT(float *(*output), 
00372         float *input)
00373 {
00374         float a;
00375         a = input[3];
00376 
00377         *(*output)++ = input[0] * a;
00378         *(*output)++ = input[1] * a;
00379         *(*output)++ = input[2] * a;
00380 }
00381 
00382 
00383 static inline void transfer_RGBA_FLOAT_to_RGBA8888(unsigned char *(*output), 
00384         float *input)
00385 {
00386         *(*output)++ = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00387         *(*output)++ = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00388         *(*output)++ = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00389         *(*output)++ = (unsigned char)(CLIP(input[3], 0, 1) * 0xff);
00390 }
00391 
00392 static inline void transfer_RGBA_FLOAT_to_ARGB8888(unsigned char *(*output), 
00393         float *input)
00394 {
00395         *(*output)++ = (unsigned char)(CLIP(input[3], 0, 1) * 0xff);
00396         *(*output)++ = (unsigned char)(CLIP(input[0], 0, 1) * 0xff);
00397         *(*output)++ = (unsigned char)(CLIP(input[1], 0, 1) * 0xff);
00398         *(*output)++ = (unsigned char)(CLIP(input[2], 0, 1) * 0xff);
00399 }
00400 
00401 
00402 static inline void transfer_RGBA_FLOAT_to_BGR8888(unsigned char *(*output), 
00403         float *input)
00404 {
00405         uint32_t r, g, b, a;
00406         a = (uint32_t)(CLIP(input[3], 0, 1) * 0xff);
00407         r = (uint32_t)(CLIP(input[0], 0, 1) * a);
00408         g = (uint32_t)(CLIP(input[1], 0, 1) * a);
00409         b = (uint32_t)(CLIP(input[2], 0, 1) * a);
00410 
00411         *(*output)++ = (unsigned char)(b);
00412         *(*output)++ = (unsigned char)(g);
00413         *(*output)++ = (unsigned char)(r);
00414         *(*output)++;
00415 }
00416 
00417 static inline void transfer_RGBA_FLOAT_to_YUV888(unsigned char *(*output), 
00418         float *input)
00419 {
00420         int y, u, v, r, g, b, a;
00421         a = (int)(CLIP(input[3], 0, 1) * 0x101);
00422         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
00423         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
00424         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
00425 
00426         RGB_TO_YUV16(y, u, v, r, g, b);
00427 
00428         *(*output)++ = y >> 8;
00429         *(*output)++ = u >> 8;
00430         *(*output)++ = v >> 8;
00431 }
00432 
00433 static inline void transfer_RGBA_FLOAT_to_YUVA8888(unsigned char *(*output), 
00434         float *input)
00435 {
00436         int y, u, v, r, g, b, a;
00437 
00438         a = (int)(CLIP(input[3], 0, 1) * 0xff);
00439         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00440         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00441         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00442 
00443         RGB_TO_YUV16(y, u, v, r, g, b);
00444 
00445         *(*output)++ = y >> 8;
00446         *(*output)++ = u >> 8;
00447         *(*output)++ = v >> 8;
00448         *(*output)++ = a;
00449 }
00450 
00451 static inline void transfer_RGBA_FLOAT_to_YUV161616(uint16_t *(*output), 
00452         float *input)
00453 {
00454         int y, u, v, r, g, b, a;
00455 
00456         a = (int)(CLIP(input[3], 0, 1) * 0x101);
00457         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
00458         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
00459         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
00460 
00461         RGB_TO_YUV16(y, u, v, r, g, b);
00462 
00463 // GCC 3.3 optimization error
00464         *(*output)++ = quicktime_copy(y);
00465         *(*output)++ = quicktime_copy(u);
00466         *(*output)++ = quicktime_copy(v);
00467 }
00468 
00469 static inline void transfer_RGBA_FLOAT_to_YUVA16161616(uint16_t *(*output), 
00470         float *input)
00471 {
00472         int y, u, v, r, g, b, a;
00473 
00474         r = (int)(CLIP(input[0], 0, 1) * 0xffff);
00475         g = (int)(CLIP(input[1], 0, 1) * 0xffff);
00476         b = (int)(CLIP(input[2], 0, 1) * 0xffff);
00477         a = (int)(CLIP(input[3], 0, 1) * 0xffff);
00478 
00479         RGB_TO_YUV16(y, u, v, r, g, b);
00480 
00481 // GCC 3.3 optimization error
00482         *(*output)++ = quicktime_copy(y);
00483         *(*output)++ = quicktime_copy(u);
00484         *(*output)++ = quicktime_copy(v);
00485         *(*output)++ = quicktime_copy(a);
00486 }
00487 
00488 static inline void transfer_RGBA_FLOAT_to_YUV101010(unsigned char *(*output), 
00489         float *input)
00490 {
00491         int y, u, v, r, g, b, a;
00492 
00493         a = (int)(CLIP(input[3], 0, 1) * 0x101);
00494         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
00495         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
00496         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
00497 
00498         RGB_TO_YUV16(y, u, v, r, g, b);
00499         WRITE_YUV101010(y, u, v);
00500 }
00501 
00502 
00503 static inline void transfer_RGBA_FLOAT_to_YUV420P_YUV422P(unsigned char *output_y, 
00504         unsigned char *output_u, 
00505         unsigned char *output_v, 
00506         float *input,
00507         int output_column)
00508 {
00509         int y, u, v, r, g, b, a;
00510         a = (int)(CLIP(input[3], 0, 1) * 0x101);
00511         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
00512         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
00513         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
00514 
00515         RGB_TO_YUV16(y, u, v, r, g, b);
00516 
00517         output_y[output_column] = y >> 8;
00518         output_u[output_column / 2] = u >> 8;
00519         output_v[output_column / 2] = v >> 8;
00520 }
00521 
00522 static inline void transfer_RGBA_FLOAT_to_YUV422(unsigned char *(*output),
00523         float *input,
00524         int j)
00525 {
00526         int y, u, v, r, g, b;
00527         float a = CLIP(input[3], 0, 1);
00528         r = (int)(CLIP(input[0], 0, 1) * a * 0xffff);
00529         g = (int)(CLIP(input[1], 0, 1) * a * 0xffff);
00530         b = (int)(CLIP(input[2], 0, 1) * a * 0xffff);
00531 
00532         RGB_TO_YUV16(y, u, v, r, g, b);
00533         if(!(j & 1))
00534         {
00535 // Store U and V for even pixels only
00536                 (*output)[1] = u >> 8;
00537                 (*output)[3] = v >> 8;
00538                 (*output)[0] = y >> 8;
00539         }
00540         else
00541         {
00542 // Store Y and advance output for odd pixels only
00543                 (*output)[2] = y >> 8;
00544                 (*output) += 4;
00545         }
00546 }
00547 
00548 
00549 static inline void transfer_RGBA_FLOAT_to_YUV444P(unsigned char *output_y, 
00550         unsigned char *output_u, 
00551         unsigned char *output_v, 
00552         float *input,
00553         int output_column)
00554 {
00555         int y, u, v, r, g, b, a;
00556         a = (int)(CLIP(input[3], 0, 1) * 0x101);
00557         r = (int)(CLIP(input[0], 0, 1) * 0xff * a);
00558         g = (int)(CLIP(input[1], 0, 1) * 0xff * a);
00559         b = (int)(CLIP(input[2], 0, 1) * 0xff * a);
00560 
00561         RGB_TO_YUV16(y, u, v, r, g, b);
00562 
00563         output_y[output_column] = y >> 8;
00564         output_u[output_column] = u >> 8;
00565         output_v[output_column] = v >> 8;
00566 }
00567 
00568 
00569 
00570 
00571 
00572 
00573 
00574 
00575 
00576 
00577 
00578 
00579 
00580 
00581 
00582 #define TRANSFER_DEFAULT(output, \
00583         input, \
00584         y_in_offset, \
00585         u_in_offset, \
00586         v_in_offset, \
00587         input_column) \
00588 { \
00589         register int i, j; \
00590  \
00591         switch(in_colormodel) \
00592         { \
00593                 case BC_RGB_FLOAT: \
00594                         switch(out_colormodel) \
00595                         { \
00596                                 case BC_RGB8: \
00597                                         TRANSFER_FRAME_HEAD \
00598                                         transfer_RGB_FLOAT_to_RGB8((output), (float*)(input));      \
00599                                         TRANSFER_FRAME_TAIL \
00600                                         break; \
00601                                 case BC_BGR565: \
00602                                         TRANSFER_FRAME_HEAD \
00603                                         transfer_RGB_FLOAT_to_BGR565((output), (float*)(input));    \
00604                                         TRANSFER_FRAME_TAIL \
00605                                         break; \
00606                                 case BC_RGB565: \
00607                                         TRANSFER_FRAME_HEAD \
00608                                         transfer_RGB_FLOAT_to_RGB565((output), (float*)(input));    \
00609                                         TRANSFER_FRAME_TAIL \
00610                                         break; \
00611                                 case BC_BGR888: \
00612                                         TRANSFER_FRAME_HEAD \
00613                                         transfer_RGB_FLOAT_to_BGR888((output), (float*)(input));    \
00614                                         TRANSFER_FRAME_TAIL \
00615                                         break; \
00616                                 case BC_BGR8888: \
00617                                         TRANSFER_FRAME_HEAD \
00618                                         transfer_RGB_FLOAT_to_BGR8888((output), (float*)(input));   \
00619                                         TRANSFER_FRAME_TAIL \
00620                                         break; \
00621                                 case BC_RGB888: \
00622                                         TRANSFER_FRAME_HEAD \
00623                                         transfer_RGB_FLOAT_to_RGB888((output), (float*)(input));    \
00624                                         TRANSFER_FRAME_TAIL \
00625                                         break; \
00626                                 case BC_RGBA8888: \
00627                                         TRANSFER_FRAME_HEAD \
00628                                         transfer_RGB_FLOAT_to_RGBA8888((output), (float*)(input));    \
00629                                         TRANSFER_FRAME_TAIL \
00630                                         break; \
00631                                 case BC_ARGB8888: \
00632                                         TRANSFER_FRAME_HEAD \
00633                                         transfer_RGB_FLOAT_to_ARGB8888((output), (float*)(input));    \
00634                                         TRANSFER_FRAME_TAIL \
00635                                         break; \
00636                                 case BC_RGBA_FLOAT: \
00637                                         TRANSFER_FRAME_HEAD \
00638                                         transfer_RGB_FLOAT_to_RGBA_FLOAT((float**)(output), (float*)(input));    \
00639                                         TRANSFER_FRAME_TAIL \
00640                                         break; \
00641                                 case BC_YUV888: \
00642                                         TRANSFER_FRAME_HEAD \
00643                                         transfer_RGB_FLOAT_to_YUV888((output), (float*)(input));   \
00644                                         TRANSFER_FRAME_TAIL \
00645                                         break; \
00646                                 case BC_YUVA8888: \
00647                                         TRANSFER_FRAME_HEAD \
00648                                         transfer_RGB_FLOAT_to_YUVA8888((output), (float*)(input));   \
00649                                         TRANSFER_FRAME_TAIL \
00650                                         break; \
00651                                 case BC_YUV161616: \
00652                                         TRANSFER_FRAME_HEAD \
00653                                         transfer_RGB_FLOAT_to_YUV161616((uint16_t**)(output), (float*)(input));   \
00654                                         TRANSFER_FRAME_TAIL \
00655                                         break; \
00656                                 case BC_YUVA16161616: \
00657                                         TRANSFER_FRAME_HEAD \
00658                                         transfer_RGB_FLOAT_to_YUVA16161616((uint16_t**)(output), (float*)(input));   \
00659                                         TRANSFER_FRAME_TAIL \
00660                                         break; \
00661                                 case BC_YUV101010: \
00662                                         TRANSFER_FRAME_HEAD \
00663                                         transfer_RGB_FLOAT_to_YUV101010((output), (float*)(input));   \
00664                                         TRANSFER_FRAME_TAIL \
00665                                         break; \
00666                                 case BC_YUV420P: \
00667                                         TRANSFER_YUV420P_OUT_HEAD \
00668                                         transfer_RGB_FLOAT_to_YUV420P_YUV422P(output_y, \
00669                                                 output_u, \
00670                                                 output_v, \
00671                                                 (float*)(input), \
00672                                                 j); \
00673                                         TRANSFER_FRAME_TAIL \
00674                                         break; \
00675                                 case BC_YUV422P: \
00676                                         TRANSFER_YUV422P_OUT_HEAD \
00677                                         transfer_RGB_FLOAT_to_YUV420P_YUV422P(output_y, \
00678                                                 output_u, \
00679                                                 output_v, \
00680                                                 (float*)(input), \
00681                                                 j); \
00682                                         TRANSFER_FRAME_TAIL \
00683                                         break; \
00684                                 case BC_YUV422: \
00685                                         TRANSFER_FRAME_HEAD \
00686                                         transfer_RGB_FLOAT_to_YUV422((output), \
00687                                                 (float*)(input), \
00688                                                 j); \
00689                                         TRANSFER_FRAME_TAIL \
00690                                         break; \
00691                                 case BC_YUV444P: \
00692                                         TRANSFER_YUV444P_OUT_HEAD \
00693                                         transfer_RGB_FLOAT_to_YUV444P(output_y, \
00694                                                 output_u, \
00695                                                 output_v, \
00696                                                 (float*)(input), \
00697                                                 j); \
00698                                         TRANSFER_FRAME_TAIL \
00699                                         break; \
00700                         } \
00701                         break; \
00702  \
00703                 case BC_RGBA_FLOAT: \
00704                         switch(out_colormodel) \
00705                         { \
00706                                 case BC_RGB8: \
00707                                         TRANSFER_FRAME_HEAD \
00708                                         transfer_RGBA_FLOAT_to_RGB8((output), (float*)(input)); \
00709                                         TRANSFER_FRAME_TAIL \
00710                                         break; \
00711                                 case BC_BGR565: \
00712                                         TRANSFER_FRAME_HEAD \
00713                                         transfer_RGBA_FLOAT_to_BGR565((output), (float*)(input)); \
00714                                         TRANSFER_FRAME_TAIL \
00715                                         break; \
00716                                 case BC_RGB565: \
00717                                         TRANSFER_FRAME_HEAD \
00718                                         transfer_RGBA_FLOAT_to_RGB565((output), (float*)(input)); \
00719                                         TRANSFER_FRAME_TAIL \
00720                                         break; \
00721                                 case BC_BGR888:      \
00722                                         TRANSFER_FRAME_HEAD \
00723                                         transfer_RGBA_FLOAT_to_BGR888((output), (float*)(input)); \
00724                                         TRANSFER_FRAME_TAIL \
00725                                         break; \
00726                                 case BC_BGR8888: \
00727                                         TRANSFER_FRAME_HEAD \
00728                                         transfer_RGBA_FLOAT_to_BGR8888((output), (float*)(input)); \
00729                                         TRANSFER_FRAME_TAIL \
00730                                         break; \
00731                                 case BC_RGB888: \
00732                                         TRANSFER_FRAME_HEAD \
00733                                         transfer_RGBA_FLOAT_to_RGB888((output), (float*)(input)); \
00734                                         TRANSFER_FRAME_TAIL \
00735                                         break; \
00736                                 case BC_RGB_FLOAT: \
00737                                         TRANSFER_FRAME_HEAD \
00738                                         transfer_RGBA_FLOAT_to_RGB_FLOAT((float**)(output), (float*)(input)); \
00739                                         TRANSFER_FRAME_TAIL \
00740                                         break; \
00741                                 case BC_RGBA8888: \
00742                                         TRANSFER_FRAME_HEAD \
00743                                         transfer_RGBA_FLOAT_to_RGBA8888((output), (float*)(input)); \
00744                                         TRANSFER_FRAME_TAIL \
00745                                         break; \
00746                                 case BC_ARGB8888: \
00747                                         TRANSFER_FRAME_HEAD \
00748                                         transfer_RGBA_FLOAT_to_ARGB8888((output), (float*)(input)); \
00749                                         TRANSFER_FRAME_TAIL \
00750                                         break; \
00751                                 case BC_YUV888: \
00752                                         TRANSFER_FRAME_HEAD \
00753                                         transfer_RGBA_FLOAT_to_YUV888((output), (float*)(input));   \
00754                                         TRANSFER_FRAME_TAIL \
00755                                         break; \
00756                                 case BC_YUVA8888: \
00757                                         TRANSFER_FRAME_HEAD \
00758                                         transfer_RGBA_FLOAT_to_YUVA8888((output), (float*)(input));   \
00759                                         TRANSFER_FRAME_TAIL \
00760                                         break; \
00761                                 case BC_YUV161616: \
00762                                         TRANSFER_FRAME_HEAD \
00763                                         transfer_RGBA_FLOAT_to_YUV161616((uint16_t**)(output), (float*)(input));   \
00764                                         TRANSFER_FRAME_TAIL \
00765                                         break; \
00766                                 case BC_YUVA16161616: \
00767                                         TRANSFER_FRAME_HEAD \
00768                                         transfer_RGBA_FLOAT_to_YUVA16161616((uint16_t**)(output), (float*)(input));  \
00769                                         TRANSFER_FRAME_TAIL \
00770                                         break; \
00771                                 case BC_YUV101010: \
00772                                         TRANSFER_FRAME_HEAD \
00773                                         transfer_RGBA_FLOAT_to_YUV101010((output), (float*)(input)); \
00774                                         TRANSFER_FRAME_TAIL \
00775                                         break; \
00776                                 case BC_YUV420P: \
00777                                         TRANSFER_YUV420P_OUT_HEAD \
00778                                         transfer_RGBA_FLOAT_to_YUV420P_YUV422P(output_y, \
00779                                                 output_u, \
00780                                                 output_v, \
00781                                                 (float*)(input), \
00782                                                 j); \
00783                                         TRANSFER_FRAME_TAIL \
00784                                         break; \
00785                                 case BC_YUV422P: \
00786                                         TRANSFER_YUV422P_OUT_HEAD \
00787                                         transfer_RGBA_FLOAT_to_YUV420P_YUV422P(output_y, \
00788                                                 output_u, \
00789                                                 output_v, \
00790                                                 (float*)(input), \
00791                                                 j); \
00792                                         TRANSFER_FRAME_TAIL \
00793                                         break; \
00794                                 case BC_YUV422: \
00795                                         TRANSFER_FRAME_HEAD \
00796                                         transfer_RGBA_FLOAT_to_YUV422((output), \
00797                                                 (float*)(input), \
00798                                                 j); \
00799                                         TRANSFER_FRAME_TAIL \
00800                                         break; \
00801                                 case BC_YUV444P: \
00802                                         TRANSFER_YUV444P_OUT_HEAD \
00803                                         transfer_RGBA_FLOAT_to_YUV444P(output_y, \
00804                                                 output_u, \
00805                                                 output_v, \
00806                                                 (float*)(input), \
00807                                                 j); \
00808                                         TRANSFER_FRAME_TAIL \
00809                                         break; \
00810                         } \
00811                         break; \
00812         } \
00813 }
00814 
00815 
00816 
00817 void cmodel_float(PERMUTATION_ARGS)
00818 {
00819         if(scale)
00820         {
00821                 TRANSFER_DEFAULT(&output_row, 
00822                         input_row + column_table[j] * in_pixelsize,
00823                         0,
00824                         0,
00825                         0,
00826                         0);
00827         }
00828         else
00829         {
00830                 TRANSFER_DEFAULT(&output_row, 
00831                         input_row + j * in_pixelsize,
00832                         0,
00833                         0,
00834                         0,
00835                         0);
00836         }
00837 }
00838
hvirtual/quicktime/cmodel_float.c
