1 #include "CreateJavaOutputStreamAdaptor.h"
2 #include "SkJPEGWriteUtility.h"
3 #include "YuvToJpegEncoder.h"
4 #include <ui/PixelFormat.h>
5 #include <hardware/hardware.h>
7 #include "core_jni_helpers.h"
11 YuvToJpegEncoder* YuvToJpegEncoder::create(int format, int* strides) {
12 // Only ImageFormat.NV21 and ImageFormat.YUY2 are supported
14 if (format == HAL_PIXEL_FORMAT_YCrCb_420_SP) {
15 return new Yuv420SpToJpegEncoder(strides);
16 } else if (format == HAL_PIXEL_FORMAT_YCbCr_422_I) {
17 return new Yuv422IToJpegEncoder(strides);
23 YuvToJpegEncoder::YuvToJpegEncoder(int* strides) : fStrides(strides) {
26 bool YuvToJpegEncoder::encode(SkWStream* stream, void* inYuv, int width,
27 int height, int* offsets, int jpegQuality) {
28 jpeg_compress_struct cinfo;
29 skjpeg_error_mgr sk_err;
30 skjpeg_destination_mgr sk_wstream(stream);
32 cinfo.err = jpeg_std_error(&sk_err);
33 sk_err.error_exit = skjpeg_error_exit;
34 if (setjmp(sk_err.fJmpBuf)) {
37 jpeg_create_compress(&cinfo);
39 cinfo.dest = &sk_wstream;
41 setJpegCompressStruct(&cinfo, width, height, jpegQuality);
43 jpeg_start_compress(&cinfo, TRUE);
45 compress(&cinfo, (uint8_t*) inYuv, offsets);
47 jpeg_finish_compress(&cinfo);
52 void YuvToJpegEncoder::setJpegCompressStruct(jpeg_compress_struct* cinfo,
53 int width, int height, int quality) {
54 cinfo->image_width = width;
55 cinfo->image_height = height;
56 cinfo->input_components = 3;
57 cinfo->in_color_space = JCS_YCbCr;
58 jpeg_set_defaults(cinfo);
60 jpeg_set_quality(cinfo, quality, TRUE);
61 jpeg_set_colorspace(cinfo, JCS_YCbCr);
62 cinfo->raw_data_in = TRUE;
63 cinfo->dct_method = JDCT_IFAST;
64 configSamplingFactors(cinfo);
67 ///////////////////////////////////////////////////////////////////
68 Yuv420SpToJpegEncoder::Yuv420SpToJpegEncoder(int* strides) :
69 YuvToJpegEncoder(strides) {
73 void Yuv420SpToJpegEncoder::compress(jpeg_compress_struct* cinfo,
74 uint8_t* yuv, int* offsets) {
75 SkDebugf("onFlyCompress");
84 int width = cinfo->image_width;
85 int height = cinfo->image_height;
86 uint8_t* yPlanar = yuv + offsets[0];
87 uint8_t* vuPlanar = yuv + offsets[1]; //width * height;
88 uint8_t* uRows = new uint8_t [8 * (width >> 1)];
89 uint8_t* vRows = new uint8_t [8 * (width >> 1)];
92 // process 16 lines of Y and 8 lines of U/V each time.
93 while (cinfo->next_scanline < cinfo->image_height) {
94 //deitnerleave u and v
95 deinterleave(vuPlanar, uRows, vRows, cinfo->next_scanline, width, height);
97 // Jpeg library ignores the rows whose indices are greater than height.
98 for (int i = 0; i < 16; i++) {
100 y[i] = yPlanar + (cinfo->next_scanline + i) * fStrides[0];
102 // construct u row and v row
104 // height and width are both halved because of downsampling
105 int offset = (i >> 1) * (width >> 1);
106 cb[i/2] = uRows + offset;
107 cr[i/2] = vRows + offset;
110 jpeg_write_raw_data(cinfo, planes, 16);
117 void Yuv420SpToJpegEncoder::deinterleave(uint8_t* vuPlanar, uint8_t* uRows,
118 uint8_t* vRows, int rowIndex, int width, int height) {
119 int numRows = (height - rowIndex) / 2;
120 if (numRows > 8) numRows = 8;
121 for (int row = 0; row < numRows; ++row) {
122 int offset = ((rowIndex >> 1) + row) * fStrides[1];
123 uint8_t* vu = vuPlanar + offset;
124 for (int i = 0; i < (width >> 1); ++i) {
125 int index = row * (width >> 1) + i;
126 uRows[index] = vu[1];
127 vRows[index] = vu[0];
133 void Yuv420SpToJpegEncoder::configSamplingFactors(jpeg_compress_struct* cinfo) {
134 // cb and cr are horizontally downsampled and vertically downsampled as well.
135 cinfo->comp_info[0].h_samp_factor = 2;
136 cinfo->comp_info[0].v_samp_factor = 2;
137 cinfo->comp_info[1].h_samp_factor = 1;
138 cinfo->comp_info[1].v_samp_factor = 1;
139 cinfo->comp_info[2].h_samp_factor = 1;
140 cinfo->comp_info[2].v_samp_factor = 1;
143 ///////////////////////////////////////////////////////////////////////////////
144 Yuv422IToJpegEncoder::Yuv422IToJpegEncoder(int* strides) :
145 YuvToJpegEncoder(strides) {
149 void Yuv422IToJpegEncoder::compress(jpeg_compress_struct* cinfo,
150 uint8_t* yuv, int* offsets) {
151 SkDebugf("onFlyCompress_422");
155 JSAMPARRAY planes[3];
160 int width = cinfo->image_width;
161 int height = cinfo->image_height;
162 uint8_t* yRows = new uint8_t [16 * width];
163 uint8_t* uRows = new uint8_t [16 * (width >> 1)];
164 uint8_t* vRows = new uint8_t [16 * (width >> 1)];
166 uint8_t* yuvOffset = yuv + offsets[0];
168 // process 16 lines of Y and 16 lines of U/V each time.
169 while (cinfo->next_scanline < cinfo->image_height) {
170 deinterleave(yuvOffset, yRows, uRows, vRows, cinfo->next_scanline, width, height);
172 // Jpeg library ignores the rows whose indices are greater than height.
173 for (int i = 0; i < 16; i++) {
175 y[i] = yRows + i * width;
177 // construct u row and v row
178 // width is halved because of downsampling
179 int offset = i * (width >> 1);
180 cb[i] = uRows + offset;
181 cr[i] = vRows + offset;
184 jpeg_write_raw_data(cinfo, planes, 16);
192 void Yuv422IToJpegEncoder::deinterleave(uint8_t* yuv, uint8_t* yRows, uint8_t* uRows,
193 uint8_t* vRows, int rowIndex, int width, int height) {
194 int numRows = height - rowIndex;
195 if (numRows > 16) numRows = 16;
196 for (int row = 0; row < numRows; ++row) {
197 uint8_t* yuvSeg = yuv + (rowIndex + row) * fStrides[0];
198 for (int i = 0; i < (width >> 1); ++i) {
199 int indexY = row * width + (i << 1);
200 int indexU = row * (width >> 1) + i;
201 yRows[indexY] = yuvSeg[0];
202 yRows[indexY + 1] = yuvSeg[2];
203 uRows[indexU] = yuvSeg[1];
204 vRows[indexU] = yuvSeg[3];
210 void Yuv422IToJpegEncoder::configSamplingFactors(jpeg_compress_struct* cinfo) {
211 // cb and cr are horizontally downsampled and vertically downsampled as well.
212 cinfo->comp_info[0].h_samp_factor = 2;
213 cinfo->comp_info[0].v_samp_factor = 2;
214 cinfo->comp_info[1].h_samp_factor = 1;
215 cinfo->comp_info[1].v_samp_factor = 2;
216 cinfo->comp_info[2].h_samp_factor = 1;
217 cinfo->comp_info[2].v_samp_factor = 2;
219 ///////////////////////////////////////////////////////////////////////////////
221 static jboolean YuvImage_compressToJpeg(JNIEnv* env, jobject, jbyteArray inYuv,
222 jint format, jint width, jint height, jintArray offsets,
223 jintArray strides, jint jpegQuality, jobject jstream,
224 jbyteArray jstorage) {
225 jbyte* yuv = env->GetByteArrayElements(inYuv, NULL);
226 SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
228 jint* imgOffsets = env->GetIntArrayElements(offsets, NULL);
229 jint* imgStrides = env->GetIntArrayElements(strides, NULL);
230 YuvToJpegEncoder* encoder = YuvToJpegEncoder::create(format, imgStrides);
231 jboolean result = JNI_FALSE;
232 if (encoder != NULL) {
233 encoder->encode(strm, yuv, width, height, imgOffsets, jpegQuality);
238 env->ReleaseByteArrayElements(inYuv, yuv, 0);
239 env->ReleaseIntArrayElements(offsets, imgOffsets, 0);
240 env->ReleaseIntArrayElements(strides, imgStrides, 0);
244 ///////////////////////////////////////////////////////////////////////////////
246 static const JNINativeMethod gYuvImageMethods[] = {
247 { "nativeCompressToJpeg", "([BIII[I[IILjava/io/OutputStream;[B)Z",
248 (void*)YuvImage_compressToJpeg }
251 int register_android_graphics_YuvImage(JNIEnv* env)
253 return android::RegisterMethodsOrDie(env, "android/graphics/YuvImage", gYuvImageMethods,
254 NELEM(gYuvImageMethods));