jni_jpegstream/src/jpeg_writer.cpp

   1 /*
   2  * Copyright (C) 2013 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 "jpeg_hook.h"
  18 #include "jpeg_writer.h"
  19 #include "error_codes.h"
  20
  21 #include <setjmp.h>
  22 #include <assert.h>
  23
  24 JpegWriter::JpegWriter() : mInfo(),
  25                            mErrorManager(),
  26                            mScanlineBuf(NULL),
  27                            mScanlineIter(NULL),
  28                            mScanlineBuflen(0),
  29                            mScanlineBytesRemaining(0),
  30                            mFormat(),
  31                            mFinished(false),
  32                            mSetup(false) {}
  33
  34 JpegWriter::~JpegWriter() {
  35     if (reset() != J_SUCCESS) {
  36         LOGE("Failed to destroy compress object, may leak memory.");
  37     }
  38 }
  39
  40 const int32_t JpegWriter::DEFAULT_X_DENSITY = 300;
  41 const int32_t JpegWriter::DEFAULT_Y_DENSITY = 300;
  42 const int32_t JpegWriter::DEFAULT_DENSITY_UNIT = 1;
  43
  44 int32_t JpegWriter::setup(JNIEnv *env, jobject out, int32_t width, int32_t height,
  45         Jpeg_Config::Format format, int32_t quality) {
  46     if (mFinished || mSetup) {
  47         return J_ERROR_FATAL;
  48     }
  49     if (env->ExceptionCheck()) {
  50         return J_EXCEPTION;
  51     }
  52     if (height <= 0 || width <= 0 || quality <= 0 || quality > 100) {
  53         return J_ERROR_BAD_ARGS;
  54     }
  55     // Setup error handler
  56     SetupErrMgr(reinterpret_cast<j_common_ptr>(&mInfo), &mErrorManager);
  57
  58     // Set jump address for error handling
  59     if (setjmp(mErrorManager.setjmp_buf)) {
  60         return J_ERROR_FATAL;
  61     }
  62
  63     // Setup cinfo struct
  64     jpeg_create_compress(&mInfo);
  65
  66     // Setup global java refs
  67     int32_t flags = MakeDst(&mInfo, env, out);
  68     if (flags != J_SUCCESS) {
  69         return flags;
  70     }
  71
  72     // Initialize width, height, and color space
  73     mInfo.image_width = width;
  74     mInfo.image_height = height;
  75     const int components = (static_cast<int>(format) & 0xff);
  76     switch (components) {
  77     case 1:
  78         mInfo.input_components = 1;
  79         mInfo.in_color_space = JCS_GRAYSCALE;
  80         break;
  81     case 3:
  82     case 4:
  83         mInfo.input_components = 3;
  84         mInfo.in_color_space = JCS_RGB;
  85         break;
  86     default:
  87         return J_ERROR_BAD_ARGS;
  88     }
  89
  90     // Set defaults
  91     jpeg_set_defaults(&mInfo);
  92     mInfo.density_unit = DEFAULT_DENSITY_UNIT; // JFIF code for pixel size units:
  93                              // 1 = in, 2 = cm
  94     mInfo.X_density = DEFAULT_X_DENSITY; // Horizontal pixel density
  95     mInfo.Y_density = DEFAULT_Y_DENSITY; // Vertical pixel density
  96
  97     // Set compress quality
  98     jpeg_set_quality(&mInfo, quality, TRUE);
  99
 100     mFormat = format;
 101
 102     // Setup scanline buffer
 103     mScanlineBuflen = width * components;
 104     mScanlineBytesRemaining = mScanlineBuflen;
 105     mScanlineBuf = (JSAMPLE *) (mInfo.mem->alloc_small)(
 106             reinterpret_cast<j_common_ptr>(&mInfo), JPOOL_PERMANENT,
 107             mScanlineBuflen * sizeof(JSAMPLE));
 108     mScanlineIter = mScanlineBuf;
 109
 110     // Start compression
 111     jpeg_start_compress(&mInfo, TRUE);
 112     mSetup = true;
 113     return J_SUCCESS;
 114 }
 115
 116 int32_t JpegWriter::write(int8_t* bytes, int32_t length) {
 117     if (!mSetup) {
 118         return J_ERROR_FATAL;
 119     }
 120     if (mFinished) {
 121         return 0;
 122     }
 123     // Set jump address for error handling
 124     if (setjmp(mErrorManager.setjmp_buf)) {
 125         return J_ERROR_FATAL;
 126     }
 127     if (length < 0 || bytes == NULL) {
 128         return J_ERROR_BAD_ARGS;
 129     }
 130
 131     int32_t total_length = length;
 132     JSAMPROW row_pointer[1];
 133     while (mInfo.next_scanline < mInfo.image_height) {
 134         if (length < mScanlineBytesRemaining) {
 135             // read partial scanline and return
 136             memcpy((void*) mScanlineIter, (void*) bytes,
 137                     length * sizeof(int8_t));
 138             mScanlineBytesRemaining -= length;
 139             mScanlineIter += length;
 140             return total_length;
 141         } else if (length > 0) {
 142             // read full scanline
 143             memcpy((void*) mScanlineIter, (void*) bytes,
 144                     mScanlineBytesRemaining * sizeof(int8_t));
 145             bytes += mScanlineBytesRemaining;
 146             length -= mScanlineBytesRemaining;
 147             mScanlineBytesRemaining = 0;
 148         }
 149         // Do in-place pixel formatting
 150         formatPixels(static_cast<uint8_t*>(mScanlineBuf), mScanlineBuflen);
 151         row_pointer[0] = mScanlineBuf;
 152         // Do compression
 153         if (jpeg_write_scanlines(&mInfo, row_pointer, 1) != 1) {
 154             return J_ERROR_FATAL;
 155         }
 156         // Reset scanline buffer
 157         mScanlineBytesRemaining = mScanlineBuflen;
 158         mScanlineIter = mScanlineBuf;
 159     }
 160     jpeg_finish_compress(&mInfo);
 161     mFinished = true;
 162     return total_length - length;
 163 }
 164
 165 // Does in-place pixel formatting
 166 void JpegWriter::formatPixels(uint8_t* buf, int32_t len) {
 167     //  Assumes len is a multiple of 4 for RGBA and ABGR pixels.
 168     assert((len % 4) == 0);
 169     uint8_t* d = buf;
 170     switch (mFormat) {
 171     case Jpeg_Config::FORMAT_RGBA: {
 172         // Strips alphas
 173         for (int i = 0; i < len / 4; ++i, buf += 4) {
 174             *d++ = buf[0];
 175             *d++ = buf[1];
 176             *d++ = buf[2];
 177         }
 178         break;
 179     }
 180     case Jpeg_Config::FORMAT_ABGR: {
 181         // Strips alphas and flips endianness
 182         if (len / 4 >= 1) {
 183             *d++ = buf[3];
 184             uint8_t tmp = *d;
 185             *d++ = buf[2];
 186             *d++ = tmp;
 187         }
 188         for (int i = 1; i < len / 4; ++i, buf += 4) {
 189             *d++ = buf[3];
 190             *d++ = buf[2];
 191             *d++ = buf[1];
 192         }
 193         break;
 194     }
 195     default: {
 196         // Do nothing
 197         break;
 198     }
 199     }
 200 }
 201
 202 void JpegWriter::updateEnv(JNIEnv *env) {
 203     UpdateDstEnv(&mInfo, env);
 204 }
 205
 206 int32_t JpegWriter::reset() {
 207     // Set jump address for error handling
 208     if (setjmp(mErrorManager.setjmp_buf)) {
 209         return J_ERROR_FATAL;
 210     }
 211     // Clean up global java references
 212     CleanDst(&mInfo);
 213     // Wipe compress struct, free memory pools
 214     jpeg_destroy_compress(&mInfo);
 215     mFinished = false;
 216     mSetup = false;
 217     return J_SUCCESS;
 218 }