1 #include "CreateJavaOutputStreamAdaptor.h"
2 #include "SkJpegUtility.h"
3 #include "YuvToJpegEncoder.h"
4 #include <ui/PixelFormat.h>
5 #include <hardware/hardware.h>
6
7 #include <jni.h>
8
create(int format,int * strides)9 YuvToJpegEncoder* YuvToJpegEncoder::create(int format, int* strides) {
10 // Only ImageFormat.NV21 and ImageFormat.YUY2 are supported
11 // for now.
12 if (format == HAL_PIXEL_FORMAT_YCrCb_420_SP) {
13 return new Yuv420SpToJpegEncoder(strides);
14 } else if (format == HAL_PIXEL_FORMAT_YCbCr_422_I) {
15 return new Yuv422IToJpegEncoder(strides);
16 } else {
17 return NULL;
18 }
19 }
20
YuvToJpegEncoder(int * strides)21 YuvToJpegEncoder::YuvToJpegEncoder(int* strides) : fStrides(strides) {
22 }
23
encode(SkWStream * stream,void * inYuv,int width,int height,int * offsets,int jpegQuality)24 bool YuvToJpegEncoder::encode(SkWStream* stream, void* inYuv, int width,
25 int height, int* offsets, int jpegQuality) {
26 jpeg_compress_struct cinfo;
27 skjpeg_error_mgr sk_err;
28 skjpeg_destination_mgr sk_wstream(stream);
29
30 cinfo.err = jpeg_std_error(&sk_err);
31 sk_err.error_exit = skjpeg_error_exit;
32 if (setjmp(sk_err.fJmpBuf)) {
33 return false;
34 }
35 jpeg_create_compress(&cinfo);
36
37 cinfo.dest = &sk_wstream;
38
39 setJpegCompressStruct(&cinfo, width, height, jpegQuality);
40
41 jpeg_start_compress(&cinfo, TRUE);
42
43 compress(&cinfo, (uint8_t*) inYuv, offsets);
44
45 jpeg_finish_compress(&cinfo);
46
47 return true;
48 }
49
setJpegCompressStruct(jpeg_compress_struct * cinfo,int width,int height,int quality)50 void YuvToJpegEncoder::setJpegCompressStruct(jpeg_compress_struct* cinfo,
51 int width, int height, int quality) {
52 cinfo->image_width = width;
53 cinfo->image_height = height;
54 cinfo->input_components = 3;
55 cinfo->in_color_space = JCS_YCbCr;
56 jpeg_set_defaults(cinfo);
57
58 jpeg_set_quality(cinfo, quality, TRUE);
59 jpeg_set_colorspace(cinfo, JCS_YCbCr);
60 cinfo->raw_data_in = TRUE;
61 cinfo->dct_method = JDCT_IFAST;
62 configSamplingFactors(cinfo);
63 }
64
65 ///////////////////////////////////////////////////////////////////
Yuv420SpToJpegEncoder(int * strides)66 Yuv420SpToJpegEncoder::Yuv420SpToJpegEncoder(int* strides) :
67 YuvToJpegEncoder(strides) {
68 fNumPlanes = 2;
69 }
70
compress(jpeg_compress_struct * cinfo,uint8_t * yuv,int * offsets)71 void Yuv420SpToJpegEncoder::compress(jpeg_compress_struct* cinfo,
72 uint8_t* yuv, int* offsets) {
73 SkDebugf("onFlyCompress");
74 JSAMPROW y[16];
75 JSAMPROW cb[8];
76 JSAMPROW cr[8];
77 JSAMPARRAY planes[3];
78 planes[0] = y;
79 planes[1] = cb;
80 planes[2] = cr;
81
82 int width = cinfo->image_width;
83 int height = cinfo->image_height;
84 uint8_t* yPlanar = yuv + offsets[0];
85 uint8_t* vuPlanar = yuv + offsets[1]; //width * height;
86 uint8_t* uRows = new uint8_t [8 * (width >> 1)];
87 uint8_t* vRows = new uint8_t [8 * (width >> 1)];
88
89
90 // process 16 lines of Y and 8 lines of U/V each time.
91 while (cinfo->next_scanline < cinfo->image_height) {
92 //deitnerleave u and v
93 deinterleave(vuPlanar, uRows, vRows, cinfo->next_scanline, width, height);
94
95 // Jpeg library ignores the rows whose indices are greater than height.
96 for (int i = 0; i < 16; i++) {
97 // y row
98 y[i] = yPlanar + (cinfo->next_scanline + i) * fStrides[0];
99
100 // construct u row and v row
101 if ((i & 1) == 0) {
102 // height and width are both halved because of downsampling
103 int offset = (i >> 1) * (width >> 1);
104 cb[i/2] = uRows + offset;
105 cr[i/2] = vRows + offset;
106 }
107 }
108 jpeg_write_raw_data(cinfo, planes, 16);
109 }
110 delete [] uRows;
111 delete [] vRows;
112
113 }
114
deinterleave(uint8_t * vuPlanar,uint8_t * uRows,uint8_t * vRows,int rowIndex,int width,int height)115 void Yuv420SpToJpegEncoder::deinterleave(uint8_t* vuPlanar, uint8_t* uRows,
116 uint8_t* vRows, int rowIndex, int width, int height) {
117 int numRows = (height - rowIndex) / 2;
118 if (numRows > 8) numRows = 8;
119 for (int row = 0; row < numRows; ++row) {
120 int offset = ((rowIndex >> 1) + row) * fStrides[1];
121 uint8_t* vu = vuPlanar + offset;
122 for (int i = 0; i < (width >> 1); ++i) {
123 int index = row * (width >> 1) + i;
124 uRows[index] = vu[1];
125 vRows[index] = vu[0];
126 vu += 2;
127 }
128 }
129 }
130
configSamplingFactors(jpeg_compress_struct * cinfo)131 void Yuv420SpToJpegEncoder::configSamplingFactors(jpeg_compress_struct* cinfo) {
132 // cb and cr are horizontally downsampled and vertically downsampled as well.
133 cinfo->comp_info[0].h_samp_factor = 2;
134 cinfo->comp_info[0].v_samp_factor = 2;
135 cinfo->comp_info[1].h_samp_factor = 1;
136 cinfo->comp_info[1].v_samp_factor = 1;
137 cinfo->comp_info[2].h_samp_factor = 1;
138 cinfo->comp_info[2].v_samp_factor = 1;
139 }
140
141 ///////////////////////////////////////////////////////////////////////////////
Yuv422IToJpegEncoder(int * strides)142 Yuv422IToJpegEncoder::Yuv422IToJpegEncoder(int* strides) :
143 YuvToJpegEncoder(strides) {
144 fNumPlanes = 1;
145 }
146
compress(jpeg_compress_struct * cinfo,uint8_t * yuv,int * offsets)147 void Yuv422IToJpegEncoder::compress(jpeg_compress_struct* cinfo,
148 uint8_t* yuv, int* offsets) {
149 SkDebugf("onFlyCompress_422");
150 JSAMPROW y[16];
151 JSAMPROW cb[16];
152 JSAMPROW cr[16];
153 JSAMPARRAY planes[3];
154 planes[0] = y;
155 planes[1] = cb;
156 planes[2] = cr;
157
158 int width = cinfo->image_width;
159 int height = cinfo->image_height;
160 uint8_t* yRows = new uint8_t [16 * width];
161 uint8_t* uRows = new uint8_t [16 * (width >> 1)];
162 uint8_t* vRows = new uint8_t [16 * (width >> 1)];
163
164 uint8_t* yuvOffset = yuv + offsets[0];
165
166 // process 16 lines of Y and 16 lines of U/V each time.
167 while (cinfo->next_scanline < cinfo->image_height) {
168 deinterleave(yuvOffset, yRows, uRows, vRows, cinfo->next_scanline, width, height);
169
170 // Jpeg library ignores the rows whose indices are greater than height.
171 for (int i = 0; i < 16; i++) {
172 // y row
173 y[i] = yRows + i * width;
174
175 // construct u row and v row
176 // width is halved because of downsampling
177 int offset = i * (width >> 1);
178 cb[i] = uRows + offset;
179 cr[i] = vRows + offset;
180 }
181
182 jpeg_write_raw_data(cinfo, planes, 16);
183 }
184 delete [] yRows;
185 delete [] uRows;
186 delete [] vRows;
187 }
188
189
deinterleave(uint8_t * yuv,uint8_t * yRows,uint8_t * uRows,uint8_t * vRows,int rowIndex,int width,int height)190 void Yuv422IToJpegEncoder::deinterleave(uint8_t* yuv, uint8_t* yRows, uint8_t* uRows,
191 uint8_t* vRows, int rowIndex, int width, int height) {
192 int numRows = height - rowIndex;
193 if (numRows > 16) numRows = 16;
194 for (int row = 0; row < numRows; ++row) {
195 uint8_t* yuvSeg = yuv + (rowIndex + row) * fStrides[0];
196 for (int i = 0; i < (width >> 1); ++i) {
197 int indexY = row * width + (i << 1);
198 int indexU = row * (width >> 1) + i;
199 yRows[indexY] = yuvSeg[0];
200 yRows[indexY + 1] = yuvSeg[2];
201 uRows[indexU] = yuvSeg[1];
202 vRows[indexU] = yuvSeg[3];
203 yuvSeg += 4;
204 }
205 }
206 }
207
configSamplingFactors(jpeg_compress_struct * cinfo)208 void Yuv422IToJpegEncoder::configSamplingFactors(jpeg_compress_struct* cinfo) {
209 // cb and cr are horizontally downsampled and vertically downsampled as well.
210 cinfo->comp_info[0].h_samp_factor = 2;
211 cinfo->comp_info[0].v_samp_factor = 2;
212 cinfo->comp_info[1].h_samp_factor = 1;
213 cinfo->comp_info[1].v_samp_factor = 2;
214 cinfo->comp_info[2].h_samp_factor = 1;
215 cinfo->comp_info[2].v_samp_factor = 2;
216 }
217 ///////////////////////////////////////////////////////////////////////////////
218
YuvImage_compressToJpeg(JNIEnv * env,jobject,jbyteArray inYuv,int format,int width,int height,jintArray offsets,jintArray strides,int jpegQuality,jobject jstream,jbyteArray jstorage)219 static jboolean YuvImage_compressToJpeg(JNIEnv* env, jobject, jbyteArray inYuv,
220 int format, int width, int height, jintArray offsets,
221 jintArray strides, int jpegQuality, jobject jstream,
222 jbyteArray jstorage) {
223 jbyte* yuv = env->GetByteArrayElements(inYuv, NULL);
224 SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
225
226 jint* imgOffsets = env->GetIntArrayElements(offsets, NULL);
227 jint* imgStrides = env->GetIntArrayElements(strides, NULL);
228 YuvToJpegEncoder* encoder = YuvToJpegEncoder::create(format, imgStrides);
229 if (encoder == NULL) {
230 return false;
231 }
232 encoder->encode(strm, yuv, width, height, imgOffsets, jpegQuality);
233
234 delete encoder;
235 env->ReleaseByteArrayElements(inYuv, yuv, 0);
236 env->ReleaseIntArrayElements(offsets, imgOffsets, 0);
237 env->ReleaseIntArrayElements(strides, imgStrides, 0);
238 return true;
239 }
240 ///////////////////////////////////////////////////////////////////////////////
241
242 #include <android_runtime/AndroidRuntime.h>
243
244 static JNINativeMethod gYuvImageMethods[] = {
245 { "nativeCompressToJpeg", "([BIII[I[IILjava/io/OutputStream;[B)Z",
246 (void*)YuvImage_compressToJpeg }
247 };
248
249 #define kClassPathName "android/graphics/YuvImage"
250
register_android_graphics_YuvImage(JNIEnv * env)251 int register_android_graphics_YuvImage(JNIEnv* env)
252 {
253 return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,
254 gYuvImageMethods, SK_ARRAY_COUNT(gYuvImageMethods));
255 }
256