如何在 C/C++ 中增强这个 YUV420P 到 RGB 的转换？

Question

我正在尝试将 YUV420P 写入 RGB888，因为当我将整个东西作为一个巨大的缓冲区时， Y （大小width*height ）然后是Cr （大小width*height/4 ）然后是Cb （大小width*height/4 ）。 output 应该是大小width*height*3的 RGB 缓冲区。

我觉得我下面的 function 效率很低。 例如，我使用天花板 function （它不应该返回一个 int 吗？在我的情况下它返回一个 double，为什么？）我从未见过任何颜色转换 function 使用这个 ZC1C425268E687A94F1C 但这是我发现为每个Y获取相应Cr和Cb的方式。

JNIEXPORT void JNICALL Java_com_example_mediacodecdecoderexample_YuvToRgb_YUVtoRBGA2(JNIEnv * env, jobject obj, jbyteArray yuv420sp, jint width, jint height, jbyteArray rgbOut)
{
    //ITU-R BT.601 conversion
    //
    //     R = 1.164*(Y-16)+1.596*(Cr-128)
    //     G = 1.164*(Y-16)-0.392*(Cb-128)-0.813*(Cr-128)
    //     B = 1.164*(Y-16)+2.017*(Cb-128)
    //
    int Y;
    int Cr;
    int Cb;
    int R;
    int G;
    int B;
    int size = width * height;
    //After width*height luminance values we have the Cr values
    size_t CrBase = size;
    //After width*height luminance values + width*height/4 we have the Cb values
    size_t CbBase = size + width*height/4;
    jbyte *rgbData = (jbyte*) ((*env)->GetPrimitiveArrayCritical(env, rgbOut, 0));
    jbyte* yuv = (jbyte*) (*env)->GetPrimitiveArrayCritical(env, yuv420sp, 0);

    for (int i=0; i<size; i++) {
        Y  = rgbData[i] - 16;
        Cr = rgbData[CrBase + ceil(i/4)]  - 128;
        Cb = rgbData[CbBase + ceil(i/4)]  - 128;
        R = 1.164*Y+1.596*Cr;
        G = 1.164*Y-0.392*Cb-0.813*Cr;
        B = 1.164*Y+2.017*Cb;
        yuv[i*3] = R;
        yuv[i*3+1] = G;
        yuv[i*3+2] = B;
    }

    (*env)->ReleasePrimitiveArrayCritical(env, rgbOut, rgbData, 0);
    (*env)->ReleasePrimitiveArrayCritical(env, yuv420sp, yuv, 0);
}

我这样做是因为我还没有找到一个 function 可以做到这一点，我需要一个用于 MediaCodec 解码缓冲区。 但即使有，我也想知道可以做些什么来改进我的 function，只是为了学习。

更新：

我根据以下答案修改了代码，以使其与 ByteBuffer 一起使用：

JNIEXPORT void JNICALL Java_com_lucaszanella_mediacodecdecoderexample_YuvToRgb_YUVtoRBGA2(JNIEnv * env, jobject obj, jobject yuv420sp, jint width, jint height, jobject rgbOut)
{
    //ITU-R BT.601 conversion
    //
    //     R = 1.164*(Y-16)+1.596*(Cr-128)
    //     G = 1.164*(Y-16)-0.392*(Cb-128)-0.813*(Cr-128)
    //     B = 1.164*(Y-16)+2.017*(Cb-128)
    //

    char *rgbData = (char*)(*env)->GetDirectBufferAddress(env, rgbOut);
    char *yuv = (char*)(*env)->GetDirectBufferAddress(env, yuv420sp);

    const int size = width * height;

    //After width*height luminance values we have the Cr values
    const size_t CrBase = size;

    //After width*height luminance values + width*height/4 we have the Cb values
    const size_t CbBase = size + width*height/4;

    for (int i=0; i<size; i++) {
        int Y  = yuv[i] - 16;
        int Cr = yuv[CrBase + i/4]  - 128;
        int Cb = yuv[CbBase + i/4]  - 128;

        double R = 1.164*Y+1.596*Cr;
        double G = 1.164*Y-0.392*Cb-0.813*Cr;
        double B = 1.164*Y+2.017*Cb;

        rgbData[i*3] = (R > 255) ? 255 : ((R < 0) ? 0 : R);
        rgbData[i*3+1] = (G > 255) ? 255 : ((G < 0) ? 0 : G);
        rgbData[i*3+2] = (B > 255) ? 255 : ((B < 0) ? 0 : B);
    }
}

但是它正在崩溃。 我没有看到任何东西被写在边界之外。 有人知道吗？

更新：

如果我们使用直接字节缓冲区调用上面的代码，它就可以工作。 如果缓冲区不是直接的，则将不起作用。

添加

    if (rgbData==NULL) {
        __android_log_print(ANDROID_LOG_ERROR, "TRACKERS", "%s", "RGB data null");
    }

    if (yuv==NULL) {
        __android_log_print(ANDROID_LOG_ERROR, "TRACKERS", "%s", "yuv data null");
    }
    if (rgbData==NULL || yuv==NULL) {
        return;
    }

为了安全。

无论如何，颜色不正确：

Answer 1

只是我，但你不应该从yuv数组中读取并写入rgbData数组吗？ 你实际上在你的实现中把它颠倒了。

不需要在 integer 表达式（例如i/4 ）上调用ceil 。 而且，当您实现图像处理路线时，对每个像素调用 function 只会降低性能（去过那里，做到了）。 也许编译器可以优化它，但为什么要抓住这个机会。

所以改变这个：

    Cr = rgbData[CrBase + ceil(i/4)]  - 128;
    Cb = rgbData[CbBase + ceil(i/4)]  - 128;

