Android decodeYUV420SP results in green images?

Question

Ok so my question is pretty much identical to this: Converting preview frame to bitmap

However his answer is no good, and trying to use it doesn't solve my problem.

So what I'm trying to do at the moment is to send each frame as a bitmap to a method to detect if there are any faces, but first I need to create a bitmap which means I have to use the decodeYUV420sp method, which doesn't seem to be working properly and all my images just come out as a green and yellow tie dye looking image. Here is my code:

This is from onPreviewFrame:

    Parameters parameters = cam.getParameters(); 

    Integer width = parameters.getPreviewSize().width;
    Integer height = parameters.getPreviewSize().height;

    Log.i("preview size: ", String.valueOf(width) + "x" + String.valueOf(height));
    int[] mIntArray = new int[width*height];

    // Decode Yuv data to integer array
    decodeYUV420SP(mIntArray, data, width, height);

    //Initialize the bitmap, with the replaced color  
    Bitmap bmp = Bitmap.createBitmap(mIntArray, width, height, Bitmap.Config.ARGB_8888);  

    saveImage(bmp);

This is decodeYUV method:

    static public void decodeYUV420SP(int[] rgba, byte[] yuv420sp, int width,
        int height) {
    final int frameSize = width * height;

    for (int j = 0, yp = 0; j < height; j++) {
        int uvp = frameSize + (j >> 1) * width, u = 0, v = 0;
        for (int i = 0; i < width; i++, yp++) {
            int y = (0xff & ((int) yuv420sp[yp])) - 16;
            if (y < 0)
                y = 0;
            if ((i & 1) == 0) {
                v = (0xff & yuv420sp[uvp++]) - 128;
                u = (0xff & yuv420sp[uvp++]) - 128;
            }

            int y1192 = 1192 * y;
            int r = (y1192 + 1634 * v);
            int g = (y1192 - 833 * v - 400 * u);
            int b = (y1192 + 2066 * u);

            if (r < 0)
                r = 0;
            else if (r > 262143)
                r = 262143;
            if (g < 0)
                g = 0;
            else if (g > 262143)
                g = 262143;
            if (b < 0)
                b = 0;
            else if (b > 262143)
                b = 262143;

            // rgb[yp] = 0xff000000 | ((r << 6) & 0xff0000) | ((g >> 2) &
            // 0xff00) | ((b >> 10) & 0xff);
            // rgba, divide 2^10 ( >> 10)
            rgba[yp] = ((r << 14) & 0xff000000) | ((g << 6) & 0xff0000)
                    | ((b >> 2) | 0xff00);
        }
    }
    }

and this is the method I'm calling to save the bitmaps to see what they look like:

       private void saveImage(Bitmap bmp) {

      File myDir=new File("/sdcard/saved_images");
      myDir.mkdirs();
      Random generator = new Random();
      int n = 10000;
      n = generator.nextInt(n);
      String fname = "Image-"+ n +".jpg";
      File file = new File (myDir, fname);
      if (file.exists ()) file.delete (); 
      try {
           FileOutputStream   out = new FileOutputStream(file);
           bmp.compress(Bitmap.CompressFormat.JPEG, 90, out);
           out.flush();
           out.close();

       } catch (Exception e) {
           e.printStackTrace();
      }
    }

Here is a resulting image: https://docs.google.com/drawings/d/1kyIvb4oHHInW_c71mjfFSVCxVopBgBWX3k1OR_nMgRA/edit

Answer 1

The key point here is that there are a (large) number of different YUV encodings, and an even larger list of names used for them. A lot of information about all the different variants (and their names) is given by fourcc, although 420SP isn't mentionned explicitly. Looking here, it looks like:

• 420P is the same as YV12. 'P' appears to stand for planar: there are three 'planes' of data one after the other: Y, U and then V. (Or, in YV21, which is also a 420P encoding, Y, V and then U.)
• 420SP is the same as NV12 (which is the same as NV21 but with U and V swapped around). 'SP' appears to stand for 'semi-planar', and so '420SP' could, technically, refer to either NV21 or NV12.

In this case, therefore, you are decoding NV12 (as opposed to NV21) and so the order of U and V is swapped around compared to the answer you quote in your answer. In case it helps, I have provided some code here.

Answer 2

Ok so the problem was the decodeYUV method which I got from a different stackoverflow post here: Converting YUV->RGB(Image processing)->YUV during onPreviewFrame in android? didn't quite work.

But I replaced that with what I think must be the original decodeYUV method from here: http://code.google.com/p/android/issues/detail?id=823 an