Home | History | Annotate | Download | only in camera
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*
     18  * Contains implemenation of framebuffer conversion routines.
     19  */
     20 
     21 #define LOG_NDEBUG 0
     22 #define LOG_TAG "EmulatedCamera_Converter"
     23 #include <cutils/log.h>
     24 #include "Converters.h"
     25 
     26 namespace android {
     27 
     28 static void _YUV420SToRGB565(const uint8_t* Y,
     29                              const uint8_t* U,
     30                              const uint8_t* V,
     31                              int dUV,
     32                              uint16_t* rgb,
     33                              int width,
     34                              int height)
     35 {
     36     const uint8_t* U_pos = U;
     37     const uint8_t* V_pos = V;
     38 
     39     for (int y = 0; y < height; y++) {
     40         for (int x = 0; x < width; x += 2, U += dUV, V += dUV) {
     41             const uint8_t nU = *U;
     42             const uint8_t nV = *V;
     43             *rgb = YUVToRGB565(*Y, nU, nV);
     44             Y++; rgb++;
     45             *rgb = YUVToRGB565(*Y, nU, nV);
     46             Y++; rgb++;
     47         }
     48         if (y & 0x1) {
     49             U_pos = U;
     50             V_pos = V;
     51         } else {
     52             U = U_pos;
     53             V = V_pos;
     54         }
     55     }
     56 }
     57 
     58 static void _YUV420SToRGB32(const uint8_t* Y,
     59                             const uint8_t* U,
     60                             const uint8_t* V,
     61                             int dUV,
     62                             uint32_t* rgb,
     63                             int width,
     64                             int height)
     65 {
     66     const uint8_t* U_pos = U;
     67     const uint8_t* V_pos = V;
     68 
     69     for (int y = 0; y < height; y++) {
     70         for (int x = 0; x < width; x += 2, U += dUV, V += dUV) {
     71             const uint8_t nU = *U;
     72             const uint8_t nV = *V;
     73             *rgb = YUVToRGB32(*Y, nU, nV);
     74             Y++; rgb++;
     75             *rgb = YUVToRGB32(*Y, nU, nV);
     76             Y++; rgb++;
     77         }
     78         if (y & 0x1) {
     79             U_pos = U;
     80             V_pos = V;
     81         } else {
     82             U = U_pos;
     83             V = V_pos;
     84         }
     85     }
     86 }
     87 
     88 void YV12ToRGB565(const void* yv12, void* rgb, int width, int height)
     89 {
     90     const int pix_total = width * height;
     91     const uint8_t* Y = reinterpret_cast<const uint8_t*>(yv12);
     92     const uint8_t* U = Y + pix_total;
     93     const uint8_t* V = U + pix_total / 4;
     94     _YUV420SToRGB565(Y, U, V, 1, reinterpret_cast<uint16_t*>(rgb), width, height);
     95 }
     96 
     97 void YV12ToRGB32(const void* yv12, void* rgb, int width, int height)
     98 {
     99     const int pix_total = width * height;
    100     const uint8_t* Y = reinterpret_cast<const uint8_t*>(yv12);
    101     const uint8_t* V = Y + pix_total;
    102     const uint8_t* U = V + pix_total / 4;
    103     _YUV420SToRGB32(Y, U, V, 1, reinterpret_cast<uint32_t*>(rgb), width, height);
    104 }
    105 
    106 void YU12ToRGB32(const void* yu12, void* rgb, int width, int height)
    107 {
    108     const int pix_total = width * height;
    109     const uint8_t* Y = reinterpret_cast<const uint8_t*>(yu12);
    110     const uint8_t* U = Y + pix_total;
    111     const uint8_t* V = U + pix_total / 4;
    112     _YUV420SToRGB32(Y, U, V, 1, reinterpret_cast<uint32_t*>(rgb), width, height);
    113 }
    114 
    115 /* Common converter for YUV 4:2:0 interleaved to RGB565.
    116  * y, u, and v point to Y,U, and V panes, where U and V values are interleaved.
    117  */
    118 static void _NVXXToRGB565(const uint8_t* Y,
    119                           const uint8_t* U,
    120                           const uint8_t* V,
    121                           uint16_t* rgb,
    122                           int width,
    123                           int height)
    124 {
    125     _YUV420SToRGB565(Y, U, V, 2, rgb, width, height);
    126 }
    127 
    128 /* Common converter for YUV 4:2:0 interleaved to RGB32.
    129  * y, u, and v point to Y,U, and V panes, where U and V values are interleaved.
    130  */
    131 static void _NVXXToRGB32(const uint8_t* Y,
    132                          const uint8_t* U,
    133                          const uint8_t* V,
    134                          uint32_t* rgb,
    135                          int width,
    136                          int height)
    137 {
    138     _YUV420SToRGB32(Y, U, V, 2, rgb, width, height);
    139 }
    140 
    141 void NV12ToRGB565(const void* nv12, void* rgb, int width, int height)
    142 {
    143     const int pix_total = width * height;
    144     const uint8_t* y = reinterpret_cast<const uint8_t*>(nv12);
    145     _NVXXToRGB565(y, y + pix_total, y + pix_total + 1,
    146                   reinterpret_cast<uint16_t*>(rgb), width, height);
    147 }
    148 
    149 void NV12ToRGB32(const void* nv12, void* rgb, int width, int height)
    150 {
    151     const int pix_total = width * height;
    152     const uint8_t* y = reinterpret_cast<const uint8_t*>(nv12);
    153     _NVXXToRGB32(y, y + pix_total, y + pix_total + 1,
    154                  reinterpret_cast<uint32_t*>(rgb), width, height);
    155 }
    156 
    157 void NV21ToRGB565(const void* nv21, void* rgb, int width, int height)
    158 {
    159     const int pix_total = width * height;
    160     const uint8_t* y = reinterpret_cast<const uint8_t*>(nv21);
    161     _NVXXToRGB565(y, y + pix_total + 1, y + pix_total,
    162                   reinterpret_cast<uint16_t*>(rgb), width, height);
    163 }
    164 
    165 void NV21ToRGB32(const void* nv21, void* rgb, int width, int height)
    166 {
    167     const int pix_total = width * height;
    168     const uint8_t* y = reinterpret_cast<const uint8_t*>(nv21);
    169     _NVXXToRGB32(y, y + pix_total + 1, y + pix_total,
    170                  reinterpret_cast<uint32_t*>(rgb), width, height);
    171 }
    172 
    173 }; /* namespace android */
    174