| /* |
| * Copyright 2023 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifdef _WIN32 |
| #include <Windows.h> |
| #else |
| #include <sys/time.h> |
| #endif |
| |
| #include <string.h> |
| |
| #include <algorithm> |
| #include <cmath> |
| #include <fstream> |
| #include <iostream> |
| |
| #include "ultrahdr/ultrahdrcommon.h" |
| #include "ultrahdr/gainmapmath.h" |
| #include "ultrahdr/jpegr.h" |
| |
| using namespace ultrahdr; |
| |
| const float BT601YUVtoRGBMatrix[9] = { |
| 1, 0, 1.402, 1, (-0.202008 / 0.587), (-0.419198 / 0.587), 1.0, 1.772, 0.0}; |
| const float BT709YUVtoRGBMatrix[9] = { |
| 1, 0, 1.5748, 1, (-0.13397432 / 0.7152), (-0.33480248 / 0.7152), 1.0, 1.8556, 0.0}; |
| const float BT2020YUVtoRGBMatrix[9] = { |
| 1, 0, 1.4746, 1, (-0.11156702 / 0.6780), (-0.38737742 / 0.6780), 1, 1.8814, 0}; |
| |
| const float BT601RGBtoYUVMatrix[9] = { |
| 0.299, 0.587, 0.114, (-0.299 / 1.772), (-0.587 / 1.772), 0.5, 0.5, (-0.587 / 1.402), |
| (-0.114 / 1.402)}; |
| const float BT709RGBtoYUVMatrix[9] = {0.2126, |
| 0.7152, |
| 0.0722, |
| (-0.2126 / 1.8556), |
| (-0.7152 / 1.8556), |
| 0.5, |
| 0.5, |
| (-0.7152 / 1.5748), |
| (-0.0722 / 1.5748)}; |
| const float BT2020RGBtoYUVMatrix[9] = {0.2627, |
| 0.6780, |
| 0.0593, |
| (-0.2627 / 1.8814), |
| (-0.6780 / 1.8814), |
| 0.5, |
| 0.5, |
| (-0.6780 / 1.4746), |
| (-0.0593 / 1.4746)}; |
| |
| int optind_s = 1; |
| int optopt_s = 0; |
| char* optarg_s = nullptr; |
| |
| int getopt_s(int argc, char* const argv[], char* ostr) { |
| if (optind_s >= argc) return -1; |
| |
| const char* arg = argv[optind_s]; |
| if (arg[0] != '-' || !arg[1]) { |
| std::cerr << "invalid option " << arg << std::endl; |
| return '?'; |
| } |
| optopt_s = arg[1]; |
| char* oindex = strchr(ostr, optopt_s); |
| if (!oindex) { |
| std::cerr << "unsupported option " << arg << std::endl; |
| return '?'; |
| } |
| if (oindex[1] != ':') { |
| optarg_s = nullptr; |
| return optopt_s; |
| } |
| |
| if (argc > ++optind_s) { |
| optarg_s = (char*)argv[optind_s++]; |
| } else { |
| std::cerr << "option " << arg << " requires an argument" << std::endl; |
| optarg_s = nullptr; |
| return '?'; |
| } |
| return optopt_s; |
| } |
| |
| // #define PROFILE_ENABLE 1 |
| #ifdef _WIN32 |
| class Profiler { |
| public: |
| void timerStart() { QueryPerformanceCounter(&mStartingTime); } |
| |
| void timerStop() { QueryPerformanceCounter(&mEndingTime); } |
| |
| int64_t elapsedTime() { |
| LARGE_INTEGER frequency; |
| LARGE_INTEGER elapsedMicroseconds; |
| QueryPerformanceFrequency(&frequency); |
| elapsedMicroseconds.QuadPart = mEndingTime.QuadPart - mStartingTime.QuadPart; |
| return (double)elapsedMicroseconds.QuadPart / (double)frequency.QuadPart * 1000000; |
| } |
| |
| private: |
| LARGE_INTEGER mStartingTime; |
| LARGE_INTEGER mEndingTime; |
| }; |
| #else |
| class Profiler { |
| public: |
| void timerStart() { gettimeofday(&mStartingTime, nullptr); } |
| |
| void timerStop() { gettimeofday(&mEndingTime, nullptr); } |
| |
| int64_t elapsedTime() { |
| struct timeval elapsedMicroseconds; |
| elapsedMicroseconds.tv_sec = mEndingTime.tv_sec - mStartingTime.tv_sec; |
| elapsedMicroseconds.tv_usec = mEndingTime.tv_usec - mStartingTime.tv_usec; |
| return elapsedMicroseconds.tv_sec * 1000000 + elapsedMicroseconds.tv_usec; |
| } |
| |
| private: |
| struct timeval mStartingTime; |
| struct timeval mEndingTime; |
| }; |
| #endif |
| |
| static bool loadFile(const char* filename, void*& result, int length) { |
| std::ifstream ifd(filename, std::ios::binary | std::ios::ate); |
| if (ifd.good()) { |
| int size = ifd.tellg(); |
| if (size < length) { |
| std::cerr << "requested to read " << length << " bytes from file : " << filename |
| << ", file contains only " << size << " bytes" << std::endl; |
| return false; |
| } |
| ifd.seekg(0, std::ios::beg); |
| result = malloc(length); |
| if (result == nullptr) { |
| std::cerr << "failed to allocate memory to store contents of file : " << filename |
| << std::endl; |
| return false; |
| } |
| ifd.read(static_cast<char*>(result), length); |
| return true; |
| } |
| std::cerr << "unable to open file : " << filename << std::endl; |
| return false; |
| } |
| |
| static bool writeFile(const char* filename, void*& result, int length) { |
| std::ofstream ofd(filename, std::ios::binary); |
| if (ofd.is_open()) { |
| ofd.write(static_cast<char*>(result), length); |
| return true; |
| } |
| std::cerr << "unable to write to file : " << filename << std::endl; |
| return false; |
| } |
| |
| class UltraHdrAppInput { |
| public: |
| UltraHdrAppInput(const char* p010File, const char* yuv420File, const char* yuv420JpegFile, |
| size_t width, size_t height, |
| ultrahdr_color_gamut p010Cg = ULTRAHDR_COLORGAMUT_BT709, |
| ultrahdr_color_gamut yuv420Cg = ULTRAHDR_COLORGAMUT_BT709, |
| ultrahdr_transfer_function tf = ULTRAHDR_TF_HLG, int quality = 100, |
| ultrahdr_output_format of = ULTRAHDR_OUTPUT_HDR_HLG) |
| : mP010File(p010File), |
| mYuv420File(yuv420File), |
| mYuv420JpegFile(yuv420JpegFile), |
| mJpegRFile(nullptr), |
| mWidth(width), |
| mHeight(height), |
| mP010Cg(p010Cg), |
| mYuv420Cg(yuv420Cg), |
| mTf(tf), |
| mQuality(quality), |
| mOf(of), |
| mMode(0){}; |
| |
| UltraHdrAppInput(const char* jpegRFile, ultrahdr_output_format of = ULTRAHDR_OUTPUT_HDR_HLG) |
| : mP010File(nullptr), |
| mYuv420File(nullptr), |
| mJpegRFile(jpegRFile), |
| mWidth(0), |
| mHeight(0), |
| mP010Cg(ULTRAHDR_COLORGAMUT_UNSPECIFIED), |
| mYuv420Cg(ULTRAHDR_COLORGAMUT_UNSPECIFIED), |
| mTf(ULTRAHDR_TF_UNSPECIFIED), |
| mQuality(100), |
| mOf(of), |
| mMode(1){}; |
| |
| ~UltraHdrAppInput() { |
| if (mRawP010Image.data) free(mRawP010Image.data); |
| if (mRawP010Image.chroma_data) free(mRawP010Image.chroma_data); |
| if (mRawRgba1010102Image.data) free(mRawRgba1010102Image.data); |
| if (mRawRgba1010102Image.chroma_data) free(mRawRgba1010102Image.chroma_data); |
| if (mRawYuv420Image.data) free(mRawYuv420Image.data); |
| if (mRawYuv420Image.chroma_data) free(mRawYuv420Image.chroma_data); |
| if (mRawRgba8888Image.data) free(mRawRgba8888Image.data); |
| if (mRawRgba8888Image.chroma_data) free(mRawRgba8888Image.chroma_data); |
| if (mJpegImgR.data) free(mJpegImgR.data); |
| if (mDestImage.data) free(mDestImage.data); |
| if (mDestImage.chroma_data) free(mDestImage.chroma_data); |
| if (mDestYUV444Image.data) free(mDestYUV444Image.data); |
| if (mDestYUV444Image.chroma_data) free(mDestYUV444Image.chroma_data); |
| } |
| |
| bool fillJpegRImageHandle(); |
| bool fillP010ImageHandle(); |
| bool convertP010ToRGBImage(); |
| bool fillYuv420ImageHandle(); |
| bool fillYuv420JpegImageHandle(); |
| bool convertYuv420ToRGBImage(); |
| bool convertRgba8888ToYUV444Image(); |
| bool convertRgba1010102ToYUV444Image(); |
| bool encode(); |
| bool decode(); |
| void computeRGBHdrPSNR(); |
| void computeRGBSdrPSNR(); |
| void computeYUVHdrPSNR(); |
| void computeYUVSdrPSNR(); |
| |
| const char* mP010File; |
| const char* mYuv420File; |
| const char* mYuv420JpegFile; |
| const char* mJpegRFile; |
| const int mWidth; |
| const int mHeight; |
| const ultrahdr_color_gamut mP010Cg; |
| const ultrahdr_color_gamut mYuv420Cg; |
| const ultrahdr_transfer_function mTf; |
| const int mQuality; |
| const ultrahdr_output_format mOf; |
| const int mMode; |
| jpegr_uncompressed_struct mRawP010Image{}; |
| jpegr_uncompressed_struct mRawRgba1010102Image{}; |
| jpegr_uncompressed_struct mRawYuv420Image{}; |
| jpegr_compressed_struct mYuv420JpegImage{}; |
| jpegr_uncompressed_struct mRawRgba8888Image{}; |
| jpegr_compressed_struct mJpegImgR{}; |
| jpegr_uncompressed_struct mDestImage{}; |
| jpegr_uncompressed_struct mDestYUV444Image{}; |
| double mPsnr[3]{}; |
| }; |
| |
| bool UltraHdrAppInput::fillP010ImageHandle() { |
| const int bpp = 2; |
| int p010Size = mWidth * mHeight * bpp * 1.5; |
| mRawP010Image.width = mWidth; |
| mRawP010Image.height = mHeight; |
| mRawP010Image.colorGamut = mP010Cg; |
| return loadFile(mP010File, mRawP010Image.data, p010Size); |
| } |
| |
| bool UltraHdrAppInput::fillYuv420ImageHandle() { |
| int yuv420Size = mWidth * mHeight * 1.5; |
| mRawYuv420Image.width = mWidth; |
| mRawYuv420Image.height = mHeight; |
| mRawYuv420Image.colorGamut = mYuv420Cg; |
| return loadFile(mYuv420File, mRawYuv420Image.data, yuv420Size); |
| } |
| |
| bool UltraHdrAppInput::fillYuv420JpegImageHandle() { |
| std::ifstream ifd(mYuv420JpegFile, std::ios::binary | std::ios::ate); |
| if (ifd.good()) { |
| int size = ifd.tellg(); |
| mYuv420JpegImage.length = size; |
| mYuv420JpegImage.maxLength = size; |
| mYuv420JpegImage.data = nullptr; |
| mYuv420JpegImage.colorGamut = mYuv420Cg; |
| ifd.close(); |
| return loadFile(mYuv420JpegFile, mYuv420JpegImage.data, size); |
| } |
| return false; |
| } |
| |
| bool UltraHdrAppInput::fillJpegRImageHandle() { |
| std::ifstream ifd(mJpegRFile, std::ios::binary | std::ios::ate); |
| if (ifd.good()) { |
| int size = ifd.tellg(); |
| mJpegImgR.length = size; |
| mJpegImgR.maxLength = size; |
| mJpegImgR.data = nullptr; |
| mJpegImgR.colorGamut = mYuv420Cg; |
| ifd.close(); |
| return loadFile(mJpegRFile, mJpegImgR.data, size); |
| } |
| return false; |
| } |
| |
| bool UltraHdrAppInput::encode() { |
| if (!fillP010ImageHandle()) return false; |
| if (mYuv420File != nullptr && !fillYuv420ImageHandle()) return false; |
| if (mYuv420JpegFile != nullptr && !fillYuv420JpegImageHandle()) return false; |
| |
| mJpegImgR.maxLength = (std::max)(static_cast<size_t>(8 * 1024) /* min size 8kb */, |
| mRawP010Image.width * mRawP010Image.height * 3 * 2); |
| mJpegImgR.data = malloc(mJpegImgR.maxLength); |
| if (mJpegImgR.data == nullptr) { |
| std::cerr << "unable to allocate memory to store compressed image" << std::endl; |
| return false; |
| } |
| |
| JpegR jpegHdr; |
| status_t status = JPEGR_UNKNOWN_ERROR; |
| #ifdef PROFILE_ENABLE |
| const int profileCount = 10; |
| Profiler profileEncode; |
| profileEncode.timerStart(); |
| for (auto i = 0; i < profileCount; i++) { |
| #endif |
| if (mYuv420File == nullptr && mYuv420JpegFile == nullptr) { // api-0 |
| status = jpegHdr.encodeJPEGR(&mRawP010Image, mTf, &mJpegImgR, mQuality, nullptr); |
| if (JPEGR_NO_ERROR != status) { |
| std::cerr << "Encountered error during encodeJPEGR call, error code " << status |
| << std::endl; |
| return false; |
| } |
| } else if (mYuv420File != nullptr && mYuv420JpegFile == nullptr) { // api-1 |
| status = |
| jpegHdr.encodeJPEGR(&mRawP010Image, &mRawYuv420Image, mTf, &mJpegImgR, mQuality, nullptr); |
| if (JPEGR_NO_ERROR != status) { |
| std::cerr << "Encountered error during encodeJPEGR call, error code " << status |
| << std::endl; |
| return false; |
| } |
| } else if (mYuv420File != nullptr && mYuv420JpegFile != nullptr) { // api-2 |
| status = |
| jpegHdr.encodeJPEGR(&mRawP010Image, &mRawYuv420Image, &mYuv420JpegImage, mTf, &mJpegImgR); |
| if (JPEGR_NO_ERROR != status) { |
| std::cerr << "Encountered error during encodeJPEGR call, error code " << status |
| << std::endl; |
| return false; |
| } |
| } else if (mYuv420File == nullptr && mYuv420JpegFile != nullptr) { // api-3 |
| status = jpegHdr.encodeJPEGR(&mRawP010Image, &mYuv420JpegImage, mTf, &mJpegImgR); |
| if (JPEGR_NO_ERROR != status) { |
| std::cerr << "Encountered error during encodeJPEGR call, error code " << status |
| << std::endl; |
| return false; |
| } |
| } |
| #ifdef PROFILE_ENABLE |
| } |
| profileEncode.timerStop(); |
| auto avgEncTime = profileEncode.elapsedTime() / (profileCount * 1000.f); |
| printf("Average encode time for res %d x %d is %f ms \n", mWidth, mHeight, avgEncTime); |
| #endif |
| writeFile("out.jpeg", mJpegImgR.data, mJpegImgR.length); |
| return true; |
| } |
| |
| bool UltraHdrAppInput::decode() { |
| if (mMode == 1 && !fillJpegRImageHandle()) return false; |
| std::vector<uint8_t> iccData(0); |
| std::vector<uint8_t> exifData(0); |
| jpegr_info_struct info{0, 0, &iccData, &exifData}; |
| JpegR jpegHdr; |
| status_t status = jpegHdr.getJPEGRInfo(&mJpegImgR, &info); |
| if (JPEGR_NO_ERROR == status) { |
| size_t outSize = info.width * info.height * ((mOf == ULTRAHDR_OUTPUT_HDR_LINEAR) ? 8 : 4); |
| mDestImage.data = malloc(outSize); |
| if (mDestImage.data == nullptr) { |
| std::cerr << "failed to allocate memory to store decoded output" << std::endl; |
| return false; |
| } |
| #ifdef PROFILE_ENABLE |
| const int profileCount = 10; |
| Profiler profileDecode; |
| profileDecode.timerStart(); |
| for (auto i = 0; i < profileCount; i++) { |
| #endif |
| status = |
| jpegHdr.decodeJPEGR(&mJpegImgR, &mDestImage, FLT_MAX, nullptr, mOf, nullptr, nullptr); |
| if (JPEGR_NO_ERROR != status) { |
| std::cerr << "Encountered error during decodeJPEGR call, error code " << status |
| << std::endl; |
| return false; |
| } |
| #ifdef PROFILE_ENABLE |
| } |
| profileDecode.timerStop(); |
| auto avgDecTime = profileDecode.elapsedTime() / (profileCount * 1000.f); |
| printf("Average decode time for res %ld x %ld is %f ms \n", info.width, info.height, |
| avgDecTime); |
| #endif |
| writeFile("outrgb.raw", mDestImage.data, outSize); |
| } else { |
| std::cerr << "Encountered error during getJPEGRInfo call, error code " << status << std::endl; |
| return false; |
| } |
| return true; |
| } |
| |
| bool UltraHdrAppInput::convertP010ToRGBImage() { |
| const float* coeffs = BT2020YUVtoRGBMatrix; |
| if (mP010Cg == ULTRAHDR_COLORGAMUT_BT709) { |
| coeffs = BT709YUVtoRGBMatrix; |
| } else if (mP010Cg == ULTRAHDR_COLORGAMUT_BT2100) { |
| coeffs = BT2020YUVtoRGBMatrix; |
| } else if (mP010Cg == ULTRAHDR_COLORGAMUT_P3) { |
| coeffs = BT601YUVtoRGBMatrix; |
| } else { |
| std::cerr << "color matrix not present for gamut " << mP010Cg << " using BT2020Matrix" |
| << std::endl; |
| } |
| |
| mRawRgba1010102Image.data = malloc(mRawP010Image.width * mRawP010Image.height * 4); |
| if (mRawRgba1010102Image.data == nullptr) { |
| std::cerr << "failed to allocate memory to store Rgba1010102" << std::endl; |
| return false; |
| } |
| mRawRgba1010102Image.width = mRawP010Image.width; |
| mRawRgba1010102Image.height = mRawP010Image.height; |
| mRawRgba1010102Image.colorGamut = mRawP010Image.colorGamut; |
| uint32_t* rgbData = static_cast<uint32_t*>(mRawRgba1010102Image.data); |
| uint16_t* y = static_cast<uint16_t*>(mRawP010Image.data); |
| uint16_t* u = y + mRawP010Image.width * mRawP010Image.height; |
| uint16_t* v = u + 1; |
| |
| for (size_t i = 0; i < mRawP010Image.height; i++) { |
| for (size_t j = 0; j < mRawP010Image.width; j++) { |
| float y0 = float(y[mRawP010Image.width * i + j] >> 6); |
| float u0 = float(u[mRawP010Image.width * (i / 2) + (j / 2) * 2] >> 6); |
| float v0 = float(v[mRawP010Image.width * (i / 2) + (j / 2) * 2] >> 6); |
| |
| y0 = CLIP3(y0, 64.0f, 940.0f); |
| u0 = CLIP3(u0, 64.0f, 960.0f); |
| v0 = CLIP3(v0, 64.0f, 960.0f); |
| |
| y0 = (y0 - 64.0f) / 876.0f; |
| u0 = (u0 - 64.0f) / 896.0f - 0.5f; |
| v0 = (v0 - 64.0f) / 896.0f - 0.5f; |
| |
| float r = coeffs[0] * y0 + coeffs[1] * u0 + coeffs[2] * v0; |
| float g = coeffs[3] * y0 + coeffs[4] * u0 + coeffs[5] * v0; |
| float b = coeffs[6] * y0 + coeffs[7] * u0 + coeffs[8] * v0; |
| |
| r = CLIP3(r * 1023.0f + 0.5f, 0.0f, 1023.0f); |
| g = CLIP3(g * 1023.0f + 0.5f, 0.0f, 1023.0f); |
| b = CLIP3(b * 1023.0f + 0.5f, 0.0f, 1023.0f); |
| |
| int32_t r0 = int32_t(r); |
| int32_t g0 = int32_t(g); |
| int32_t b0 = int32_t(b); |
| *rgbData = (0x3ff & r0) | ((0x3ff & g0) << 10) | ((0x3ff & b0) << 20) | |
| (0x3 << 30); // Set alpha to 1.0 |
| |
| rgbData++; |
| } |
| } |
| writeFile("inRgba1010102.raw", mRawRgba1010102Image.data, |
| mRawP010Image.width * mRawP010Image.height * 4); |
| return true; |
| } |
| |
| bool UltraHdrAppInput::convertYuv420ToRGBImage() { |
| mRawRgba8888Image.data = malloc(mRawYuv420Image.width * mRawYuv420Image.height * 4); |
| if (mRawRgba8888Image.data == nullptr) { |
| std::cerr << "failed to allocate memory to store rgba888" << std::endl; |
| return false; |
| } |
| mRawRgba8888Image.width = mRawYuv420Image.width; |
| mRawRgba8888Image.height = mRawYuv420Image.height; |
| mRawRgba8888Image.colorGamut = mRawYuv420Image.colorGamut; |
| uint32_t* rgbData = static_cast<uint32_t*>(mRawRgba8888Image.data); |
| uint8_t* y = static_cast<uint8_t*>(mRawYuv420Image.data); |
| uint8_t* u = y + (mRawYuv420Image.width * mRawYuv420Image.height); |
| uint8_t* v = u + (mRawYuv420Image.width * mRawYuv420Image.height / 4); |
| |
| const float* coeffs = BT601YUVtoRGBMatrix; |
| for (size_t i = 0; i < mRawYuv420Image.height; i++) { |
| for (size_t j = 0; j < mRawYuv420Image.width; j++) { |
| float y0 = float(y[mRawYuv420Image.width * i + j]); |
| float u0 = float(u[mRawYuv420Image.width / 2 * (i / 2) + (j / 2)] - 128); |
| float v0 = float(v[mRawYuv420Image.width / 2 * (i / 2) + (j / 2)] - 128); |
| |
| y0 /= 255.0f; |
| u0 /= 255.0f; |
| v0 /= 255.0f; |
| |
| float r = coeffs[0] * y0 + coeffs[1] * u0 + coeffs[2] * v0; |
| float g = coeffs[3] * y0 + coeffs[4] * u0 + coeffs[5] * v0; |
| float b = coeffs[6] * y0 + coeffs[7] * u0 + coeffs[8] * v0; |
| |
| r = r * 255.0f + 0.5f; |
| g = g * 255.0f + 0.5f; |
| b = b * 255.0f + 0.5f; |
| |
| r = CLIP3(r, 0.0f, 255.0f); |
| g = CLIP3(g, 0.0f, 255.0f); |
| b = CLIP3(b, 0.0f, 255.0f); |
| |
| int32_t r0 = int32_t(r); |
| int32_t g0 = int32_t(g); |
| int32_t b0 = int32_t(b); |
| *rgbData = r0 | (g0 << 8) | (b0 << 16) | (255 << 24); // Set alpha to 1.0 |
| |
| rgbData++; |
| } |
| } |
| writeFile("inRgba8888.raw", mRawRgba8888Image.data, |
| mRawYuv420Image.width * mRawYuv420Image.height * 4); |
| return true; |
| } |
| |
| bool UltraHdrAppInput::convertRgba8888ToYUV444Image() { |
| mDestYUV444Image.data = malloc(mDestImage.width * mDestImage.height * 3); |
| if (mDestYUV444Image.data == nullptr) { |
| std::cerr << "failed to allocate memory to store yuv444" << std::endl; |
| return false; |
| } |
| mDestYUV444Image.width = mDestImage.width; |
| mDestYUV444Image.height = mDestImage.height; |
| mDestYUV444Image.colorGamut = mDestImage.colorGamut; |
| |
| uint32_t* rgbData = static_cast<uint32_t*>(mDestImage.data); |
| |
| uint8_t* yData = static_cast<uint8_t*>(mDestYUV444Image.data); |
| uint8_t* uData = yData + (mDestYUV444Image.width * mDestYUV444Image.height); |
| uint8_t* vData = uData + (mDestYUV444Image.width * mDestYUV444Image.height); |
| |
| const float* coeffs = BT601RGBtoYUVMatrix; |
| for (size_t i = 0; i < mDestImage.height; i++) { |
| for (size_t j = 0; j < mDestImage.width; j++) { |
| float r0 = float(rgbData[mDestImage.width * i + j] & 0xff); |
| float g0 = float((rgbData[mDestImage.width * i + j] >> 8) & 0xff); |
| float b0 = float((rgbData[mDestImage.width * i + j] >> 16) & 0xff); |
| |
| r0 /= 255.0f; |
| g0 /= 255.0f; |
| b0 /= 255.0f; |
| |
| float y = coeffs[0] * r0 + coeffs[1] * g0 + coeffs[2] * b0; |
| float u = coeffs[3] * r0 + coeffs[4] * g0 + coeffs[5] * b0; |
| float v = coeffs[6] * r0 + coeffs[7] * g0 + coeffs[8] * b0; |
| |
| y = y * 255.0f + 0.5f; |
| u = u * 255.0f + 0.5f + 128.0f; |
| v = v * 255.0f + 0.5f + 128.0f; |
| |
| y = CLIP3(y, 0.0f, 255.0f); |
| u = CLIP3(u, 0.0f, 255.0f); |
| v = CLIP3(v, 0.0f, 255.0f); |
| |
| yData[mDestYUV444Image.width * i + j] = uint8_t(y); |
| uData[mDestYUV444Image.width * i + j] = uint8_t(u); |
| vData[mDestYUV444Image.width * i + j] = uint8_t(v); |
| } |
| } |
| writeFile("outyuv444.yuv", mDestYUV444Image.data, |
| mDestYUV444Image.width * mDestYUV444Image.height * 3); |
| return true; |
| } |
| |
| bool UltraHdrAppInput::convertRgba1010102ToYUV444Image() { |
| const float* coeffs = BT2020RGBtoYUVMatrix; |
| if (mP010Cg == ULTRAHDR_COLORGAMUT_BT709) { |
| coeffs = BT709RGBtoYUVMatrix; |
| } else if (mP010Cg == ULTRAHDR_COLORGAMUT_BT2100) { |
| coeffs = BT2020RGBtoYUVMatrix; |
| } else if (mP010Cg == ULTRAHDR_COLORGAMUT_P3) { |
| coeffs = BT601RGBtoYUVMatrix; |
| } else { |
| std::cerr << "color matrix not present for gamut " << mP010Cg << " using BT2020Matrix" |
| << std::endl; |
| } |
| |
| mDestYUV444Image.data = malloc(mDestImage.width * mDestImage.height * 3 * 2); |
| if (mDestYUV444Image.data == nullptr) { |
| std::cerr << "failed to allocate memory to store yuv444" << std::endl; |
| return false; |
| } |
| mDestYUV444Image.width = mDestImage.width; |
| mDestYUV444Image.height = mDestImage.height; |
| mDestYUV444Image.colorGamut = mDestImage.colorGamut; |
| |
| uint32_t* rgbData = static_cast<uint32_t*>(mDestImage.data); |
| |
| uint16_t* yData = static_cast<uint16_t*>(mDestYUV444Image.data); |
| uint16_t* uData = yData + (mDestYUV444Image.width * mDestYUV444Image.height); |
| uint16_t* vData = uData + (mDestYUV444Image.width * mDestYUV444Image.height); |
| |
| for (size_t i = 0; i < mDestImage.height; i++) { |
| for (size_t j = 0; j < mDestImage.width; j++) { |
| float r0 = float(rgbData[mDestImage.width * i + j] & 0x3ff); |
| float g0 = float((rgbData[mDestImage.width * i + j] >> 10) & 0x3ff); |
| float b0 = float((rgbData[mDestImage.width * i + j] >> 20) & 0x3ff); |
| |
| r0 /= 1023.0f; |
| g0 /= 1023.0f; |
| b0 /= 1023.0f; |
| |
| float y = coeffs[0] * r0 + coeffs[1] * g0 + coeffs[2] * b0; |
| float u = coeffs[3] * r0 + coeffs[4] * g0 + coeffs[5] * b0; |
| float v = coeffs[6] * r0 + coeffs[7] * g0 + coeffs[8] * b0; |
| |
| y = (y * 876.0f) + 64.0f + 0.5f; |
| u = (u * 896.0f) + 64.0f + 512.0f + 0.5f; |
| v = (v * 896.0f) + 64.0f + 512.0f + 0.5f; |
| |
| y = CLIP3(y, 64.0f, 940.0f); |
| u = CLIP3(u, 64.0f, 960.0f); |
| v = CLIP3(v, 64.0f, 960.0f); |
| |
| yData[mDestYUV444Image.width * i + j] = uint16_t(y); |
| uData[mDestYUV444Image.width * i + j] = uint16_t(u); |
| vData[mDestYUV444Image.width * i + j] = uint16_t(v); |
| } |
| } |
| writeFile("outyuv444.yuv", mDestYUV444Image.data, |
| mDestYUV444Image.width * mDestYUV444Image.height * 3 * 2); |
| return true; |
| } |
| |
| void UltraHdrAppInput::computeRGBHdrPSNR() { |
| if (mOf == ULTRAHDR_OUTPUT_SDR || mOf == ULTRAHDR_OUTPUT_HDR_LINEAR) { |
| std::cout << "psnr not supported for output format " << mOf << std::endl; |
| return; |
| } |
| uint32_t* rgbDataSrc = static_cast<uint32_t*>(mRawRgba1010102Image.data); |
| uint32_t* rgbDataDst = static_cast<uint32_t*>(mDestImage.data); |
| if (rgbDataSrc == nullptr || rgbDataDst == nullptr) { |
| std::cerr << "invalid src or dst pointer for psnr computation " << std::endl; |
| return; |
| } |
| if ((mOf == ULTRAHDR_OUTPUT_HDR_PQ && mTf != ULTRAHDR_TF_PQ) || |
| (mOf == ULTRAHDR_OUTPUT_HDR_HLG && mTf != ULTRAHDR_TF_HLG)) { |
| std::cout << "input transfer function and output format are not compatible, psnr results " |
| "may be unreliable" |
| << std::endl; |
| } |
| uint64_t rSqError = 0, gSqError = 0, bSqError = 0; |
| for (size_t i = 0; i < mRawP010Image.width * mRawP010Image.height; i++) { |
| int rSrc = *rgbDataSrc & 0x3ff; |
| int rDst = *rgbDataDst & 0x3ff; |
| rSqError += (rSrc - rDst) * (rSrc - rDst); |
| |
| int gSrc = (*rgbDataSrc >> 10) & 0x3ff; |
| int gDst = (*rgbDataDst >> 10) & 0x3ff; |
| gSqError += (gSrc - gDst) * (gSrc - gDst); |
| |
| int bSrc = (*rgbDataSrc >> 20) & 0x3ff; |
| int bDst = (*rgbDataDst >> 20) & 0x3ff; |
| bSqError += (bSrc - bDst) * (bSrc - bDst); |
| |
| rgbDataSrc++; |
| rgbDataDst++; |
| } |
| double meanSquareError = (double)rSqError / (mRawP010Image.width * mRawP010Image.height); |
| mPsnr[0] = meanSquareError ? 10 * log10((double)1023 * 1023 / meanSquareError) : 100; |
| |
| meanSquareError = (double)gSqError / (mRawP010Image.width * mRawP010Image.height); |
| mPsnr[1] = meanSquareError ? 10 * log10((double)1023 * 1023 / meanSquareError) : 100; |
| |
| meanSquareError = (double)bSqError / (mRawP010Image.width * mRawP010Image.height); |
| mPsnr[2] = meanSquareError ? 10 * log10((double)1023 * 1023 / meanSquareError) : 100; |
| |
| std::cout << "psnr r :: " << mPsnr[0] << " psnr g :: " << mPsnr[1] << " psnr b :: " << mPsnr[2] |
| << std::endl; |
| } |
| |
| void UltraHdrAppInput::computeRGBSdrPSNR() { |
| if (mOf != ULTRAHDR_OUTPUT_SDR) { |
| std::cout << "psnr not supported for output format " << mOf << std::endl; |
| return; |
| } |
| uint32_t* rgbDataSrc = static_cast<uint32_t*>(mRawRgba8888Image.data); |
| uint32_t* rgbDataDst = static_cast<uint32_t*>(mDestImage.data); |
| if (rgbDataSrc == nullptr || rgbDataDst == nullptr) { |
| std::cerr << "invalid src or dst pointer for psnr computation " << std::endl; |
| return; |
| } |
| |
| uint64_t rSqError = 0, gSqError = 0, bSqError = 0; |
| for (size_t i = 0; i < mRawYuv420Image.width * mRawYuv420Image.height; i++) { |
| int rSrc = *rgbDataSrc & 0xff; |
| int rDst = *rgbDataDst & 0xff; |
| rSqError += (rSrc - rDst) * (rSrc - rDst); |
| |
| int gSrc = (*rgbDataSrc >> 8) & 0xff; |
| int gDst = (*rgbDataDst >> 8) & 0xff; |
| gSqError += (gSrc - gDst) * (gSrc - gDst); |
| |
| int bSrc = (*rgbDataSrc >> 16) & 0xff; |
| int bDst = (*rgbDataDst >> 16) & 0xff; |
| bSqError += (bSrc - bDst) * (bSrc - bDst); |
| |
| rgbDataSrc++; |
| rgbDataDst++; |
| } |
| double meanSquareError = (double)rSqError / (mRawYuv420Image.width * mRawYuv420Image.height); |
| mPsnr[0] = meanSquareError ? 10 * log10((double)255 * 255 / meanSquareError) : 100; |
| |
| meanSquareError = (double)gSqError / (mRawYuv420Image.width * mRawYuv420Image.height); |
| mPsnr[1] = meanSquareError ? 10 * log10((double)255 * 255 / meanSquareError) : 100; |
| |
| meanSquareError = (double)bSqError / (mRawYuv420Image.width * mRawYuv420Image.height); |
| mPsnr[2] = meanSquareError ? 10 * log10((double)255 * 255 / meanSquareError) : 100; |
| |
| std::cout << "psnr r :: " << mPsnr[0] << " psnr g :: " << mPsnr[1] << " psnr b :: " << mPsnr[2] |
| << std::endl; |
| } |
| |
| void UltraHdrAppInput::computeYUVHdrPSNR() { |
| if (mOf == ULTRAHDR_OUTPUT_SDR || mOf == ULTRAHDR_OUTPUT_HDR_LINEAR) { |
| std::cout << "psnr not supported for output format " << mOf << std::endl; |
| return; |
| } |
| uint16_t* yuvDataSrc = static_cast<uint16_t*>(mRawP010Image.data); |
| uint16_t* yuvDataDst = static_cast<uint16_t*>(mDestYUV444Image.data); |
| if (yuvDataSrc == nullptr || yuvDataDst == nullptr) { |
| std::cerr << "invalid src or dst pointer for psnr computation " << std::endl; |
| return; |
| } |
| if ((mOf == ULTRAHDR_OUTPUT_HDR_PQ && mTf != ULTRAHDR_TF_PQ) || |
| (mOf == ULTRAHDR_OUTPUT_HDR_HLG && mTf != ULTRAHDR_TF_HLG)) { |
| std::cout << "input transfer function and output format are not compatible, psnr results " |
| "may be unreliable" |
| << std::endl; |
| } |
| |
| uint16_t* yDataSrc = static_cast<uint16_t*>(mRawP010Image.data); |
| uint16_t* uDataSrc = yDataSrc + (mRawP010Image.width * mRawP010Image.height); |
| uint16_t* vDataSrc = uDataSrc + 1; |
| |
| uint16_t* yDataDst = static_cast<uint16_t*>(mDestYUV444Image.data); |
| uint16_t* uDataDst = yDataDst + (mDestYUV444Image.width * mDestYUV444Image.height); |
| uint16_t* vDataDst = uDataDst + (mDestYUV444Image.width * mDestYUV444Image.height); |
| |
| uint64_t ySqError = 0, uSqError = 0, vSqError = 0; |
| for (size_t i = 0; i < mDestYUV444Image.height; i++) { |
| for (size_t j = 0; j < mDestYUV444Image.width; j++) { |
| int ySrc = (yDataSrc[mRawP010Image.width * i + j] >> 6) & 0x3ff; |
| ySrc = CLIP3(ySrc, 64, 940); |
| int yDst = yDataDst[mDestYUV444Image.width * i + j] & 0x3ff; |
| ySqError += (ySrc - yDst) * (ySrc - yDst); |
| |
| if (i % 2 == 0 && j % 2 == 0) { |
| int uSrc = (uDataSrc[mRawP010Image.width * (i / 2) + (j / 2) * 2] >> 6) & 0x3ff; |
| uSrc = CLIP3(uSrc, 64, 960); |
| int uDst = uDataDst[mDestYUV444Image.width * i + j] & 0x3ff; |
| uDst += uDataDst[mDestYUV444Image.width * i + j + 1] & 0x3ff; |
| uDst += uDataDst[mDestYUV444Image.width * (i + 1) + j + 1] & 0x3ff; |
| uDst += uDataDst[mDestYUV444Image.width * (i + 1) + j + 1] & 0x3ff; |
| uDst = (uDst + 2) >> 2; |
| uSqError += (uSrc - uDst) * (uSrc - uDst); |
| |
| int vSrc = (vDataSrc[mRawP010Image.width * (i / 2) + (j / 2) * 2] >> 6) & 0x3ff; |
| vSrc = CLIP3(vSrc, 64, 960); |
| int vDst = vDataDst[mDestYUV444Image.width * i + j] & 0x3ff; |
| vDst += vDataDst[mDestYUV444Image.width * i + j + 1] & 0x3ff; |
| vDst += vDataDst[mDestYUV444Image.width * (i + 1) + j + 1] & 0x3ff; |
| vDst += vDataDst[mDestYUV444Image.width * (i + 1) + j + 1] & 0x3ff; |
| vDst = (vDst + 2) >> 2; |
| vSqError += (vSrc - vDst) * (vSrc - vDst); |
| } |
| } |
| } |
| |
| double meanSquareError = (double)ySqError / (mDestYUV444Image.width * mDestYUV444Image.height); |
| mPsnr[0] = meanSquareError ? 10 * log10((double)1023 * 1023 / meanSquareError) : 100; |
| |
| meanSquareError = (double)uSqError / (mDestYUV444Image.width * mDestYUV444Image.height / 4); |
| mPsnr[1] = meanSquareError ? 10 * log10((double)1023 * 1023 / meanSquareError) : 100; |
| |
| meanSquareError = (double)vSqError / (mDestYUV444Image.width * mDestYUV444Image.height / 4); |
| mPsnr[2] = meanSquareError ? 10 * log10((double)1023 * 1023 / meanSquareError) : 100; |
| |
| std::cout << "psnr y :: " << mPsnr[0] << " psnr u :: " << mPsnr[1] << " psnr v :: " << mPsnr[2] |
| << std::endl; |
| } |
| |
| void UltraHdrAppInput::computeYUVSdrPSNR() { |
| if (mOf != ULTRAHDR_OUTPUT_SDR) { |
| std::cout << "psnr not supported for output format " << mOf << std::endl; |
| return; |
| } |
| |
| uint8_t* yDataSrc = static_cast<uint8_t*>(mRawYuv420Image.data); |
| uint8_t* uDataSrc = yDataSrc + (mRawYuv420Image.width * mRawYuv420Image.height); |
| uint8_t* vDataSrc = uDataSrc + (mRawYuv420Image.width * mRawYuv420Image.height / 4); |
| |
| uint8_t* yDataDst = static_cast<uint8_t*>(mDestYUV444Image.data); |
| uint8_t* uDataDst = yDataDst + (mDestYUV444Image.width * mDestYUV444Image.height); |
| uint8_t* vDataDst = uDataDst + (mDestYUV444Image.width * mDestYUV444Image.height); |
| |
| uint64_t ySqError = 0, uSqError = 0, vSqError = 0; |
| for (size_t i = 0; i < mDestYUV444Image.height; i++) { |
| for (size_t j = 0; j < mDestYUV444Image.width; j++) { |
| int ySrc = yDataSrc[mRawYuv420Image.width * i + j]; |
| int yDst = yDataDst[mDestYUV444Image.width * i + j]; |
| ySqError += (ySrc - yDst) * (ySrc - yDst); |
| |
| if (i % 2 == 0 && j % 2 == 0) { |
| int uSrc = uDataSrc[mRawYuv420Image.width / 2 * (i / 2) + j / 2]; |
| int uDst = uDataDst[mDestYUV444Image.width * i + j]; |
| uDst += uDataDst[mDestYUV444Image.width * i + j + 1]; |
| uDst += uDataDst[mDestYUV444Image.width * (i + 1) + j]; |
| uDst += uDataDst[mDestYUV444Image.width * (i + 1) + j + 1]; |
| uDst = (uDst + 2) >> 2; |
| uSqError += (uSrc - uDst) * (uSrc - uDst); |
| |
| int vSrc = vDataSrc[mRawYuv420Image.width / 2 * (i / 2) + j / 2]; |
| int vDst = vDataDst[mDestYUV444Image.width * i + j]; |
| vDst += vDataDst[mDestYUV444Image.width * i + j + 1]; |
| vDst += vDataDst[mDestYUV444Image.width * (i + 1) + j]; |
| vDst += vDataDst[mDestYUV444Image.width * (i + 1) + j + 1]; |
| vDst = (vDst + 2) >> 2; |
| vSqError += (vSrc - vDst) * (vSrc - vDst); |
| } |
| } |
| } |
| double meanSquareError = (double)ySqError / (mDestYUV444Image.width * mDestYUV444Image.height); |
| mPsnr[0] = meanSquareError ? 10 * log10((double)255 * 255 / meanSquareError) : 100; |
| |
| meanSquareError = (double)uSqError / (mDestYUV444Image.width * mDestYUV444Image.height / 4); |
| mPsnr[1] = meanSquareError ? 10 * log10((double)255 * 255 / meanSquareError) : 100; |
| |
| meanSquareError = (double)vSqError / (mDestYUV444Image.width * mDestYUV444Image.height / 4); |
| mPsnr[2] = meanSquareError ? 10 * log10((double)255 * 255 / meanSquareError) : 100; |
| |
| std::cout << "psnr y :: " << mPsnr[0] << " psnr u:: " << mPsnr[1] << " psnr v :: " << mPsnr[2] |
| << std::endl; |
| } |
| |
| static void usage(const char* name) { |
| fprintf(stderr, "\n## ultra hdr demo application.\nUsage : %s \n", name); |
| fprintf(stderr, " -m mode of operation. [0: encode, 1:decode] \n"); |
| fprintf(stderr, "\n## encoder options : \n"); |
| fprintf(stderr, " -p raw 10 bit input resource in p010 color format, mandatory. \n"); |
| fprintf(stderr, |
| " -y raw 8 bit input resource in yuv420, optional. \n" |
| " if not provided tonemapping happens internally. \n"); |
| fprintf(stderr, " -i compressed 8 bit jpeg file path, optional \n"); |
| fprintf(stderr, " -w input file width, mandatory. \n"); |
| fprintf(stderr, " -h input file height, mandatory. \n"); |
| fprintf(stderr, " -C 10 bit input color gamut, optional. [0:bt709, 1:p3, 2:bt2100] \n"); |
| fprintf(stderr, " -c 8 bit input color gamut, optional. [0:bt709, 1:p3, 2:bt2100] \n"); |
| fprintf(stderr, " -t input transfer function, optional. [0:linear, 1:hlg, 2:pq] \n"); |
| fprintf(stderr, |
| " -q quality factor to be used while encoding 8 bit image, optional. [0-100].\n" |
| " gain map image does not use this quality factor. \n" |
| " for now gain map image quality factor is not configurable. \n"); |
| fprintf(stderr, " -e compute psnr, optional. [0:yes, 1:no] \n"); |
| fprintf(stderr, "\n## decoder options : \n"); |
| fprintf(stderr, " -j ultra hdr input resource, mandatory in decode mode. \n"); |
| fprintf(stderr, |
| " -o output transfer function, optional. [0:sdr, 1:hdr_linear, 2:hdr_pq, " |
| "3:hdr_hlg] \n"); |
| fprintf(stderr, "\n## examples of usage :\n"); |
| fprintf(stderr, "\n## encode api-0 :\n"); |
| fprintf(stderr, " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -w 1920 -h 1080 -q 97\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -w 1920 -h 1080 -q 97 -C 2 -t 2\n"); |
| fprintf(stderr, "\n## encode api-1 :\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 " |
| "-h 1080 -q 97\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 " |
| "-h 1080 -q 97\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 " |
| "-h 1080 -q 97 -C 2 -c 1 -t 1\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 " |
| "-h 1080 -q 97 -C 2 -c 1 -t 1 -e 1\n"); |
| fprintf(stderr, "\n## encode api-2 :\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -i " |
| "cosmat_1920x1080_420_8bit.jpg -w 1920 -h 1080 -t 1 -o 3 -e 1\n"); |
| fprintf(stderr, "\n## encode api-3 :\n"); |
| fprintf(stderr, |
| " ultrahdr_app -m 0 -p cosmat_1920x1080_p010.yuv -i cosmat_1920x1080_420_8bit.jpg -w " |
| "1920 -h 1080 -t 1 -o 3 -e 1\n"); |
| fprintf(stderr, "\n## decode api :\n"); |
| fprintf(stderr, " ultrahdr_app -m 1 -j cosmat_1920x1080_hdr.jpg \n"); |
| fprintf(stderr, " ultrahdr_app -m 1 -j cosmat_1920x1080_hdr.jpg -o 2\n"); |
| fprintf(stderr, "\n"); |
| } |
| |
| int main(int argc, char* argv[]) { |
| char opt_string[] = "p:y:i:w:h:C:c:t:q:o:m:j:e:"; |
| char *p010_file = nullptr, *yuv420_file = nullptr, *jpegr_file = nullptr, |
| *yuv420_jpeg_file = nullptr; |
| int width = 0, height = 0; |
| ultrahdr_color_gamut p010Cg = ULTRAHDR_COLORGAMUT_BT709; |
| ultrahdr_color_gamut yuv420Cg = ULTRAHDR_COLORGAMUT_BT709; |
| ultrahdr_transfer_function tf = ULTRAHDR_TF_HLG; |
| int quality = 100; |
| ultrahdr_output_format of = ULTRAHDR_OUTPUT_HDR_HLG; |
| int mode = 0; |
| int compute_psnr = 0; |
| int ch; |
| while ((ch = getopt_s(argc, argv, opt_string)) != -1) { |
| switch (ch) { |
| case 'p': |
| p010_file = optarg_s; |
| break; |
| case 'y': |
| yuv420_file = optarg_s; |
| break; |
| case 'i': |
| yuv420_jpeg_file = optarg_s; |
| break; |
| case 'w': |
| width = atoi(optarg_s); |
| break; |
| case 'h': |
| height = atoi(optarg_s); |
| break; |
| case 'C': |
| p010Cg = static_cast<ultrahdr_color_gamut>(atoi(optarg_s)); |
| break; |
| case 'c': |
| yuv420Cg = static_cast<ultrahdr_color_gamut>(atoi(optarg_s)); |
| break; |
| case 't': |
| tf = static_cast<ultrahdr_transfer_function>(atoi(optarg_s)); |
| break; |
| case 'q': |
| quality = atoi(optarg_s); |
| break; |
| case 'o': |
| of = static_cast<ultrahdr_output_format>(atoi(optarg_s)); |
| break; |
| case 'm': |
| mode = atoi(optarg_s); |
| break; |
| case 'j': |
| jpegr_file = optarg_s; |
| break; |
| case 'e': |
| compute_psnr = atoi(optarg_s); |
| break; |
| default: |
| usage(argv[0]); |
| return -1; |
| } |
| } |
| if (mode == 0) { |
| if (width <= 0 || height <= 0 || p010_file == nullptr) { |
| usage(argv[0]); |
| return -1; |
| } |
| UltraHdrAppInput appInput(p010_file, yuv420_file, yuv420_jpeg_file, width, height, p010Cg, |
| yuv420Cg, tf, quality, of); |
| if (!appInput.encode()) return -1; |
| if (compute_psnr == 1) { |
| if (!appInput.decode()) return -1; |
| if (of == ULTRAHDR_OUTPUT_SDR && yuv420_file != nullptr) { |
| appInput.convertYuv420ToRGBImage(); |
| appInput.computeRGBSdrPSNR(); |
| appInput.convertRgba8888ToYUV444Image(); |
| appInput.computeYUVSdrPSNR(); |
| } else if (of == ULTRAHDR_OUTPUT_HDR_HLG || of == ULTRAHDR_OUTPUT_HDR_PQ) { |
| appInput.convertP010ToRGBImage(); |
| appInput.computeRGBHdrPSNR(); |
| appInput.convertRgba1010102ToYUV444Image(); |
| appInput.computeYUVHdrPSNR(); |
| } |
| } |
| } else if (mode == 1) { |
| if (jpegr_file == nullptr) { |
| usage(argv[0]); |
| return -1; |
| } |
| UltraHdrAppInput appInput(jpegr_file, of); |
| if (!appInput.decode()) return -1; |
| } else { |
| std::cerr << "unrecognized input mode " << mode << std::endl; |
| usage(argv[0]); |
| return -1; |
| } |
| |
| return 0; |
| } |
