android/src/com/google/zxing/client/android/YUVMonochromeBitmapSource.java

   1 /*
   2  * Copyright (C) 2008 ZXing authors
   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 package com.google.zxing.client.android;
  18
  19 import android.graphics.Bitmap;
  20 import android.graphics.Rect;
  21 import com.google.zxing.common.BaseMonochromeBitmapSource;
  22
  23 /**
  24  * This object implements MonochromeBitmapSource around an array of YUV data, giving you the option
  25  * to crop to a rectangle within the full data. This can be used to exclude superfluous pixels
  26  * around the perimeter and speed up decoding.
  27  */
  28 final class YUVMonochromeBitmapSource extends BaseMonochromeBitmapSource {
  29
  30   private final byte[] mYUVData;
  31   private final int mDataWidth;
  32   private final Rect mCrop;
  33
  34   /**
  35    * Builds an object around a YUV buffer from the camera.
  36    *
  37    * @param yuvData    A byte array of planar Y data, followed by interleaved U and V
  38    * @param dataWidth  The width of the Y data
  39    * @param dataHeight The height of the Y data
  40    * @param crop       The rectangle within the yuvData to expose to MonochromeBitmapSource users
  41    */
  42   YUVMonochromeBitmapSource(byte[] yuvData, int dataWidth, int dataHeight, Rect crop) {
  43     mYUVData = yuvData;
  44     mDataWidth = dataWidth;
  45     mCrop = crop;
  46     assert (crop.width() <= dataWidth);
  47     assert (crop.height() <= dataHeight);
  48   }
  49
  50   public int getHeight() {
  51     return mCrop.height();
  52   }
  53
  54   public int getWidth() {
  55     return mCrop.width();
  56   }
  57
  58   /**
  59    * The Y channel is stored as planar data at the head of the array, so we just ignore the
  60    * interleavd U and V which follow it.
  61    *
  62    * @param x The x coordinate to fetch within crop
  63    * @param y The y coordinate to fetch within crop
  64    * @return The luminance as an int, from 0-255
  65    */
  66   protected int getLuminance(int x, int y) {
  67     return mYUVData[(y + mCrop.top) * mDataWidth + x + mCrop.left] & 0xff;
  68   }
  69
  70   protected int[] getLuminanceRow(int y, int[] row) {
  71     int width = getWidth();
  72     if (row == null || row.length < width) {
  73       row = new int[width];
  74     }
  75     int offset = (y + mCrop.top) * mDataWidth + mCrop.left;
  76     for (int x = 0; x < width; x++) {
  77       row[x] = mYUVData[offset + x] & 0xff;
  78     }
  79     return row;
  80   }
  81
  82   protected int[] getLuminanceColumn(int x, int[] column) {
  83     int height = getHeight();
  84     if (column == null || column.length < height) {
  85       column = new int[height];
  86     }
  87     int offset = mCrop.top * mDataWidth + mCrop.left + x;
  88     for (int y = 0; y < height; y++) {
  89       column[y] = mYUVData[offset] & 0xff;
  90       offset += mDataWidth;
  91     }
  92     return column;
  93   }
  94
  95   /**
  96    * Create a greyscale Android Bitmap from the YUV data based on the crop rectangle.
  97    *
  98    * @return An 8888 bitmap.
  99    */
 100   public Bitmap renderToBitmap() {
 101     int width = mCrop.width();
 102     int height = mCrop.height();
 103     int[] pixels = new int[width * height];
 104     for (int y = 0; y < height; y++) {
 105       int base = (y + mCrop.top) * mDataWidth + mCrop.left;
 106       for (int x = 0; x < width; x++) {
 107         int grey = mYUVData[base + x] & 0xff;
 108         pixels[y * width + x] = (0xff << 24) | (grey << 16) | (grey << 8) | grey;
 109       }
 110     }
 111
 112     Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
 113     bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
 114     return bitmap;
 115   }
 116
 117 }