OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 #include <stddef.h> |
| 6 #include <stdint.h> |
| 7 |
| 8 #include "build/build_config.h" |
5 #include "media/base/simd/convert_yuv_to_rgb.h" | 9 #include "media/base/simd/convert_yuv_to_rgb.h" |
6 | 10 |
7 namespace media { | 11 namespace media { |
8 | 12 |
9 #define packuswb(x) ((x) < 0 ? 0 : ((x) > 255 ? 255 : (x))) | 13 #define packuswb(x) ((x) < 0 ? 0 : ((x) > 255 ? 255 : (x))) |
10 #define paddsw(x, y) (((x) + (y)) < -32768 ? -32768 : \ | 14 #define paddsw(x, y) (((x) + (y)) < -32768 ? -32768 : \ |
11 (((x) + (y)) > 32767 ? 32767 : ((x) + (y)))) | 15 (((x) + (y)) > 32767 ? 32767 : ((x) + (y)))) |
12 | 16 |
13 // On Android, pixel layout is RGBA (see skia/include/core/SkColorPriv.h); | 17 // On Android, pixel layout is RGBA (see skia/include/core/SkColorPriv.h); |
14 // however, other Chrome platforms use BGRA (see skia/config/SkUserConfig.h). | 18 // however, other Chrome platforms use BGRA (see skia/config/SkUserConfig.h). |
(...skipping 12 matching lines...) Expand all Loading... |
27 #define SK_B32_SHIFT 0 | 31 #define SK_B32_SHIFT 0 |
28 #define SK_G32_SHIFT 8 | 32 #define SK_G32_SHIFT 8 |
29 #define SK_R32_SHIFT 16 | 33 #define SK_R32_SHIFT 16 |
30 #define SK_A32_SHIFT 24 | 34 #define SK_A32_SHIFT 24 |
31 #define B_INDEX 0 | 35 #define B_INDEX 0 |
32 #define G_INDEX 1 | 36 #define G_INDEX 1 |
33 #define R_INDEX 2 | 37 #define R_INDEX 2 |
34 #define A_INDEX 3 | 38 #define A_INDEX 3 |
35 #endif | 39 #endif |
36 | 40 |
37 static inline void ConvertYUVToRGB32_C(uint8 y, | 41 static inline void ConvertYUVToRGB32_C(uint8_t y, |
38 uint8 u, | 42 uint8_t u, |
39 uint8 v, | 43 uint8_t v, |
40 uint8* rgb_buf, | 44 uint8_t* rgb_buf, |
41 const int16* convert_table) { | 45 const int16_t* convert_table) { |
42 int b = convert_table[4 * (256 + u) + B_INDEX]; | 46 int b = convert_table[4 * (256 + u) + B_INDEX]; |
43 int g = convert_table[4 * (256 + u) + G_INDEX]; | 47 int g = convert_table[4 * (256 + u) + G_INDEX]; |
44 int r = convert_table[4 * (256 + u) + R_INDEX]; | 48 int r = convert_table[4 * (256 + u) + R_INDEX]; |
45 int a = convert_table[4 * (256 + u) + A_INDEX]; | 49 int a = convert_table[4 * (256 + u) + A_INDEX]; |
46 | 50 |
47 b = paddsw(b, convert_table[4 * (512 + v) + B_INDEX]); | 51 b = paddsw(b, convert_table[4 * (512 + v) + B_INDEX]); |
48 g = paddsw(g, convert_table[4 * (512 + v) + G_INDEX]); | 52 g = paddsw(g, convert_table[4 * (512 + v) + G_INDEX]); |
49 r = paddsw(r, convert_table[4 * (512 + v) + R_INDEX]); | 53 r = paddsw(r, convert_table[4 * (512 + v) + R_INDEX]); |
50 a = paddsw(a, convert_table[4 * (512 + v) + A_INDEX]); | 54 a = paddsw(a, convert_table[4 * (512 + v) + A_INDEX]); |
51 | 55 |
52 b = paddsw(b, convert_table[4 * y + B_INDEX]); | 56 b = paddsw(b, convert_table[4 * y + B_INDEX]); |
53 g = paddsw(g, convert_table[4 * y + G_INDEX]); | 57 g = paddsw(g, convert_table[4 * y + G_INDEX]); |
54 r = paddsw(r, convert_table[4 * y + R_INDEX]); | 58 r = paddsw(r, convert_table[4 * y + R_INDEX]); |
55 a = paddsw(a, convert_table[4 * y + A_INDEX]); | 59 a = paddsw(a, convert_table[4 * y + A_INDEX]); |
56 | 60 |
57 b >>= 6; | 61 b >>= 6; |
58 g >>= 6; | 62 g >>= 6; |
59 r >>= 6; | 63 r >>= 6; |
60 a >>= 6; | 64 a >>= 6; |
61 | 65 |
62 *reinterpret_cast<uint32*>(rgb_buf) = (packuswb(b) << SK_B32_SHIFT) | | 66 *reinterpret_cast<uint32_t*>(rgb_buf) = |
63 (packuswb(g) << SK_G32_SHIFT) | | 67 (packuswb(b) << SK_B32_SHIFT) | (packuswb(g) << SK_G32_SHIFT) | |
64 (packuswb(r) << SK_R32_SHIFT) | | 68 (packuswb(r) << SK_R32_SHIFT) | (packuswb(a) << SK_A32_SHIFT); |
65 (packuswb(a) << SK_A32_SHIFT); | |
66 } | 69 } |
67 | 70 |
68 static inline void ConvertYUVAToARGB_C(uint8 y, | 71 static inline void ConvertYUVAToARGB_C(uint8_t y, |
69 uint8 u, | 72 uint8_t u, |
70 uint8 v, | 73 uint8_t v, |
71 uint8 a, | 74 uint8_t a, |
72 uint8* rgb_buf, | 75 uint8_t* rgb_buf, |
73 const int16* convert_table) { | 76 const int16_t* convert_table) { |
74 int b = convert_table[4 * (256 + u) + 0]; | 77 int b = convert_table[4 * (256 + u) + 0]; |
75 int g = convert_table[4 * (256 + u) + 1]; | 78 int g = convert_table[4 * (256 + u) + 1]; |
76 int r = convert_table[4 * (256 + u) + 2]; | 79 int r = convert_table[4 * (256 + u) + 2]; |
77 | 80 |
78 b = paddsw(b, convert_table[4 * (512 + v) + 0]); | 81 b = paddsw(b, convert_table[4 * (512 + v) + 0]); |
79 g = paddsw(g, convert_table[4 * (512 + v) + 1]); | 82 g = paddsw(g, convert_table[4 * (512 + v) + 1]); |
80 r = paddsw(r, convert_table[4 * (512 + v) + 2]); | 83 r = paddsw(r, convert_table[4 * (512 + v) + 2]); |
81 | 84 |
82 b = paddsw(b, convert_table[4 * y + 0]); | 85 b = paddsw(b, convert_table[4 * y + 0]); |
83 g = paddsw(g, convert_table[4 * y + 1]); | 86 g = paddsw(g, convert_table[4 * y + 1]); |
84 r = paddsw(r, convert_table[4 * y + 2]); | 87 r = paddsw(r, convert_table[4 * y + 2]); |
85 | 88 |
86 b >>= 6; | 89 b >>= 6; |
87 g >>= 6; | 90 g >>= 6; |
88 r >>= 6; | 91 r >>= 6; |
89 | 92 |
90 b = packuswb(b) * a >> 8; | 93 b = packuswb(b) * a >> 8; |
91 g = packuswb(g) * a >> 8; | 94 g = packuswb(g) * a >> 8; |
92 r = packuswb(r) * a >> 8; | 95 r = packuswb(r) * a >> 8; |
93 | 96 |
94 *reinterpret_cast<uint32*>(rgb_buf) = (b << SK_B32_SHIFT) | | 97 *reinterpret_cast<uint32_t*>(rgb_buf) = |
95 (g << SK_G32_SHIFT) | | 98 (b << SK_B32_SHIFT) | (g << SK_G32_SHIFT) | (r << SK_R32_SHIFT) | |
96 (r << SK_R32_SHIFT) | | 99 (a << SK_A32_SHIFT); |
97 (a << SK_A32_SHIFT); | |
98 } | 100 } |
99 | 101 |
100 void ConvertYUVToRGB32Row_C(const uint8* y_buf, | 102 void ConvertYUVToRGB32Row_C(const uint8_t* y_buf, |
101 const uint8* u_buf, | 103 const uint8_t* u_buf, |
102 const uint8* v_buf, | 104 const uint8_t* v_buf, |
103 uint8* rgb_buf, | 105 uint8_t* rgb_buf, |
104 ptrdiff_t width, | 106 ptrdiff_t width, |
105 const int16* convert_table) { | 107 const int16_t* convert_table) { |
106 for (int x = 0; x < width; x += 2) { | 108 for (int x = 0; x < width; x += 2) { |
107 uint8 u = u_buf[x >> 1]; | 109 uint8_t u = u_buf[x >> 1]; |
108 uint8 v = v_buf[x >> 1]; | 110 uint8_t v = v_buf[x >> 1]; |
109 uint8 y0 = y_buf[x]; | 111 uint8_t y0 = y_buf[x]; |
110 ConvertYUVToRGB32_C(y0, u, v, rgb_buf, convert_table); | 112 ConvertYUVToRGB32_C(y0, u, v, rgb_buf, convert_table); |
111 if ((x + 1) < width) { | 113 if ((x + 1) < width) { |
112 uint8 y1 = y_buf[x + 1]; | 114 uint8_t y1 = y_buf[x + 1]; |
113 ConvertYUVToRGB32_C(y1, u, v, rgb_buf + 4, convert_table); | 115 ConvertYUVToRGB32_C(y1, u, v, rgb_buf + 4, convert_table); |
114 } | 116 } |
115 rgb_buf += 8; // Advance 2 pixels. | 117 rgb_buf += 8; // Advance 2 pixels. |
116 } | 118 } |
117 } | 119 } |
118 | 120 |
119 void ConvertYUVAToARGBRow_C(const uint8* y_buf, | 121 void ConvertYUVAToARGBRow_C(const uint8_t* y_buf, |
120 const uint8* u_buf, | 122 const uint8_t* u_buf, |
121 const uint8* v_buf, | 123 const uint8_t* v_buf, |
122 const uint8* a_buf, | 124 const uint8_t* a_buf, |
123 uint8* rgba_buf, | 125 uint8_t* rgba_buf, |
124 ptrdiff_t width, | 126 ptrdiff_t width, |
125 const int16* convert_table) { | 127 const int16_t* convert_table) { |
126 for (int x = 0; x < width; x += 2) { | 128 for (int x = 0; x < width; x += 2) { |
127 uint8 u = u_buf[x >> 1]; | 129 uint8_t u = u_buf[x >> 1]; |
128 uint8 v = v_buf[x >> 1]; | 130 uint8_t v = v_buf[x >> 1]; |
129 uint8 y0 = y_buf[x]; | 131 uint8_t y0 = y_buf[x]; |
130 uint8 a0 = a_buf[x]; | 132 uint8_t a0 = a_buf[x]; |
131 ConvertYUVAToARGB_C(y0, u, v, a0, rgba_buf, convert_table); | 133 ConvertYUVAToARGB_C(y0, u, v, a0, rgba_buf, convert_table); |
132 if ((x + 1) < width) { | 134 if ((x + 1) < width) { |
133 uint8 y1 = y_buf[x + 1]; | 135 uint8_t y1 = y_buf[x + 1]; |
134 uint8 a1 = a_buf[x + 1]; | 136 uint8_t a1 = a_buf[x + 1]; |
135 ConvertYUVAToARGB_C(y1, u, v, a1, rgba_buf + 4, convert_table); | 137 ConvertYUVAToARGB_C(y1, u, v, a1, rgba_buf + 4, convert_table); |
136 } | 138 } |
137 rgba_buf += 8; // Advance 2 pixels. | 139 rgba_buf += 8; // Advance 2 pixels. |
138 } | 140 } |
139 } | 141 } |
140 | 142 |
141 // 16.16 fixed point is used. A shift by 16 isolates the integer. | 143 // 16.16 fixed point is used. A shift by 16 isolates the integer. |
142 // A shift by 17 is used to further subsample the chrominence channels. | 144 // A shift by 17 is used to further subsample the chrominence channels. |
143 // & 0xffff isolates the fixed point fraction. >> 2 to get the upper 2 bits, | 145 // & 0xffff isolates the fixed point fraction. >> 2 to get the upper 2 bits, |
144 // for 1/65536 pixel accurate interpolation. | 146 // for 1/65536 pixel accurate interpolation. |
145 void ScaleYUVToRGB32Row_C(const uint8* y_buf, | 147 void ScaleYUVToRGB32Row_C(const uint8_t* y_buf, |
146 const uint8* u_buf, | 148 const uint8_t* u_buf, |
147 const uint8* v_buf, | 149 const uint8_t* v_buf, |
148 uint8* rgb_buf, | 150 uint8_t* rgb_buf, |
149 ptrdiff_t width, | 151 ptrdiff_t width, |
150 ptrdiff_t source_dx, | 152 ptrdiff_t source_dx, |
151 const int16* convert_table) { | 153 const int16_t* convert_table) { |
152 int x = 0; | 154 int x = 0; |
153 for (int i = 0; i < width; i += 2) { | 155 for (int i = 0; i < width; i += 2) { |
154 int y = y_buf[x >> 16]; | 156 int y = y_buf[x >> 16]; |
155 int u = u_buf[(x >> 17)]; | 157 int u = u_buf[(x >> 17)]; |
156 int v = v_buf[(x >> 17)]; | 158 int v = v_buf[(x >> 17)]; |
157 ConvertYUVToRGB32_C(y, u, v, rgb_buf, convert_table); | 159 ConvertYUVToRGB32_C(y, u, v, rgb_buf, convert_table); |
158 x += source_dx; | 160 x += source_dx; |
159 if ((i + 1) < width) { | 161 if ((i + 1) < width) { |
160 y = y_buf[x >> 16]; | 162 y = y_buf[x >> 16]; |
161 ConvertYUVToRGB32_C(y, u, v, rgb_buf+4, convert_table); | 163 ConvertYUVToRGB32_C(y, u, v, rgb_buf+4, convert_table); |
162 x += source_dx; | 164 x += source_dx; |
163 } | 165 } |
164 rgb_buf += 8; | 166 rgb_buf += 8; |
165 } | 167 } |
166 } | 168 } |
167 | 169 |
168 void LinearScaleYUVToRGB32Row_C(const uint8* y_buf, | 170 void LinearScaleYUVToRGB32Row_C(const uint8_t* y_buf, |
169 const uint8* u_buf, | 171 const uint8_t* u_buf, |
170 const uint8* v_buf, | 172 const uint8_t* v_buf, |
171 uint8* rgb_buf, | 173 uint8_t* rgb_buf, |
172 ptrdiff_t width, | 174 ptrdiff_t width, |
173 ptrdiff_t source_dx, | 175 ptrdiff_t source_dx, |
174 const int16* convert_table) { | 176 const int16_t* convert_table) { |
175 // Avoid point-sampling for down-scaling by > 2:1. | 177 // Avoid point-sampling for down-scaling by > 2:1. |
176 int source_x = 0; | 178 int source_x = 0; |
177 if (source_dx >= 0x20000) | 179 if (source_dx >= 0x20000) |
178 source_x += 0x8000; | 180 source_x += 0x8000; |
179 LinearScaleYUVToRGB32RowWithRange_C(y_buf, u_buf, v_buf, rgb_buf, width, | 181 LinearScaleYUVToRGB32RowWithRange_C(y_buf, u_buf, v_buf, rgb_buf, width, |
180 source_x, source_dx, convert_table); | 182 source_x, source_dx, convert_table); |
181 } | 183 } |
182 | 184 |
183 void LinearScaleYUVToRGB32RowWithRange_C(const uint8* y_buf, | 185 void LinearScaleYUVToRGB32RowWithRange_C(const uint8_t* y_buf, |
184 const uint8* u_buf, | 186 const uint8_t* u_buf, |
185 const uint8* v_buf, | 187 const uint8_t* v_buf, |
186 uint8* rgb_buf, | 188 uint8_t* rgb_buf, |
187 int dest_width, | 189 int dest_width, |
188 int x, | 190 int x, |
189 int source_dx, | 191 int source_dx, |
190 const int16* convert_table) { | 192 const int16_t* convert_table) { |
191 for (int i = 0; i < dest_width; i += 2) { | 193 for (int i = 0; i < dest_width; i += 2) { |
192 int y0 = y_buf[x >> 16]; | 194 int y0 = y_buf[x >> 16]; |
193 int y1 = y_buf[(x >> 16) + 1]; | 195 int y1 = y_buf[(x >> 16) + 1]; |
194 int u0 = u_buf[(x >> 17)]; | 196 int u0 = u_buf[(x >> 17)]; |
195 int u1 = u_buf[(x >> 17) + 1]; | 197 int u1 = u_buf[(x >> 17) + 1]; |
196 int v0 = v_buf[(x >> 17)]; | 198 int v0 = v_buf[(x >> 17)]; |
197 int v1 = v_buf[(x >> 17) + 1]; | 199 int v1 = v_buf[(x >> 17) + 1]; |
198 int y_frac = (x & 65535); | 200 int y_frac = (x & 65535); |
199 int uv_frac = ((x >> 1) & 65535); | 201 int uv_frac = ((x >> 1) & 65535); |
200 int y = (y_frac * y1 + (y_frac ^ 65535) * y0) >> 16; | 202 int y = (y_frac * y1 + (y_frac ^ 65535) * y0) >> 16; |
201 int u = (uv_frac * u1 + (uv_frac ^ 65535) * u0) >> 16; | 203 int u = (uv_frac * u1 + (uv_frac ^ 65535) * u0) >> 16; |
202 int v = (uv_frac * v1 + (uv_frac ^ 65535) * v0) >> 16; | 204 int v = (uv_frac * v1 + (uv_frac ^ 65535) * v0) >> 16; |
203 ConvertYUVToRGB32_C(y, u, v, rgb_buf, convert_table); | 205 ConvertYUVToRGB32_C(y, u, v, rgb_buf, convert_table); |
204 x += source_dx; | 206 x += source_dx; |
205 if ((i + 1) < dest_width) { | 207 if ((i + 1) < dest_width) { |
206 y0 = y_buf[x >> 16]; | 208 y0 = y_buf[x >> 16]; |
207 y1 = y_buf[(x >> 16) + 1]; | 209 y1 = y_buf[(x >> 16) + 1]; |
208 y_frac = (x & 65535); | 210 y_frac = (x & 65535); |
209 y = (y_frac * y1 + (y_frac ^ 65535) * y0) >> 16; | 211 y = (y_frac * y1 + (y_frac ^ 65535) * y0) >> 16; |
210 ConvertYUVToRGB32_C(y, u, v, rgb_buf+4, convert_table); | 212 ConvertYUVToRGB32_C(y, u, v, rgb_buf+4, convert_table); |
211 x += source_dx; | 213 x += source_dx; |
212 } | 214 } |
213 rgb_buf += 8; | 215 rgb_buf += 8; |
214 } | 216 } |
215 } | 217 } |
216 | 218 |
217 void ConvertYUVToRGB32_C(const uint8* yplane, | 219 void ConvertYUVToRGB32_C(const uint8_t* yplane, |
218 const uint8* uplane, | 220 const uint8_t* uplane, |
219 const uint8* vplane, | 221 const uint8_t* vplane, |
220 uint8* rgbframe, | 222 uint8_t* rgbframe, |
221 int width, | 223 int width, |
222 int height, | 224 int height, |
223 int ystride, | 225 int ystride, |
224 int uvstride, | 226 int uvstride, |
225 int rgbstride, | 227 int rgbstride, |
226 YUVType yuv_type) { | 228 YUVType yuv_type) { |
227 unsigned int y_shift = GetVerticalShift(yuv_type); | 229 unsigned int y_shift = GetVerticalShift(yuv_type); |
228 const int16* lookup_table = GetLookupTable(yuv_type); | 230 const int16_t* lookup_table = GetLookupTable(yuv_type); |
229 for (int y = 0; y < height; ++y) { | 231 for (int y = 0; y < height; ++y) { |
230 uint8* rgb_row = rgbframe + y * rgbstride; | 232 uint8_t* rgb_row = rgbframe + y * rgbstride; |
231 const uint8* y_ptr = yplane + y * ystride; | 233 const uint8_t* y_ptr = yplane + y * ystride; |
232 const uint8* u_ptr = uplane + (y >> y_shift) * uvstride; | 234 const uint8_t* u_ptr = uplane + (y >> y_shift) * uvstride; |
233 const uint8* v_ptr = vplane + (y >> y_shift) * uvstride; | 235 const uint8_t* v_ptr = vplane + (y >> y_shift) * uvstride; |
234 | 236 |
235 ConvertYUVToRGB32Row_C(y_ptr, | 237 ConvertYUVToRGB32Row_C(y_ptr, |
236 u_ptr, | 238 u_ptr, |
237 v_ptr, | 239 v_ptr, |
238 rgb_row, | 240 rgb_row, |
239 width, | 241 width, |
240 lookup_table); | 242 lookup_table); |
241 } | 243 } |
242 } | 244 } |
243 | 245 |
244 void ConvertYUVAToARGB_C(const uint8* yplane, | 246 void ConvertYUVAToARGB_C(const uint8_t* yplane, |
245 const uint8* uplane, | 247 const uint8_t* uplane, |
246 const uint8* vplane, | 248 const uint8_t* vplane, |
247 const uint8* aplane, | 249 const uint8_t* aplane, |
248 uint8* rgbaframe, | 250 uint8_t* rgbaframe, |
249 int width, | 251 int width, |
250 int height, | 252 int height, |
251 int ystride, | 253 int ystride, |
252 int uvstride, | 254 int uvstride, |
253 int astride, | 255 int astride, |
254 int rgbastride, | 256 int rgbastride, |
255 YUVType yuv_type) { | 257 YUVType yuv_type) { |
256 unsigned int y_shift = GetVerticalShift(yuv_type); | 258 unsigned int y_shift = GetVerticalShift(yuv_type); |
257 const int16* lookup_table = GetLookupTable(yuv_type); | 259 const int16_t* lookup_table = GetLookupTable(yuv_type); |
258 for (int y = 0; y < height; y++) { | 260 for (int y = 0; y < height; y++) { |
259 uint8* rgba_row = rgbaframe + y * rgbastride; | 261 uint8_t* rgba_row = rgbaframe + y * rgbastride; |
260 const uint8* y_ptr = yplane + y * ystride; | 262 const uint8_t* y_ptr = yplane + y * ystride; |
261 const uint8* u_ptr = uplane + (y >> y_shift) * uvstride; | 263 const uint8_t* u_ptr = uplane + (y >> y_shift) * uvstride; |
262 const uint8* v_ptr = vplane + (y >> y_shift) * uvstride; | 264 const uint8_t* v_ptr = vplane + (y >> y_shift) * uvstride; |
263 const uint8* a_ptr = aplane + y * astride; | 265 const uint8_t* a_ptr = aplane + y * astride; |
264 | 266 |
265 ConvertYUVAToARGBRow_C(y_ptr, | 267 ConvertYUVAToARGBRow_C(y_ptr, |
266 u_ptr, | 268 u_ptr, |
267 v_ptr, | 269 v_ptr, |
268 a_ptr, | 270 a_ptr, |
269 rgba_row, | 271 rgba_row, |
270 width, | 272 width, |
271 lookup_table); | 273 lookup_table); |
272 } | 274 } |
273 } | 275 } |
274 | 276 |
275 } // namespace media | 277 } // namespace media |
OLD | NEW |