content: /*
   * Copyright (C) 2010 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.graphics;
  
  import java.io.OutputStream;
  
  /**
   * YuvImage contains YUV data and provides a method that compresses a region of
   * the YUV data to a Jpeg. The YUV data should be provided as a single byte
   * array irrespective of the number of image planes in it.
   * Currently only ImageFormat.NV21 and ImageFormat.YUY2 are supported.
   *
   * To compress a rectangle region in the YUV data, users have to specify the
   * region by left, top, width and height.
   */
  public class YuvImage {
  
      /**
       * Number of bytes of temp storage we use for communicating between the
       * native compressor and the java OutputStream.
       */
      private final static int WORKING_COMPRESS_STORAGE = 4096;
  
     /**
       * The YUV format as defined in {@link ImageFormat}.
       */
      private int mFormat;
  
      /**
       * The raw YUV data.
       * In the case of more than one image plane, the image planes must be
       * concatenated into a single byte array.
       */
      private byte[] mData;
  
      /**
       * The number of row bytes in each image plane.
       */
      private int[] mStrides;
  
      /**
       * The width of the image.
       */
      private int mWidth;
  
      /**
       * The height of the the image.
       */
      private int mHeight;
  
      /**
       * Construct an YuvImage.
       *
       * @param yuv     The YUV data. In the case of more than one image plane, all the planes must be
       *                concatenated into a single byte array.
       * @param format  The YUV data format as defined in {@link ImageFormat}.
       * @param width   The width of the YuvImage.
       * @param height  The height of the YuvImage.
       * @param strides (Optional) Row bytes of each image plane. If yuv contains padding, the stride
       *                of each image must be provided. If strides is null, the method assumes no
       *                padding and derives the row bytes by format and width itself.
       * @throws IllegalArgumentException if format is not support; width or height <= 0; or yuv is
       *                null.
       */
      public YuvImage(byte[] yuv, int format, int width, int height, int[] strides) {
          if (format != ImageFormat.NV21 &&
                  format != ImageFormat.YUY2) {
              throw new IllegalArgumentException(
                      "only support ImageFormat.NV21 " +
                      "and ImageFormat.YUY2 for now");
          }
  
          if (width <= 0  || height <= 0) {
              throw new IllegalArgumentException(
                      "width and height must large than 0");
          }
  
          if (yuv == null) {
              throw new IllegalArgumentException("yuv cannot be null");
          }
  
          if (strides == null) {
              mStrides = calculateStrides(width, format);
          } else {
              mStrides = strides;
          }
  
          mData = yuv;
          mFormat = format;
          mWidth = width;
          mHeight = height;
      }
  
      /**
       * Compress a rectangle region in the YuvImage to a jpeg.
       * Only ImageFormat.NV21 and ImageFormat.YUY2
       * are supported for now.
       *
       * @param rectangle The rectangle region to be compressed. The medthod checks if rectangle is
       *                  inside the image. Also, the method modifies rectangle if the chroma pixels
       *                  in it are not matched with the luma pixels in it.
       * @param quality   Hint to the compressor, 0-100. 0 meaning compress for
       *                  small size, 100 meaning compress for max quality.
       * @param stream    OutputStream to write the compressed data.
       * @return          True if the compression is successful.
       * @throws IllegalArgumentException if rectangle is invalid; quality is not within [0,
       *                  100]; or stream is null.
       */
      public boolean compressToJpeg(Rect rectangle, int quality, OutputStream stream) {
          Rect wholeImage = new Rect(0, 0, mWidth, mHeight);
          if (!wholeImage.contains(rectangle)) {
              throw new IllegalArgumentException(
                      "rectangle is not inside the image");
          }
  
          if (quality < 0 || quality > 100) {
              throw new IllegalArgumentException("quality must be 0..100");
          }
  
          if (stream == null) {
              throw new IllegalArgumentException("stream cannot be null");
          }
  
          adjustRectangle(rectangle);
          int[] offsets = calculateOffsets(rectangle.left, rectangle.top);
  
          return nativeCompressToJpeg(mData, mFormat, rectangle.width(),
                  rectangle.height(), offsets, mStrides, quality, stream,
                  new byte[WORKING_COMPRESS_STORAGE]);
      }
  
  
     /**
       * @return the YUV data.
       */
      public byte[] getYuvData() {
          return mData;
      }
  
      /**
       * @return the YUV format as defined in {@link ImageFormat}.
       */
      public int getYuvFormat() {
          return mFormat;
      }
  
      /**
       * @return the number of row bytes in each image plane.
       */
      public int[] getStrides() {
          return mStrides;
      }
  
      /**
       * @return the width of the image.
       */
      public int getWidth() {
          return mWidth;
      }
  
      /**
       * @return the height of the image.
       */
      public int getHeight() {
          return mHeight;
      }
  
      int[] calculateOffsets(int left, int top) {
          int[] offsets = null;
          if (mFormat == ImageFormat.NV21) {
              offsets = new int[] {top * mStrides[0] + left,
                    mHeight * mStrides[0] + top / 2 * mStrides[1]
                    + left / 2 * 2 };
              return offsets;
          }
  
          if (mFormat == ImageFormat.YUY2) {
              offsets = new int[] {top * mStrides[0] + left / 2 * 4};
              return offsets;
          }
  
          return offsets;
      }
  
      private int[] calculateStrides(int width, int format) {
          int[] strides = null;
          if (format == ImageFormat.NV21) {
              strides = new int[] {width, width};
              return strides;
          }
  
          if (format == ImageFormat.YUY2) {
              strides = new int[] {width * 2};
              return strides;
          }
  
          return strides;
      }
  
     private void adjustRectangle(Rect rect) {
         int width = rect.width();
         int height = rect.height();
         if (mFormat == ImageFormat.NV21) {
             // Make sure left, top, width and height are all even.
             width &= ~1;
             height &= ~1;
             rect.left &= ~1;
             rect.top &= ~1;
             rect.right = rect.left + width;
             rect.bottom = rect.top + height;
          }
  
          if (mFormat == ImageFormat.YUY2) {
              // Make sure left and width are both even.
              width &= ~1;
              rect.left &= ~1;
              rect.right = rect.left + width;
          }
      }
  
      //////////// native methods
  
      private static native boolean nativeCompressToJpeg(byte[] oriYuv,
              int format, int width, int height, int[] offsets, int[] strides,
              int quality, OutputStream stream, byte[] tempStorage);
  }
  