android - AndroidのonPreviewFrame中にYUV->RGB（画像処理）-> YUVを変換しますか？

Question

SurfaceViewを使用して画像をキャプチャし、パブリックボイドonPreviewFrame4（byte []データ、カメラカメラ）でYuvRawプレビューデータを取得しています

onPreviewFrameで画像の前処理を実行する必要があるため、Yuvプレビューデータを画像の前処理よりもRGBデータに変換して、Yuvデータに戻す必要があります。

私は次のようにYuvデータをRGBにエンコードおよびデコードするための両方の関数を使用しました：

public void onPreviewFrame(byte[] data, Camera camera) {
    Point cameraResolution = configManager.getCameraResolution();
    if (data != null) {
        Log.i("DEBUG", "data Not Null");

                // Preprocessing
                Log.i("DEBUG", "Try For Image Processing");
                Camera.Parameters mParameters = camera.getParameters();
                Size mSize = mParameters.getPreviewSize();
                int mWidth = mSize.width;
                int mHeight = mSize.height;
                int[] mIntArray = new int[mWidth * mHeight];

                // Decode Yuv data to integer array
                decodeYUV420SP(mIntArray, data, mWidth, mHeight);

                // Converting int mIntArray to Bitmap and 
                // than image preprocessing 
                // and back to mIntArray.

                // Encode intArray to Yuv data
                encodeYUV420SP(data, mIntArray, mWidth, mHeight);
                    }
}

    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);
        }
    }
}


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

    int[] U, V;
    U = new int[frameSize];
    V = new int[frameSize];

    final int uvwidth = width / 2;

    int r, g, b, y, u, v;
    for (int j = 0; j < height; j++) {
        int index = width * j;
        for (int i = 0; i < width; i++) {
            r = (rgba[index] & 0xff000000) >> 24;
            g = (rgba[index] & 0xff0000) >> 16;
            b = (rgba[index] & 0xff00) >> 8;

            // rgb to yuv
            y = (66 * r + 129 * g + 25 * b + 128) >> 8 + 16;
            u = (-38 * r - 74 * g + 112 * b + 128) >> 8 + 128;
            v = (112 * r - 94 * g - 18 * b + 128) >> 8 + 128;

            // clip y
            yuv420sp[index++] = (byte) ((y < 0) ? 0 : ((y > 255) ? 255 : y));
            U[index] = u;
            V[index++] = v;
        }
    }

問題は、Yuvデータのエンコードとデコードに誤りがある可能性があることです。前処理ステップをスキップすると、エンコードされたYuvデータもPreviewCallbackの元のデータと異なるためです。

この問題の解決にご協力ください。このコードをOCRスキャンで使用する必要があるため、このタイプのロジックを実装する必要があります。

同じことをする他の方法があれば、私に提供してください。

前もって感謝します。:)

score 50 · Accepted Answer

ドキュメントには、画像データがカメラから到着する形式を設定できることが示されていますが、実際には、多くの場合、NV21、YUV形式のいずれかを選択できます。この形式に関する多くの情報については、 http ：//www.fourcc.org/yuv.php#NV21を参照してください。また、RGBへの変換の背後にある理論については、http：//www.fourcc.org/fccyvrgb.phpを参照してください。AndroidカメラのNV21形式から白黒画像を抽出するに画像ベースの説明があります。ウィキペディアのページに、このテーマに関するAndroid固有のセクションがあります（@AlexCohnに感謝）：YUV＃Y'UV420sp（NV21）からRGBへの変換（Android）。

ただし、onPreviewFrameルーチンを設定すると、それが送信するバイト配列から有用なデータに移動するメカニズムは、やや不明確です。API 8以降、画像のJPEGをホライズするByteStreamに到達するために、次のソリューションが利用可能になります（compressToJpegは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);

このJPEGは、必要な形式に変換する必要がある場合があります。ビットマップが必要な場合：

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

何らかの理由でこれを実行できない場合は、手動で変換を実行できます。これを行う際に克服すべきいくつかの問題：