对此：

    Cr = rgbData[CrBase + i/4]  - 128;
    Cb = rgbData[CbBase + i/4]  - 128;

唯一需要注意的另一件事是，在分配回yuv数组之前，您可能希望将R 、 G和B限制在 8 位字节范围内。 这些数学方程式可以产生< 0和> 255的结果。

另一个微优化是在 for 循环块中声明所有变量，以便编译器有更多关于优化它作为临时变量的提示。 并将您的其他一些常量声明为const我建议：

JNIEXPORT void JNICALL Java_com_example_mediacodecdecoderexample_YuvToRgb_YUVtoRBGA2(JNIEnv * env, jobject obj, jbyteArray yuv420sp, jint width, jint height, jbyteArray rgbOut)
{
    //ITU-R BT.601 conversion
    //
    //     R = 1.164*(Y-16)+1.596*(Cr-128)
    //     G = 1.164*(Y-16)-0.392*(Cb-128)-0.813*(Cr-128)
    //     B = 1.164*(Y-16)+2.017*(Cb-128)
    //
    const int size = width * height;
    //After width*height luminance values we have the Cr values

    const size_t CrBase = size;
    //After width*height luminance values + width*height/4 we have the Cb values

    const size_t CbBase = size + width*height/4;

    jbyte *rgbData = (jbyte*) ((*env)->GetPrimitiveArrayCritical(env, rgbOut, 0));
    jbyte* yuv= (jbyte*) (*env)->GetPrimitiveArrayCritical(env, yuv420sp, 0);

    for (int i=0; i<size; i++) {
        int Y  = yuv[i] - 16;
        int Cr = yuv[CrBase + i/4]  - 128;
        int Cb = yuv[CbBase + i/4]  - 128;

        int R = 1.164*Y+1.596*Cr;
        int G = 1.164*Y-0.392*Cb-0.813*Cr;
        int B = 1.164*Y+2.017*Cb;

        rgbData[i*3] = (R > 255) ? 255 : ((R < 0) ? 0 : R);
        rgbData[i*3+1] = (G > 255) ? 255 : ((G < 0) ? 0 : G);
        rgbData[i*3+2] = (B > 255) ? 255 : ((B < 0) ? 0 : B);
    }

    (*env)->ReleasePrimitiveArrayCritical(env, rgbOut, rgbData, 0);
    (*env)->ReleasePrimitiveArrayCritical(env, yuv420sp, yuv, 0);
}

那么剩下要做的就是在最大优化的情况下进行编译。 编译器将处理 rest。

之后，研究 SIMD 优化，一些编译器作为编译器开关提供（或通过编译指示启用）。

Answer 2

对 selbie 的答案稍作修改，它使用ByteBuffer更有用，因为它是 Java 在解码时产生的。

JNIEXPORT void JNICALL Java_com_example_mediacodecdecoderexample_YuvToRgb_YUVtoRBGA2(JNIEnv * env, jobject obj, jobject yuv420sp, jint width, jint height, jobject rgbOut)
{
    //ITU-R BT.601 conversion
    //
    //     R = 1.164*(Y-16)+1.596*(Cr-128)
    //     G = 1.164*(Y-16)-0.392*(Cb-128)-0.813*(Cr-128)
    //     B = 1.164*(Y-16)+2.017*(Cb-128)
    //
    const int size = width * height;
    
    //After width*height luminance values we have the Cr values
    const size_t CrBase = size;
    
    //After width*height luminance values + width*height/4 we have the Cb values
    const size_t CbBase = size + width*height/4;

    jbyte *rgbData = (*env)->GetDirectBufferAddress(env, rgbOut);
    jbyte *yuv = (*env)->GetDirectBufferAddress(env, yuv420sp);

    for (int i=0; i<size; i++) {
        int Y  = yuv[i] - 16;
        int Cr = yuv[CrBase + i/4]  - 128;
        int Cb = yuv[CbBase + i/4]  - 128;

        int R = 1.164*Y+1.596*Cr;
        int G = 1.164*Y-0.392*Cb-0.813*Cr;
        int B = 1.164*Y+2.017*Cb;

        rgbData[i*3] = (R > 255) ? 255 : ((R < 0) ? 0 : R);
        rgbData[i*3+1] = (G > 255) ? 255 : ((G < 0) ? 0 : G);
        rgbData[i*3+2] = (B > 255) ? 255 : ((B < 0) ? 0 : B);
    }
}

Answer 3

关于：

*I use the ceiling function (shouldn't it return an int? In my case it's returning a double, why?)*

这是语法：

double ceil(double x);

注意返回的类型是double

ceil() 的 MAN 页面

Answer 4

不要自己做。 不要直接在 C++ 中这样做。 唯一合适的方法是为此使用硬件加速。 您将节省大量电池。

基本上你可以利用 OpenGL 来代替你使用硬件。

很久以前我为 iOS 做过这个，我确信 Android 的解决方案会非常相似。 可悲的是，我（在旧公司）留下了代码，所以我无法为您提供示例代码。 如果我发现有用的东西，那么我会更新这个答案。 在我的代码中，YUV（以及其他几种颜色格式）直接在 openGL 视图上呈现，并且 OpenGL 进行了所需的转换。

现在我只是指指点点 OpenGL 因为其他答案直接在 CPU 上执行此操作，这是一个糟糕的选择，因为它会消耗大量电池并且您永远不会以这种方式获得所需的性能。

编辑：我在 SO 上发现了类似的问题，例如： https://stackoverflow.com/a/17110754/1387438

免责声明：未验证此示例是否是最佳方法，但这是开始寻找更好解决方案的好方法。

---

如果由于某种原因您需要在 C++ 代码中执行此操作，那么放弃浮点运算以支持 integer 类型的运算。