YuvToJpegEncoder.cpp revision d865900425d9593974aac640bc4deb93865dcfbe 
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
9YuvToJpegEncoder* 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
21YuvToJpegEncoder::YuvToJpegEncoder(int* strides) : fStrides(strides) {
22}
23
24bool 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
50void 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///////////////////////////////////////////////////////////////////
66Yuv420SpToJpegEncoder::Yuv420SpToJpegEncoder(int* strides) :
67        YuvToJpegEncoder(strides) {
68    fNumPlanes = 2;
69}
70
71void 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
115void 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
131void 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///////////////////////////////////////////////////////////////////////////////
142Yuv422IToJpegEncoder::Yuv422IToJpegEncoder(int* strides) :
143        YuvToJpegEncoder(strides) {
144    fNumPlanes = 1;
145}
146
147void 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
190void 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
208void 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
219static jboolean YuvImage_compressToJpeg(JNIEnv* env, jobject, jbyteArray inYuv,
220        jint format, jint width, jint height, jintArray offsets,
221        jintArray strides, jint 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    jboolean result = JNI_FALSE;
230    if (encoder != NULL) {
231        encoder->encode(strm, yuv, width, height, imgOffsets, jpegQuality);
232        delete encoder;
233        result = JNI_TRUE;
234    }
235
236    env->ReleaseByteArrayElements(inYuv, yuv, 0);
237    env->ReleaseIntArrayElements(offsets, imgOffsets, 0);
238    env->ReleaseIntArrayElements(strides, imgStrides, 0);
239    delete strm;
240    return result;
241}
242///////////////////////////////////////////////////////////////////////////////
243
244#include <android_runtime/AndroidRuntime.h>
245
246static JNINativeMethod gYuvImageMethods[] = {
247    {   "nativeCompressToJpeg",  "([BIII[I[IILjava/io/OutputStream;[B)Z",
248        (void*)YuvImage_compressToJpeg }
249};
250
251#define kClassPathName  "android/graphics/YuvImage"
252
253int register_android_graphics_YuvImage(JNIEnv* env)
254{
255    return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,
256            gYuvImageMethods, SK_ARRAY_COUNT(gYuvImageMethods));
257}
258