データはバイト配列で到着します。定義上、バイトは符号付き数値です。つまり、-128から127になります。ただし、データは実際には符号なしバイト（0から255）です。これが処理されない場合、結果はいくつかの奇妙なクリッピング効果を持つ運命にあります。
データは非常に特定の順序であり（前述のWebページのとおり）、各ピクセルを注意深く抽出する必要があります。
たとえば、各ピクセルをビットマップの適切な場所に配置する必要があります。これには、データのバッファを構築し、そこからビットマップを埋めるという、かなり厄介な（私の見解では）アプローチも必要です。
原則として、値は[16..240]に格納する必要がありますが、に送信されるデータには[0..255]で格納されているようです。onPreviewFrame
この問題に関するほぼすべてのWebページは、[16..240]と[0..255]のオプションを考慮しても、異なる係数を提案しています。
実際にNV12（YUV420の別のバリアント）を使用している場合は、読み取りをUとVに交換する必要があります。

私は解決策（うまくいくようです）を提示し、修正、改善、および全体の実行コストを削減する方法を要求します。速度を最適化するのではなく、何が起こっているのかを明確にするために設定しました。プレビュー画像のサイズのビットマップを作成します。

データ変数は、への呼び出しから来ていますonPreviewFrame

// Define whether expecting [16..240] or [0..255]
boolean dataIs16To240 = false;

// 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;

// Holding variables for the loop calculation
int R = 0;
int G = 0;
int B = 0;

