Cinelerra: hvirtual/quicktime/cmodel

00001 /*
00002  * This library is free software; you can redistribute it and/or modify it
00003  * under the terms of the GNU Lesser General Public License as published
00004  * by the Free Software Foundation; either version 2 of the License, or
00005  * (at your option) any later version.
00006  * 
00007  * This library is distributed in the hope that it will be useful, but
00008  * WITHOUT ANY WARRANTY; without even the implied warranty of
00009  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00010  * Lesser General Public License for more details.
00011  * 
00012  * You should have received a copy of the GNU Lesser General Public
00013  * License along with this library; if not, write to the Free Software
00014  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 
00015  * USA
00016  */
00017 
00018 
00019 #include "cmodel_permutation.h"
00020 
00021 
00022 
00023 static inline void transfer_YUV422_to_RGB8(unsigned char *(*output), 
00024         unsigned char *input, 
00025         int column)
00026 {
00027         int y, u, v;
00028         int r, g, b;
00029 
00030 // Even pixel
00031         if(!(column & 1))
00032                 y = (int)(input[0]) << 16;
00033         else
00034 // Odd pixel
00035                 y = (int)(input[2]) << 16;
00036 
00037         u = input[1];
00038         v = input[3];
00039         YUV_TO_RGB(y, u, v, r, g, b)
00040 
00041         *(*output) = (unsigned char)((r & 0xc0) +
00042                                                  ((g & 0xe0) >> 2) +
00043                                                  ((b & 0xe0) >> 5));
00044         (*output)++;
00045 }
00046 
00047 static inline void transfer_YUV422_to_BGR565(unsigned char *(*output), 
00048         unsigned char *input, 
00049         int column)
00050 {
00051         int y, u, v;
00052         int r, g, b;
00053 
00054 // Even pixel
00055         if(!(column & 1))
00056                 y = (int)(input[0]) << 16;
00057         else
00058 // Odd pixel
00059                 y = (int)(input[2]) << 16;
00060         u = input[1];
00061         v = input[3];
00062         YUV_TO_RGB(y, u, v, r, g, b)
00063 
00064         *(uint16_t*)(*output) = ((b & 0xf8) << 8)
00065                          + ((g & 0xfc) << 3)
00066                          + ((r & 0xf8) >> 3);
00067         (*output) += 2;
00068 }
00069 
00070 static inline void transfer_YUV422_to_RGB565(unsigned char *(*output), 
00071         unsigned char *input, 
00072         int column)
00073 {
00074         int y, u, v;
00075         int r, g, b;
00076 
00077 // Even pixel
00078         if(!(column & 1))
00079                 y = (int)(input[0]) << 16;
00080         else
00081 // Odd pixel
00082                 y = (int)(input[2]) << 16;
00083         u = input[1];
00084         v = input[3];
00085         YUV_TO_RGB(y, u, v, r, g, b)
00086 
00087         *(uint16_t*)(*output) = ((r & 0xf8) << 8)
00088                          + ((g & 0xfc) << 3)
00089                          + ((b & 0xf8) >> 3);
00090         (*output) += 2;
00091 }
00092 
00093 static inline void transfer_YUV422_to_BGR888(unsigned char *(*output), 
00094         unsigned char *input, 
00095         int column)
00096 {
00097         int y, u, v;
00098         int r, g, b;
00099 
00100 // Even pixel
00101         if(!(column & 1))
00102                 y = (int)(input[0]) << 16;
00103         else
00104 // Odd pixel
00105                 y = (int)(input[2]) << 16;
00106         u = input[1];
00107         v = input[3];
00108         YUV_TO_RGB(y, u, v, r, g, b)
00109 
00110         (*output)[0] = b;
00111         (*output)[1] = g;
00112         (*output)[2] = r;
00113         (*output) += 3;
00114 }
00115 
00116 static inline void transfer_YUV422_to_RGB888(unsigned char *(*output), 
00117         unsigned char *input, 
00118         int column)
00119 {
00120         int y, u, v;
00121         int r, g, b;
00122 
00123 // Even pixel
00124         if(!(column & 1))
00125                 y = (input[0] << 16) | (input[0] << 8) | input[0];
00126         else
00127 // Odd pixel
00128                 y = (input[2] << 16) | (input[2] << 8) | input[2];
00129         u = input[1];
00130         v = input[3];
00131         YUV_TO_RGB(y, u, v, r, g, b)
00132 
00133         (*output)[0] = r;
00134         (*output)[1] = g;
00135         (*output)[2] = b;
00136         (*output) += 3;
00137 }
00138 
00139 static inline void transfer_YUV422_to_RGBA8888(unsigned char *(*output), 
00140         unsigned char *input, 
00141         int column)
00142 {
00143         int y, u, v;
00144         int r, g, b;
00145 
00146 // Even pixel
00147         if(!(column & 1))
00148                 y = (input[0] << 16) | (input[0] << 8) | input[0];
00149         else
00150 // Odd pixel
00151                 y = (input[2] << 16) | (input[2] << 8) | input[2];
00152         u = input[1];
00153         v = input[3];
00154         YUV_TO_RGB(y, u, v, r, g, b)
00155 
00156         (*output)[0] = r;
00157         (*output)[1] = g;
00158         (*output)[2] = b;
00159         (*output)[3] = 0xff;
00160         (*output) += 4;
00161 }
00162 
00163 static inline void transfer_YUV422_to_RGB161616(uint16_t *(*output), 
00164         unsigned char *input, 
00165         int column)
00166 {
00167         int y, u, v;
00168         int r, g, b;
00169 
00170 // Even pixel
00171         if(!(column & 1))
00172                 y = (input[0] << 16) | (input[0] << 8) | input[0];
00173         else
00174 // Odd pixel
00175                 y = (input[2] << 16) | (input[2] << 8) | input[2];
00176         u = (input[1] << 8) | input[1];
00177         v = (input[3] << 8) | input[3];
00178         YUV_TO_RGB16(y, u, v, r, g, b)
00179 
00180         (*output)[0] = r;
00181         (*output)[1] = g;
00182         (*output)[2] = b;
00183         (*output) += 3;
00184 }
00185 
00186 static inline void transfer_YUV422_to_RGBA16161616(uint16_t *(*output), 
00187         unsigned char *input, 
00188         int column)
00189 {
00190         int y, u, v;
00191         int r, g, b;
00192 
00193 // Even pixel
00194         if(!(column & 1))
00195                 y = (input[0] << 16) | (input[0] << 8) | input[0];
00196         else
00197 // Odd pixel
00198                 y = (input[2] << 16) | (input[2] << 8) | input[2];
00199         u = (input[1] << 8) | input[1];
00200         v = (input[3] << 8) | input[3];
00201         YUV_TO_RGB16(y, u, v, r, g, b)
00202 
00203         (*output)[0] = r;
00204         (*output)[1] = g;
00205         (*output)[2] = b;
00206         (*output)[3] = 0xffff;
00207         (*output) += 4;
00208 }
00209 
00210 static inline void transfer_YUV422_to_RGB_FLOAT(float* *output, 
00211         unsigned char *input, 
00212         int column)
00213 {
00214         float y;
00215 // Signedness is important
00216         int u, v;
00217         float r, g, b;
00218 
00219 // Even pixel
00220         if(!(column & 1))
00221                 y = (float)input[0] / 0xff;
00222         else
00223 // Odd pixel
00224                 y = (float)input[2] / 0xff;
00225         u = input[1];
00226         v = input[3];
00227         YUV_TO_FLOAT(y, u, v, r, g, b)
00228 
00229         *(*output)++ = r;
00230         *(*output)++ = g;
00231         *(*output)++ = b;
00232 }
00233 
00234 static inline void transfer_YUV422_to_RGBA_FLOAT(float* *output, 
00235         unsigned char *input, 
00236         int column)
00237 {
00238         float y;
00239 // Signedness is important
00240         int u, v;
00241         float r, g, b;
00242 
00243 // Even pixel
00244         if(!(column & 1))
00245                 y = (float)input[0] / 0xff;
00246         else
00247 // Odd pixel
00248                 y = (float)input[2] / 0xff;
00249         u = input[1];
00250         v = input[3];
00251         YUV_TO_FLOAT(y, u, v, r, g, b)
00252 
00253         *(*output)++ = r;
00254         *(*output)++ = g;
00255         *(*output)++ = b;
00256         *(*output)++ = 1.0;
00257 }
00258 
00259 static inline void transfer_YUV422_to_YUV888(unsigned char *(*output), 
00260         unsigned char *input, 
00261         int column)
00262 {
00263 // Even pixel
00264         if(!(column & 1))
00265                 (*output)[0] = input[0];
00266         else
00267 // Odd pixel
00268                 (*output)[0] = input[2];
00269 
00270         (*output)[1] = input[1];
00271         (*output)[2] = input[3];
00272         (*output) += 3;
00273 }
00274 
00275 static inline void transfer_YUV422_to_YUVA8888(unsigned char *(*output), 
00276         unsigned char *input, 
00277         int column)
00278 {
00279 // Even pixel
00280         if(!(column & 1))
00281                 (*output)[0] = input[0];
00282         else
00283 // Odd pixel
00284                 (*output)[0] = input[2];
00285 
00286         (*output)[1] = input[1];
00287         (*output)[2] = input[3];
00288         (*output)[3] = 255;
00289         (*output) += 4;
00290 }
00291 
00292 static inline void transfer_YUV422_to_YUV161616(uint16_t *(*output), 
00293         unsigned char *input, 
00294         int column)
00295 {
00296 // Even pixel
00297         if(!(column & 1))
00298                 (*output)[0] = (input[0] << 8) | input[0];
00299         else
00300 // Odd pixel
00301                 (*output)[0] = (input[2] << 8) | input[2];
00302 
00303         (*output)[1] = (input[1] << 8) | input[1];
00304         (*output)[2] = (input[3] << 8) | input[3];
00305         (*output) += 3;
00306 }
00307 
00308 static inline void transfer_YUV422_to_YUVA16161616(uint16_t *(*output), 
00309         unsigned char *input, 
00310         int column)
00311 {
00312 // Even pixel
00313         if(!(column & 1))
00314                 (*output)[0] = (input[0] << 8) | input[0];
00315         else
00316 // Odd pixel
00317                 (*output)[0] = (input[2] << 8) | input[2];
00318 
00319         (*output)[1] = (input[1] << 8) | input[1];
00320         (*output)[2] = (input[3] << 8) | input[3];
00321         (*output)[3] = 0xffff;
00322         (*output) += 4;
00323 }
00324 
00325 static inline void transfer_YUV422_to_BGR8888(unsigned char *(*output), 
00326         unsigned char *input, 
00327         int column)
00328 {
00329         int y, u, v;
00330         int r, g, b;
00331 
00332 // Even pixel
00333         if(!(column & 1))
00334                 y = (int)(input[0]) << 16;
00335         else
00336 // Odd pixel
00337                 y = (int)(input[2]) << 16;
00338         u = input[1];
00339         v = input[3];
00340 
00341         YUV_TO_RGB(y, u, v, r, g, b)
00342 
00343         (*output)[0] = b;
00344         (*output)[1] = g;
00345         (*output)[2] = r;
00346         (*output) += 4;
00347 }
00348 
00349 
00350 static inline void transfer_YUV422_to_YUV422P(unsigned char *output_y, 
00351         unsigned char *output_u, 
00352         unsigned char *output_v, 
00353         unsigned char *input,
00354         int output_column)
00355 {
00356 // Store U and V for even pixels only
00357         if(!(output_column & 1))
00358         {
00359                 output_y[output_column] = input[0];
00360                 output_u[output_column / 2] = input[1];
00361                 output_v[output_column / 2] = input[3];
00362         }
00363         else
00364 // Store Y and advance output for odd pixels only
00365         {
00366                 output_y[output_column] = input[2];
00367         }
00368 }
00369 
00370 static inline void transfer_YUV422_to_YUV420P(unsigned char *output_y, 
00371         unsigned char *output_u, 
00372         unsigned char *output_v, 
00373         unsigned char *input,
00374         int output_column,
00375         int output_row)
00376 {
00377 // Even column
00378         if(!(output_column & 1))
00379         {
00380                 output_y[output_column] = input[0];
00381 // Store U and V for even columns and even rows only
00382                 if(!(output_row & 1))
00383                 {
00384                         output_u[output_column / 2] = input[1];
00385                         output_v[output_column / 2] = input[3];
00386                 }
00387         }
00388         else
00389 // Odd column
00390         {
00391                 output_y[output_column] = input[2];
00392         }
00393 }
00394 
00395 static inline void transfer_YUV422_to_YUV422(unsigned char *(*output), 
00396         unsigned char *input,
00397         int j)
00398 {
00399 // Store U and V for even pixels only
00400         if(!(j & 1))
00401         {
00402                 (*output)[0] = input[0];
00403                 (*output)[1] = input[1];
00404                 (*output)[3] = input[3];
00405         }
00406         else
00407 // Store Y and advance output for odd pixels only
00408         {
00409                 (*output)[2] = input[2];
00410                 (*output) += 4;
00411         }
00412 }
00413 
00414 
00415 
00416 
00417 
00418 
00419 #define TRANSFER_FRAME_DEFAULT(output, \
00420         input, \
00421         y_in_offset, \
00422         u_in_offset, \
00423         v_in_offset, \
00424         input_column) \
00425 { \
00426         register int i, j; \
00427  \
00428         switch(out_colormodel) \
00429         { \
00430                 case BC_RGB8: \
00431                         TRANSFER_FRAME_HEAD \
00432                         transfer_YUV422_to_RGB8((output), (input), (input_column)); \
00433                         TRANSFER_FRAME_TAIL \
00434                         break; \
00435                 case BC_BGR565: \
00436                 case BC_RGB565: \
00437                         TRANSFER_FRAME_HEAD \
00438                         transfer_YUV422_to_RGB565((output), (input), (input_column)); \
00439                         TRANSFER_FRAME_TAIL \
00440                         break; \
00441                 case BC_RGB888:      \
00442                         TRANSFER_FRAME_HEAD \
00443                         transfer_YUV422_to_RGB888((output), (input), (input_column)); \
00444                         TRANSFER_FRAME_TAIL \
00445                         break; \
00446                 case BC_RGBA8888:      \
00447                         TRANSFER_FRAME_HEAD \
00448                         transfer_YUV422_to_RGBA8888((output), (input), (input_column)); \
00449                         TRANSFER_FRAME_TAIL \
00450                         break; \
00451                 case BC_YUV888:      \
00452                         TRANSFER_FRAME_HEAD \
00453                         transfer_YUV422_to_YUV888((output), (input), (input_column)); \
00454                         TRANSFER_FRAME_TAIL \
00455                         break; \
00456                 case BC_YUVA8888:      \
00457                         TRANSFER_FRAME_HEAD \
00458                         transfer_YUV422_to_YUVA8888((output), (input), (input_column)); \
00459                         TRANSFER_FRAME_TAIL \
00460                         break; \
00461                 case BC_RGB161616:      \
00462                         TRANSFER_FRAME_HEAD \
00463                         transfer_YUV422_to_RGB161616((uint16_t**)(output), (input), (input_column)); \
00464                         TRANSFER_FRAME_TAIL \
00465                         break; \
00466                 case BC_RGBA16161616:      \
00467                         TRANSFER_FRAME_HEAD \
00468                         transfer_YUV422_to_RGBA16161616((uint16_t**)(output), (input), (input_column)); \
00469                         TRANSFER_FRAME_TAIL \
00470                         break; \
00471                 case BC_RGB_FLOAT:      \
00472                         TRANSFER_FRAME_HEAD \
00473                         transfer_YUV422_to_RGB_FLOAT((float**)(output), (input), (input_column)); \
00474                         TRANSFER_FRAME_TAIL \
00475                         break; \
00476                 case BC_RGBA_FLOAT:      \
00477                         TRANSFER_FRAME_HEAD \
00478                         transfer_YUV422_to_RGBA_FLOAT((float**)(output), (input), (input_column)); \
00479                         TRANSFER_FRAME_TAIL \
00480                         break; \
00481                 case BC_YUV161616:      \
00482                         TRANSFER_FRAME_HEAD \
00483                         transfer_YUV422_to_YUV161616((uint16_t**)(output), (input), (input_column)); \
00484                         TRANSFER_FRAME_TAIL \
00485                         break; \
00486                 case BC_YUVA16161616:      \
00487                         TRANSFER_FRAME_HEAD \
00488                         transfer_YUV422_to_YUVA16161616((uint16_t**)(output), (input), (input_column)); \
00489                         TRANSFER_FRAME_TAIL \
00490                         break; \
00491                 case BC_BGR888:      \
00492                         TRANSFER_FRAME_HEAD \
00493                         transfer_YUV422_to_BGR888((output), (input), (input_column)); \
00494                         TRANSFER_FRAME_TAIL \
00495                         break; \
00496                 case BC_BGR8888: \
00497                         TRANSFER_FRAME_HEAD \
00498                         transfer_YUV422_to_BGR8888((output), (input), (input_column)); \
00499                         TRANSFER_FRAME_TAIL \
00500                         break; \
00501                 case BC_YUV422P: \
00502                         TRANSFER_YUV422P_OUT_HEAD \
00503                         transfer_YUV422_to_YUV422P(output_y, \
00504                                 output_u, \
00505                                 output_v, \
00506                                 (input), \
00507                                 j); \
00508                         TRANSFER_FRAME_TAIL \
00509                         break; \
00510                 case BC_YUV422: \
00511                         TRANSFER_FRAME_HEAD \
00512                         transfer_YUV422_to_YUV422((output), \
00513                                 (input), \
00514                                 j); \
00515                         TRANSFER_FRAME_TAIL \
00516                         break; \
00517                 case BC_YUV420P: \
00518                         TRANSFER_YUV420P_OUT_HEAD \
00519                         transfer_YUV422_to_YUV420P(output_y, \
00520                                 output_u, \
00521                                 output_v, \
00522                                 (input), \
00523                                 j, \
00524                                 i); \
00525                         TRANSFER_FRAME_TAIL \
00526                         break; \
00527         } \
00528 }
00529 
00530 void cmodel_yuv422(PERMUTATION_ARGS)
00531 {
00532         if(scale)
00533         {
00534                 TRANSFER_FRAME_DEFAULT(&output_row, 
00535                         input_row + ((column_table[j] * in_pixelsize) & 0xfffffffc),
00536                         0,
00537                         0,
00538                         0,
00539                         column_table[j]);
00540         }
00541         else
00542         {
00543                 TRANSFER_FRAME_DEFAULT(&output_row, 
00544                         input_row + ((j * in_pixelsize) & 0xfffffffc),
00545                         0,
00546                         0,
00547                         0,
00548                         j);
00549         }
00550 }
hvirtual/quicktime/cmodel_yuv422.c
