Home | History | Annotate | Download | only in testingcamera 
      1 package com.android.testingcamera;
      2 
      3 import android.content.res.Resources;
      4 import android.graphics.ImageFormat;
      5 import android.graphics.PixelFormat;
      6 import android.os.AsyncTask;
      7 import android.os.SystemClock;
      8 import android.renderscript.Allocation;
      9 import android.renderscript.Element;
     10 import android.renderscript.Matrix4f;
     11 import android.renderscript.RenderScript;
     12 import android.renderscript.Script;
     13 import android.renderscript.ScriptGroup;
     14 import android.renderscript.ScriptIntrinsicColorMatrix;
     15 import android.renderscript.Type;
     16 import android.util.Log;
     17 import android.view.Surface;
     18 import android.view.SurfaceView;
     19 
     20 /**
     21  *  Process preview callback data for display.
     22  *  This is done by constructing a two-step Renderscript group,
     23  *  the first of which converts from various YUV formats to 8bpp YUV, and
     24  *  the second of which converts from YUV to RGB.
     25  *
     26  *  The processing is done in a background thread, and the result is produced
     27  *  into an Allocation that's backed by a SurfaceView
     28  */
     29 class CallbackProcessor {
     30     private SurfaceView mCallbackView;
     31     private Surface mCallbackSurface;
     32 
     33     private Object mTaskLock = new Object();
     34 
     35     private RenderScript mRS;
     36     private Allocation mAllocationIn;
     37     private Allocation mAllocationOut;
     38     private ScriptGroup mConverter;
     39 
     40     private int mWidth;
     41     private int mHeight;
     42     private int mFormat;
     43 
     44     private boolean mDone = false;
     45     private boolean mTaskInProgress = false;
     46 
     47     static final private int kStopTimeout = 2000; // ms
     48 
     49     private static final String TAG = "CallbackProcessor";
     50 
     51     public CallbackProcessor(int width, int height, int format,
     52             Resources res, SurfaceView callbackView,
     53             int viewWidth, int viewHeight,
     54             RenderScript rs) {
     55         mWidth = width;
     56         mHeight = height;
     57         mFormat = format;
     58         mRS = rs;
     59         mCallbackView = callbackView;
     60 
     61         int inputSize = TestingCamera.getCallbackBufferSize(mWidth, mHeight,
     62                 mFormat);
     63         mAllocationIn = Allocation.createSized(mRS, Element.U8(mRS), inputSize);
     64 
     65         Type.Builder tb = new Type.Builder(mRS, Element.RGBA_8888(mRS));
     66         tb.setX(viewWidth);
     67         tb.setY(viewHeight);
     68         Type outType = tb.create();
     69 
     70         mAllocationOut = Allocation.createTyped(mRS, outType,
     71                 Allocation.USAGE_IO_OUTPUT | Allocation.USAGE_SCRIPT);
     72 
     73         ScriptC_callback swizzleScript =
     74                 new ScriptC_callback(mRS, res, R.raw.callback);
     75         swizzleScript.bind_yuv_in(mAllocationIn);
     76         swizzleScript.invoke_init_convert(mWidth, mHeight,
     77             mFormat, viewWidth, viewHeight);
     78         Script.KernelID swizzleId;
     79 
     80         switch (mFormat) {
     81         case ImageFormat.NV21:
     82             swizzleId = swizzleScript.getKernelID_convert_semiplanar();
     83             break;
     84         case ImageFormat.YV12:
     85             swizzleId = swizzleScript.getKernelID_convert_planar();
     86             break;
     87         case ImageFormat.YUY2:
     88             swizzleId = swizzleScript.getKernelID_convert_interleaved();
     89             break;
     90         case ImageFormat.UNKNOWN:
     91         default:
     92             swizzleId = swizzleScript.getKernelID_convert_unknown();
     93         }
     94 
     95         ScriptGroup.Builder b = new ScriptGroup.Builder(rs);
     96         b.addKernel(swizzleId);
     97         mConverter = b.create();
     98 
     99         mConverter.setOutput(swizzleId, mAllocationOut);
    100     }
    101 
    102     public boolean stop() {
    103         synchronized(mTaskLock) {
    104             mDone = true;
    105             long startTime = SystemClock.elapsedRealtime();
    106             while (mTaskInProgress) {
    107                 try {
    108                     mTaskLock.wait(kStopTimeout);
    109                 } catch (InterruptedException e) {
    110                     // ignored, keep waiting
    111                 }
    112                 long endTime = SystemClock.elapsedRealtime();
    113                 if (endTime - startTime > kStopTimeout) {
    114                     return false;
    115                 }
    116             }
    117         }
    118         mAllocationOut.setSurface(null);
    119         return true;
    120     }
    121 
    122     public void displayCallback(byte[] data) {
    123         synchronized(mTaskLock) {
    124             if (mTaskInProgress || mDone) return;
    125             mTaskInProgress = true;
    126         }
    127         if (mCallbackSurface == null) {
    128             mCallbackView.getHolder().setFormat(PixelFormat.RGBA_8888);
    129             mCallbackSurface = mCallbackView.getHolder().getSurface();
    130             if (mCallbackSurface == null) return;
    131             mAllocationOut.setSurface(mCallbackSurface);
    132         }
    133         new ProcessCallbackTask().execute(data);
    134     }
    135 
    136     private class ProcessCallbackTask extends AsyncTask<byte[], Void, Boolean> {
    137 
    138         @Override
    139         protected Boolean doInBackground(byte[]... datas) {
    140             byte[] data = datas[0];
    141 
    142             mAllocationIn.copyFrom(data);
    143             mConverter.execute();
    144             mAllocationOut.ioSend();
    145 
    146             synchronized(mTaskLock) {
    147                 mTaskInProgress = false;
    148                 mTaskLock.notify();
    149             }
    150             return true;
    151         }
    152 
    153         @Override
    154         protected void onPostExecute(Boolean result) {
    155         }
    156     }
    157 
    158 }
    159