Die Umwandlung YUV- > RGB(Image processing)->YUV während onPreviewFrame in android?

Obwohl die Dokumentation legt nahe, dass Sie können festlegen, welches format das Bild sollten die Daten kommen von der Kamera, in der Praxis hat man oft eine Auswahl von ein: NV21, ein YUV-format. Für viele Informationen zu diesem format finden Sie unter http://www.fourcc.org/yuv.php#NV21 und für Informationen über die Theorie hinter dem umwandeln in RGB sehen http://www.fourcc.org/fccyvrgb.php. Es ist ein Bild basierend Erklärung an Extrahieren schwarz und weiß-Bild von android-Kamera NV21-format.

Einem anderen format, genannt YUV420SP, ist auch Recht weit verbreitet.

Jedoch, sobald Sie eingerichtet haben, ist Ihre onPreviewFrame routine, die mechanik, die von dem byte-array sendet es Ihnen, die nützliche Daten hat, ist etwas, hmmm, ist unklar. Aus der API, 8. die folgende Lösung ist verfügbar, um auf einem ByteStream holiding ein JPEG des Bildes (compressToJpeg ist die einzige Konvertierungs-option angeboten YuvImage):

//pWidth and pHeight define the size of the preview Frame
ByteArrayOutputStream out = new ByteArrayOutputStream();

//Alter the second parameter of this to the actual format you are receiving
YuvImage yuv = new YuvImage(data, ImageFormat.NV21, pWidth, pHeight, null);

//bWidth and bHeight define the size of the bitmap you wish the fill with the preview image
yuv.compressToJpeg(new Rect(0, 0, bWidth, bHeight), 50, out);

Diese JPEG-müssen dann konvertiert werden in das format, das Sie möchten. Wenn Sie möchten, eine Bitmap:

byte[] bytes = out.toByteArray();
Bitmap bitmap= BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

Wenn, aus welchem Grund auch immer, Sie sind nicht in der Lage, dies zu tun, können Sie die Konvertierung manuell aus. Einige Probleme, die es zu überwinden dies zu tun:

1. Den Empfang der Daten in einem byte-array. Per definition sind die bytes zahlen unterzeichnet, was bedeutet, dass Sie gehen von -128 bis 127. Die Daten werden jedoch ist es eigentlich ein unsigned Byte (0 bis 255). Wenn dies nicht behandelt, das Ergebnis ist dazu verdammt, Sie zu haben, zu einigen seltsamen clipping-Effekte.

2. Werden die Daten in einer ganz bestimmten Reihenfolge (wie in der zuvor beschriebenen web-Seite), und jedes pixel muss extrahiert werden gezielt.

3. Jedes pixel muss in die richtige Stelle auf eine bitmap zu sagen. Dies erfordert auch eine eher chaotisch (aus meiner Sicht) Ansatz der Bau-Puffer mit den Daten, und dann füllen Sie eine bitmap aus.

4. Wenn Sie tatsächlich bekommen habe NV12 (oder 420SP), dann müssen Sie tauschen das liest sich für U und V.

Präsentiere ich eine Lösung (die scheint zu funktionieren), mit Anfragen für Korrekturen, Verbesserungen und Möglichkeiten, wie sich die ganze Sache weniger teuer zu laufen. Es erstellt ein bitmap der Größe des Vorschau-Bildes:

Daten variable kommt aus dem Aufruf onPreviewFrame

//the bitmap we want to fill with the image
Bitmap bitmap = Bitmap.createBitmap(imageWidth, imageHeight, Bitmap.Config.ARGB_8888);
int numPixels = imageWidth*imageHeight;

//the buffer we fill up which we then fill the bitmap with
IntBuffer intBuffer = IntBuffer.allocate(imageWidth*imageHeight);
//If you're reusing a buffer, next line imperative to refill from the start,
//if not good practice
intBuffer.position(0);

//Set the alpha for the image: 0 is transparent, 255 fully opaque
final byte alpha = (byte) 255;

//Get each pixel, one at a time
for (int y = 0; y < imageHeight; y++) {
    for (int x = 0; x < imageWidth; x++) {
        //Get the Y value, stored in the first block of data
        //The logical "AND 0xff" is needed to deal with the signed issue
        int Y = data[y*imageWidth + x] & 0xff;

        //Get U and V values, stored after Y values, one per 2x2 block
        //of pixels, interleaved. Prepare them as floats with correct range
        //ready for calculation later.
        int xby2 = x/2;
        int yby2 = y/2;

        //make this V for NV12/420SP
        float U = (float)(data[numPixels + 2*xby2 + yby2*imageWidth] & 0xff) - 128.0f;

        //make this U for NV12/420SP
        float V = (float)(data[numPixels + 2*xby2 + 1 + yby2*imageWidth] & 0xff) - 128.0f;

        //Do the YUV -> RGB conversion
        float Yf = 1.164f*((float)Y) - 16.0f;
        int R = (int)(Yf + 1.596f*V);
        int G = (int)(Yf - 0.813f*V - 0.391f*U);
        int B = (int)(Yf            + 2.018f*U);

        //Clip rgb values to 0-255
        R = R < 0 ? 0 : R > 255 ? 255 : R;
        G = G < 0 ? 0 : G > 255 ? 255 : G;
        B = B < 0 ? 0 : B > 255 ? 255 : B;

        //Put that pixel in the buffer
        intBuffer.put(alpha*16777216 + R*65536 + G*256 + B);
    }
}

//Get buffer ready to be read
intBuffer.flip();

//Push the pixel information from the buffer onto the bitmap.
bitmap.copyPixelsFromBuffer(intBuffer);

Als @Timmmm Punkte out unten, Sie könnte die Konvertierung in int, das durch die Multiplikation der Skalierung der Faktoren von 1000 (ie. 1.164 wird 1164) und dann dividng das Ergebnis durch 1000.

InformationsquelleAutor der Antwort Neil Townsend

Java-Implementierung ist 10 mal langsamer als die c-version ist, schlage ich vor, Sie GPUImage Bibliothek oder bewegen Sie einfach diesen Teil des Codes.

Gibt es eine android-version von GPUImage:
https://github.com/CyberAgent/android-gpuimage

Können Sie diese Bibliothek, wenn Sie gradle, und rufen Sie die Methode:
GPUImageNativeLibrary.YUVtoRBGA( inputArray, BREITE, HÖHE, outputArray);

Vergleiche ich die Zeit, für ein NV21 Bild, das 960x540, verwenden Sie obigen java-code, kostet es 200ms+, mit GPUImage version, nur 10ms~20ms.

InformationsquelleAutor der Antwort promenade

Versuchen RenderScript ScriptIntrinsicYuvToRGB, die kommt mit JellyBean 4.2 (Api 17+).

https://developer.android.com/reference/android/renderscript/ScriptIntrinsicYuvToRGB.html

Auf dem Nexus 7 (2013, JellyBean 4.3) ein 1920x1080 Bild-Konvertierung (full-HD-Kamera-Vorschau) dauert etwa 7 ms.

InformationsquelleAutor der Antwort Matti81