yuv.c revision af51b94a435132e9014c324e25fb686b3d07a8c8 
1// Copyright 2010 Google Inc. All Rights Reserved.
2//
3// Use of this source code is governed by a BSD-style license
4// that can be found in the COPYING file in the root of the source
5// tree. An additional intellectual property rights grant can be found
6// in the file PATENTS. All contributing project authors may
7// be found in the AUTHORS file in the root of the source tree.
8// -----------------------------------------------------------------------------
9//
10// YUV->RGB conversion functions
11//
12// Author: Skal (pascal.massimino@gmail.com)
13
14#include "./yuv.h"
15
16#if defined(WEBP_YUV_USE_TABLE)
17
18static int done = 0;
19
20static WEBP_INLINE uint8_t clip(int v, int max_value) {
21  return v < 0 ? 0 : v > max_value ? max_value : v;
22}
23
24int16_t VP8kVToR[256], VP8kUToB[256];
25int32_t VP8kVToG[256], VP8kUToG[256];
26uint8_t VP8kClip[YUV_RANGE_MAX - YUV_RANGE_MIN];
27uint8_t VP8kClip4Bits[YUV_RANGE_MAX - YUV_RANGE_MIN];
28
29void VP8YUVInit(void) {
30  int i;
31  if (done) {
32    return;
33  }
34#ifndef USE_YUVj
35  for (i = 0; i < 256; ++i) {
36    VP8kVToR[i] = (89858 * (i - 128) + YUV_HALF) >> YUV_FIX;
37    VP8kUToG[i] = -22014 * (i - 128) + YUV_HALF;
38    VP8kVToG[i] = -45773 * (i - 128);
39    VP8kUToB[i] = (113618 * (i - 128) + YUV_HALF) >> YUV_FIX;
40  }
41  for (i = YUV_RANGE_MIN; i < YUV_RANGE_MAX; ++i) {
42    const int k = ((i - 16) * 76283 + YUV_HALF) >> YUV_FIX;
43    VP8kClip[i - YUV_RANGE_MIN] = clip(k, 255);
44    VP8kClip4Bits[i - YUV_RANGE_MIN] = clip((k + 8) >> 4, 15);
45  }
46#else
47  for (i = 0; i < 256; ++i) {
48    VP8kVToR[i] = (91881 * (i - 128) + YUV_HALF) >> YUV_FIX;
49    VP8kUToG[i] = -22554 * (i - 128) + YUV_HALF;
50    VP8kVToG[i] = -46802 * (i - 128);
51    VP8kUToB[i] = (116130 * (i - 128) + YUV_HALF) >> YUV_FIX;
52  }
53  for (i = YUV_RANGE_MIN; i < YUV_RANGE_MAX; ++i) {
54    const int k = i;
55    VP8kClip[i - YUV_RANGE_MIN] = clip(k, 255);
56    VP8kClip4Bits[i - YUV_RANGE_MIN] = clip((k + 8) >> 4, 15);
57  }
58#endif
59
60  done = 1;
61}
62
63#else
64
65void VP8YUVInit(void) {}
66
67#endif  // WEBP_YUV_USE_TABLE
68
69//-----------------------------------------------------------------------------
70// Plain-C version
71
72#define ROW_FUNC(FUNC_NAME, FUNC, XSTEP)                                       \
73static void FUNC_NAME(const uint8_t* y,                                        \
74                      const uint8_t* u, const uint8_t* v,                      \
75                      uint8_t* dst, int len) {                                 \
76  const uint8_t* const end = dst + (len & ~1) * XSTEP;                         \
77  while (dst != end) {                                                         \
78    FUNC(y[0], u[0], v[0], dst);                                               \
79    FUNC(y[1], u[0], v[0], dst + XSTEP);                                       \
80    y += 2;                                                                    \
81    ++u;                                                                       \
82    ++v;                                                                       \
83    dst += 2 * XSTEP;                                                          \
84  }                                                                            \
85  if (len & 1) {                                                               \
86    FUNC(y[0], u[0], v[0], dst);                                               \
87  }                                                                            \
88}                                                                              \
89
90// All variants implemented.
91ROW_FUNC(YuvToRgbRow,      VP8YuvToRgb,  3)
92ROW_FUNC(YuvToBgrRow,      VP8YuvToBgr,  3)
93ROW_FUNC(YuvToRgbaRow,     VP8YuvToRgba, 4)
94ROW_FUNC(YuvToBgraRow,     VP8YuvToBgra, 4)
95ROW_FUNC(YuvToArgbRow,     VP8YuvToArgb, 4)
96ROW_FUNC(YuvToRgba4444Row, VP8YuvToRgba4444, 2)
97ROW_FUNC(YuvToRgb565Row,   VP8YuvToRgb565, 2)
98
99#undef ROW_FUNC
100
101// Main call for processing a plane with a WebPSamplerRowFunc function:
102void WebPSamplerProcessPlane(const uint8_t* y, int y_stride,
103                             const uint8_t* u, const uint8_t* v, int uv_stride,
104                             uint8_t* dst, int dst_stride,
105                             int width, int height, WebPSamplerRowFunc func) {
106  int j;
107  for (j = 0; j < height; ++j) {
108    func(y, u, v, dst, width);
109    y += y_stride;
110    if (j & 1) {
111      u += uv_stride;
112      v += uv_stride;
113    }
114    dst += dst_stride;
115  }
116}
117
118//-----------------------------------------------------------------------------
119// Main call
120
121WebPSamplerRowFunc WebPSamplers[MODE_LAST];
122
123extern void WebPInitSamplersSSE2(void);
124extern void WebPInitSamplersMIPS32(void);
125
126void WebPInitSamplers(void) {
127  WebPSamplers[MODE_RGB]       = YuvToRgbRow;
128  WebPSamplers[MODE_RGBA]      = YuvToRgbaRow;
129  WebPSamplers[MODE_BGR]       = YuvToBgrRow;
130  WebPSamplers[MODE_BGRA]      = YuvToBgraRow;
131  WebPSamplers[MODE_ARGB]      = YuvToArgbRow;
132  WebPSamplers[MODE_RGBA_4444] = YuvToRgba4444Row;
133  WebPSamplers[MODE_RGB_565]   = YuvToRgb565Row;
134  WebPSamplers[MODE_rgbA]      = YuvToRgbaRow;
135  WebPSamplers[MODE_bgrA]      = YuvToBgraRow;
136  WebPSamplers[MODE_Argb]      = YuvToArgbRow;
137  WebPSamplers[MODE_rgbA_4444] = YuvToRgba4444Row;
138
139  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
140  if (VP8GetCPUInfo != NULL) {
141#if defined(WEBP_USE_SSE2)
142    if (VP8GetCPUInfo(kSSE2)) {
143      WebPInitSamplersSSE2();
144    }
145#endif  // WEBP_USE_SSE2
146#if defined(WEBP_USE_MIPS32)
147    if (VP8GetCPUInfo(kMIPS32)) {
148      WebPInitSamplersMIPS32();
149    }
150#endif  // WEBP_USE_MIPS32
151  }
152}
153
154//-----------------------------------------------------------------------------
155