media/base/yuv_convert.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_BASE_YUV_CONVERT_H_
   6 #define MEDIA_BASE_YUV_CONVERT_H_
   7
   8 #include "base/basictypes.h"
   9 #include "media/base/media_export.h"
  10
  11 // Visual Studio 2010 does not support MMX intrinsics on x64.
  12 // Some win64 yuv_convert code paths use SSE+MMX yasm, so without rewriting
  13 // them, we use yasm EmptyRegisterState_MMX in place of _mm_empty() or
  14 // hide the versions implemented with heavy use of MMX intrinsics.
  15 // TODO(wolenetz): Use MMX intrinsics when compiling win64 with Visual
  16 // Studio 2012? http://crbug.com/173450
  17 #if defined(ARCH_CPU_X86_FAMILY) && \
  18     !(defined(ARCH_CPU_X86_64) && defined(COMPILER_MSVC))
  19 #define MEDIA_MMX_INTRINSICS_AVAILABLE
  20 #endif
  21
  22 namespace media {
  23
  24 // Type of YUV surface.
  25 enum YUVType {
  26   YV16 = 0,    // YV16 is half width and full height chroma channels.
  27   YV12 = 1,    // YV12 is half width and half height chroma channels.
  28   YV12J = 2,   // YV12J is the same as YV12, but in JPEG color range.
  29   YV12HD = 3,  // YV12HD is the same as YV12, but in 'HD' Rec709 color space.
  30 };
  31
  32 // Get the appropriate value to bitshift by for vertical indices.
  33 MEDIA_EXPORT int GetVerticalShift(YUVType type);
  34
  35 // Get the appropriate lookup table for a given YUV format.
  36 MEDIA_EXPORT const int16* GetLookupTable(YUVType type);
  37
  38 // Mirror means flip the image horizontally, as in looking in a mirror.
  39 // Rotate happens after mirroring.
  40 enum Rotate {
  41   ROTATE_0,           // Rotation off.
  42   ROTATE_90,          // Rotate clockwise.
  43   ROTATE_180,         // Rotate upside down.
  44   ROTATE_270,         // Rotate counter clockwise.
  45   MIRROR_ROTATE_0,    // Mirror horizontally.
  46   MIRROR_ROTATE_90,   // Mirror then Rotate clockwise.
  47   MIRROR_ROTATE_180,  // Mirror vertically.
  48   MIRROR_ROTATE_270,  // Transpose.
  49 };
  50
  51 // Filter affects how scaling looks.
  52 enum ScaleFilter {
  53   FILTER_NONE = 0,        // No filter (point sampled).
  54   FILTER_BILINEAR_H = 1,  // Bilinear horizontal filter.
  55   FILTER_BILINEAR_V = 2,  // Bilinear vertical filter.
  56   FILTER_BILINEAR = 3,    // Bilinear filter.
  57 };
  58
  59 MEDIA_EXPORT void InitializeCPUSpecificYUVConversions();
  60
  61 // Convert a frame of YUV to 32 bit ARGB.
  62 // Pass in YV16/YV12 depending on source format
  63 MEDIA_EXPORT void ConvertYUVToRGB32(const uint8* yplane,
  64                                     const uint8* uplane,
  65                                     const uint8* vplane,
  66                                     uint8* rgbframe,
  67                                     int width,
  68                                     int height,
  69                                     int ystride,
  70                                     int uvstride,
  71                                     int rgbstride,
  72                                     YUVType yuv_type);
  73
  74 // Convert a frame of YUVA to 32 bit ARGB.
  75 // Pass in YV12A
  76 MEDIA_EXPORT void ConvertYUVAToARGB(const uint8* yplane,
  77                                     const uint8* uplane,
  78                                     const uint8* vplane,
  79                                     const uint8* aplane,
  80                                     uint8* rgbframe,
  81                                     int width,
  82                                     int height,
  83                                     int ystride,
  84                                     int uvstride,
  85                                     int astride,
  86                                     int rgbstride,
  87                                     YUVType yuv_type);
  88
  89 // Scale a frame of YUV to 32 bit ARGB.
  90 // Supports rotation and mirroring.
  91 MEDIA_EXPORT void ScaleYUVToRGB32(const uint8* yplane,
  92                                   const uint8* uplane,
  93                                   const uint8* vplane,
  94                                   uint8* rgbframe,
  95                                   int source_width,
  96                                   int source_height,
  97                                   int width,
  98                                   int height,
  99                                   int ystride,
 100                                   int uvstride,
 101                                   int rgbstride,
 102                                   YUVType yuv_type,
 103                                   Rotate view_rotate,
 104                                   ScaleFilter filter);
 105
 106 // Biliner Scale a frame of YV12 to 32 bits ARGB on a specified rectangle.
 107 // |yplane|, etc and |rgbframe| should point to the top-left pixels of the
 108 // source and destination buffers.
 109 MEDIA_EXPORT void ScaleYUVToRGB32WithRect(const uint8* yplane,
 110                                           const uint8* uplane,
 111                                           const uint8* vplane,
 112                                           uint8* rgbframe,
 113                                           int source_width,
 114                                           int source_height,
 115                                           int dest_width,
 116                                           int dest_height,
 117                                           int dest_rect_left,
 118                                           int dest_rect_top,
 119                                           int dest_rect_right,
 120                                           int dest_rect_bottom,
 121                                           int ystride,
 122                                           int uvstride,
 123                                           int rgbstride);
 124
 125 MEDIA_EXPORT void ConvertRGB32ToYUV(const uint8* rgbframe,
 126                                     uint8* yplane,
 127                                     uint8* uplane,
 128                                     uint8* vplane,
 129                                     int width,
 130                                     int height,
 131                                     int rgbstride,
 132                                     int ystride,
 133                                     int uvstride);
 134
 135 MEDIA_EXPORT void ConvertRGB24ToYUV(const uint8* rgbframe,
 136                                     uint8* yplane,
 137                                     uint8* uplane,
 138                                     uint8* vplane,
 139                                     int width,
 140                                     int height,
 141                                     int rgbstride,
 142                                     int ystride,
 143                                     int uvstride);
 144
 145 MEDIA_EXPORT void ConvertYUY2ToYUV(const uint8* src,
 146                                    uint8* yplane,
 147                                    uint8* uplane,
 148                                    uint8* vplane,
 149                                    int width,
 150                                    int height);
 151
 152 MEDIA_EXPORT void ConvertNV21ToYUV(const uint8* src,
 153                                    uint8* yplane,
 154                                    uint8* uplane,
 155                                    uint8* vplane,
 156                                    int width,
 157                                    int height);
 158
 159 // Empty SIMD register state after calling optimized scaler functions.
 160 MEDIA_EXPORT void EmptyRegisterState();
 161
 162 }  // namespace media
 163
 164 #endif  // MEDIA_BASE_YUV_CONVERT_H_