void copyToDebugSurface() {
        if (!mOutputSurface.get()) return;

        size_t bufferSize = mLockedBuffer.height * mLockedBuffer.stride *
                            PIXEL_SIZE;

        ANativeWindow_Buffer outBuffer;
        ARect outBufferBounds;
        mOutputSurface->lock(&outBuffer, &outBufferBounds);
        ASSERT_EQ(mLockedBuffer.width, outBuffer.width);
        ASSERT_EQ(mLockedBuffer.height, outBuffer.height);
        ASSERT_EQ(mLockedBuffer.stride, outBuffer.stride);

        if (mLockedBuffer.format == outBuffer.format) {
            memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
        } else {
            ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_RGBA_8888);
            ASSERT_EQ(mLockedBuffer.dataSpace, HAL_DATASPACE_SRGB);
            ASSERT_EQ(outBuffer.format, PIXEL_FORMAT_RGBA_8888);
            uint8_t* outPointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
            for (int y = 0; y < outBuffer.height; ++y) {
                int rowOffset = y * outBuffer.stride; // pixels
                for (int x = 0; x < outBuffer.width; ++x) {
                    int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes

                    // RGB are converted
                    for (int c = 0; c < (PIXEL_SIZE - 1); ++c) {
                        outPointer[colOffset + c] = srgbToLinear(
                                                        mLockedBuffer.data[colOffset + c]);
                    }

                    // Alpha isn't converted
                    outPointer[colOffset + 3] =
                        mLockedBuffer.data[colOffset + 3];
                }
            }
        }
        mOutputSurface->unlockAndPost();

        int sleepSeconds = atoi(getenv(SHOW_DEBUG_STRING));
        sleep(sleepSeconds);
    }
 static uint8_t srgbToLinear(uint8_t u) {
     float f = u / 255.0f;
     return static_cast<uint8_t>(srgbToLinear(f) * 255.0f + 0.5f);
 }