1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <jni.h> 18 #include <math.h> 19 #include <android/bitmap.h> 20 21 #include "jpegutil.h" 22 23 using namespace jpegutil; 24 25 /** 26 * Compresses a YCbCr image to jpeg, applying a crop and rotation. 27 * 28 * The input is defined as a set of 3 planes of 8-bit samples, one plane for 29 each channel of Y, Cb, Cr. 30 * The Y plane is assumed to have the same width and height of the entire image. 31 * The Cb and Cr planes are assumed to be downsampled by a factor of 2, to have 32 * dimensions (floor(width / 2), floor(height / 2)). 33 * Each plane is specified by a direct java.nio.ByteBuffer, a pixel-stride, and 34 * a row-stride. So, the sample at coordinate (x, y) can be retrieved from 35 * byteBuffer[x * pixel_stride + y * row_stride]. 36 * 37 * The pre-compression transformation is applied as follows: 38 * 1. The image is cropped to the rectangle from (cropLeft, cropTop) to 39 * (cropRight - 1, cropBottom - 1). So, a cropping-rectangle of (0, 0) - 40 * (width, height) is a no-op. 41 * 2. The rotation is applied counter-clockwise relative to the coordinate 42 * space of the image, so a CCW rotation will appear CW when the image is 43 * rendered in scanline order. Only rotations which are multiples of 44 * 90-degrees are suppored, so the parameter 'rot90' specifies which multiple 45 * of 90 to rotate the image. 46 * 47 * @param env the JNI environment 48 * @param width the width of the image to compress 49 * @param height the height of the image to compress 50 * @param yBuf the buffer containing the Y component of the image 51 * @param yPStride the stride between adjacent pixels in the same row in yBuf 52 * @param yRStride the stride between adjacent rows in yBuf 53 * @param cbBuf the buffer containing the Cb component of the image 54 * @param cbPStride the stride between adjacent pixels in the same row in cbBuf 55 * @param cbRStride the stride between adjacent rows in cbBuf 56 * @param crBuf the buffer containing the Cr component of the image 57 * @param crPStride the stride between adjacent pixels in the same row in crBuf 58 * @param crRStride the stride between adjacent rows in crBuf 59 * @param outBuf a direct java.nio.ByteBuffer to hold the compressed jpeg. This 60 * must have enough capacity to store the result, or an error code will be 61 * returned. 62 * @param outBufCapacity the capacity of outBuf 63 * @param quality the jpeg-quality (1-100) to use 64 * @param crop[Left|Top|Right|Bottom] the bounds of the image to crop to before 65 * rotation 66 * @param rot90 the multiple of 90 to rotate by 67 */ 68 extern "C" JNIEXPORT jint JNICALL 69 Java_com_android_camera_util_JpegUtilNative_compressJpegFromYUV420pNative( 70 JNIEnv* env, jclass clazz, 71 /** Input image dimensions */ 72 jint width, jint height, 73 /** Y Plane */ 74 jobject yBuf, jint yPStride, jint yRStride, 75 /** Cb Plane */ 76 jobject cbBuf, jint cbPStride, jint cbRStride, 77 /** Cr Plane */ 78 jobject crBuf, jint crPStride, jint crRStride, 79 /** Output */ 80 jobject outBuf, jint outBufCapacity, 81 /** Jpeg compression parameters */ 82 jint quality, 83 /** Crop */ 84 jint cropLeft, jint cropTop, jint cropRight, jint cropBottom, 85 /** Rotation (multiple of 90). For example, rot90 = 1 implies a 90 degree 86 * rotation. */ 87 jint rot90) { 88 jbyte* y = (jbyte*)env->GetDirectBufferAddress(yBuf); 89 jbyte* cb = (jbyte*)env->GetDirectBufferAddress(cbBuf); 90 jbyte* cr = (jbyte*)env->GetDirectBufferAddress(crBuf); 91 jbyte* out = (jbyte*)env->GetDirectBufferAddress(outBuf); 92 93 return Compress(width, height, // 94 (unsigned char*)y, yPStride, yRStride, // 95 (unsigned char*)cb, cbPStride, cbRStride, // 96 (unsigned char*)cr, crPStride, crRStride, // 97 (unsigned char*)out, (size_t)outBufCapacity, // 98 quality, // 99 cropLeft, cropTop, cropRight, cropBottom, // 100 rot90); 101 } 102 103 /** 104 * Copies the Image.Plane specified by planeBuf, pStride, and rStride to the 105 * Bitmap. 106 * 107 * @param env the JNI environment 108 * @param clazz the java class 109 * @param width the width of the output image 110 * @param height the height of the output image 111 * @param planeBuf the native ByteBuffer containing the image plane data 112 * @param pStride the stride between adjacent pixels in the same row of 113 *planeBuf 114 * @param rStride the stride between adjacent rows in planeBuf 115 * @param rot90 the multiple of 90 degrees to rotate, one of {0, 1, 2, 3}. 116 */ 117 extern "C" JNIEXPORT void JNICALL 118 Java_com_android_camera_util_JpegUtilNative_copyImagePlaneToBitmap( 119 JNIEnv* env, jclass clazz, jint width, jint height, jobject planeBuf, 120 jint pStride, jint rStride, jobject outBitmap, jint rot90) { 121 jbyte* src = (jbyte*)env->GetDirectBufferAddress(planeBuf); 122 123 char* dst = 0; 124 AndroidBitmap_lockPixels(env, outBitmap, (void**)&dst); 125 126 if (rot90 == 0) { 127 // No rotation 128 for (int y = 0; y < height; y++) { 129 char* srcPtr = reinterpret_cast<char*>(&src[y * rStride]); 130 char* dstPtr = &dst[y * width]; 131 for (int x = 0; x < width; x++) { 132 *dstPtr = *srcPtr; 133 srcPtr += pStride; 134 dstPtr++; 135 } 136 } 137 } else if (rot90 == 1) { 138 // 90-degree rotation 139 for (int y = 0; y < height; y++) { 140 for (int x = 0; x < width; x++) { 141 int srcX = height - 1 - y; 142 int srcY = x; 143 dst[y * width + x] = src[srcX * pStride + rStride * srcY]; 144 } 145 } 146 } else if (rot90 == 2) { 147 // 180-degree rotation 148 for (int y = 0; y < height; y++) { 149 for (int x = 0; x < width; x++) { 150 int srcX = width - 1 - x; 151 int srcY = height - 1 - y; 152 dst[y * width + x] = src[srcX * pStride + rStride * srcY]; 153 } 154 } 155 } else if (rot90 == 3) { 156 // 270-degree rotation 157 for (int y = 0; y < height; y++) { 158 for (int x = 0; x < width; x++) { 159 int srcX = y; 160 int srcY = width - 1 - x; 161 dst[y * width + x] = src[srcX * pStride + rStride * srcY]; 162 } 163 } 164 } 165 166 AndroidBitmap_unlockPixels(env, outBitmap); 167 } 168