// 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
        float Y = (float) (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;

        if (dataIs16To240) {
            // Correct Y to allow for the fact that it is [16..235] and not [0..255]
            Y = 1.164*(Y - 16.0);

            // Do the YUV -> RGB conversion
            // These seem to work, but other variations are quoted
            // out there.
            R = (int)(Yf + 1.596f*V);
            G = (int)(Yf - 0.813f*V - 0.391f*U);
            B = (int)(Yf            + 2.018f*U);
        }
        else {
            // No need to correct Y
            // These are the coefficients proposed by @AlexCohn
            // for [0..255], as per the wikipedia page referenced
            // above
            R = (int)(Yf + 1.370705f*V);
            G = (int)(Yf - 0.698001f*V - 0.337633f*U);
            B = (int)(Yf               + 1.732446f*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);

@Timmmmが以下で指摘しているように、スケーリング係数を1000で乗算し（つまり、1.164は1164になります）、最終結果を1000で除算することにより、intで変換を行うことができます。

score 18 · Accepted Answer

カメラプレビューでRGB画像を提供するように指定してみませんか？

つまり、 Camera.Parameters.setPreviewFormat（ImageFormat.RGB_565） ;

score 7 · Accepted Answer

RenderScript->ScriptIntrinsicYuvToRGBを使用できます

Kotlinサンプル

val rs = RenderScript.create(CONTEXT_HERE)
val yuvToRgbIntrinsic = ScriptIntrinsicYuvToRGB.create(rs, Element.U8_4(rs))

val yuvType = Type.Builder(rs, Element.U8(rs)).setX(byteArray.size)
val inData = Allocation.createTyped(rs, yuvType.create(), Allocation.USAGE_SCRIPT)

val rgbaType = Type.Builder(rs, Element.RGBA_8888(rs)).setX(width).setY(height)
val outData = Allocation.createTyped(rs, rgbaType.create(), Allocation.USAGE_SCRIPT)

inData.copyFrom(byteArray)

yuvToRgbIntrinsic.setInput(inData)
yuvToRgbIntrinsic.forEach(outData)

val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
outData.copyTo(bitmap)

score 5 · Accepted Answer

Samsung S4 miniでのいくつかのテストの後、最速のコードは（Neilの[floats！]より120％速く、元のHiteshより30％速い）：

static public void decodeYUV420SP(int[] rgba, byte[] yuv420sp, int width,
                                  int height) {


    final int frameSize = width * height;
// define variables before loops (+ 20-30% faster algorithm o0`)
int r, g, b, y1192, y, i, uvp, u, v;
        for (int j = 0, yp = 0; j < height; j++) {
            uvp = frameSize + (j >> 1) * width;
            u = 0;
        v = 0;
        for (i = 0; i < width; i++, yp++) {
            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;
            }

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

// Java's functions are faster then 'IFs'
                    r = Math.max(0, Math.min(r, 262143));
                g = Math.max(0, Math.min(g, 262143));
                b = Math.max(0, Math.min(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);
            }
        }
    }

速度は、出力としてByteArrayOutputStreamを使用するYuvImage.compressToJpeg（）に匹敵します（640x480イメージの場合は30〜50ミリ秒）。

結果： Samsung S4 mini（2x1.7GHz）はリアルタイムでJPEGに圧縮/ YUVをRGBに変換できません（640x480 @ 30fps）

score 5 · Accepted Answer

Javaの実装はcバージョンの10倍遅いので、GPUImageライブラリを使用するか、コードのこの部分を移動することをお勧めします。

GPUImageのAndroidバージョンがあります： https ：//github.com/CyberAgent/android-gpuimage

gradleを使用する場合は、このライブラリを含めて、次のメソッドを呼び出すことができます。GPUImageNativeLibrary.YUVtoRBGA（inputArray、WIDTH、HEIGHT、outputArray）;

時間を比較します。960x540のNV21イメージの場合、上記のJavaコードを使用すると、200ミリ秒以上かかり、GPUImageバージョンではわずか10ミリ秒から20ミリ秒です。

score 1 · Accepted Answer

上記のコードスニペットを修正する

static public void decodeYUV420SP(int[] rgba, byte[] yuv420sp, int width,
                              int height) {
    final int frameSize = width * height;
    int r, g, b, y1192, y, i, uvp, u, v;
    for (int j = 0, yp = 0; j < height; j++) {
        uvp = frameSize + (j >> 1) * width;
        u = 0;
        v = 0;
        for (i = 0; i < width; i++, yp++) {
            y = (0xff & ((int) yuv420sp[yp])) - 16;
            if (y < 0)
                y = 0;
            if ((i & 1) == 0) {
            // above answer is wrong at the following lines. just swap ***u*** and ***v*** 
                u = (0xff & yuv420sp[uvp++]) - 128;
                v = (0xff & yuv420sp[uvp++]) - 128;
            }

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

            r = Math.max(0, Math.min(r, 262143));
            g = Math.max(0, Math.min(g, 262143));
            b = Math.max(0, Math.min(b, 262143));

            // combine ARGB
            rgba[yp] = 0xff000000 | ((r << 6) & 0xff0000) | ((g >> 2) & 0xff00)
                    | ((b >> 10) | 0xff);
        }
    }
}

score 1 · Accepted Answer

JellyBean 4.2（Api 17以降）に付属しているRenderScriptScriptIntrinsicYuvToRGBを試してください。

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

Nexus 7（2013、JellyBean 4.3）では、1920x1080の画像変換（フルHDカメラプレビュー）に約7ミリ秒かかります。

score 0 · Accepted Answer

TextureViewから直接ビットマップを取得できます。これは本当に速いです。

Bitmap bitmap = textureview.getBitmap()

score 0 · Accepted Answer

多くの提案されたリンクや記事などを読んだ後、カメラからYUV画像をキャプチャしてRGBビットマップに変換する次の素晴らしいAndroidサンプルアプリを見つけました。

https://github.com/android/camera-samples/tree/main/CameraXTfLite

これについての良いこと：

前述のRenderScriptフレームワークを使用しており、コードは簡単に再利用できます。YuvToRgbConverter.ktクラスを確認してください。
彼らのドキュメントによると、このコードは「Pixel3スマートフォンで最大30FPS@640x480」を達成します

このコード（特にYUVからRGBへの変換部分）に切り替えた後、私のフレームレートは2倍になりました！画像をキャプチャした後、もう少し多くのことをしているので、全体で30 FPSに達することはありませんが、スピードアップは驚くべきものです。

android - AndroidのonPreviewFrame中にYUV->RGB（画像処理）-> YUVを変換しますか？

9 に答える 9

Related

Reference