/*
 * Copyright 2024 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.
 */

import static com.google.media.codecs.ultrahdr.UltraHDRCommon.*;
import static com.google.media.codecs.ultrahdr.UltraHDREncoder.UHDR_USAGE_BEST_QUALITY;

import java.io.File;
import java.io.FileInputStream;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import com.google.media.codecs.ultrahdr.UltraHDRDecoder;
import com.google.media.codecs.ultrahdr.UltraHDREncoder;
import com.google.media.codecs.ultrahdr.UltraHDRDecoder.GainMapMetadata;
import com.google.media.codecs.ultrahdr.UltraHDRDecoder.RawImage;

/**
 * Ultra HDR Encoding/Decoding Demo Application
 */
public class UltraHdrApp {
    private final String mHdrIntentRawFile;
    private final String mSdrIntentRawFile;
    private final String mSdrIntentCompressedFile;
    private final String mGainMapCompressedFile;
    private final String mGainMapMetadaCfgFile;
    private final String mExifFile;
    private final String mUhdrFile;
    private final String mOutputFile;
    private final int mWidth;
    private final int mHeight;
    private final int mHdrCf;
    private final int mSdrCf;
    private final int mHdrCg;
    private final int mSdrCg;
    private final int mHdrTf;
    private final int mQuality;
    private final int mOTF;
    private final int mOfmt;
    private final boolean mFullRange;
    private final int mMapDimensionScaleFactor;
    private final int mMapCompressQuality;
    private final boolean mUseMultiChannelGainMap;
    private final float mGamma;
    private final boolean mEnableGLES;
    private final int mEncPreset;
    private final float mMinContentBoost;
    private final float mMaxContentBoost;
    private final float mTargetDispPeakBrightness;

    byte[] mYuv420YData, mYuv420CbData, mYuv420CrData;
    short[] mP010YData, mP010CbCrData;
    int[] mRgba1010102Data, mRgba8888Data;
    long[] mRgbaF16Data;
    byte[] mCompressedImageData;
    byte[] mGainMapCompressedImageData;
    byte[] mExifData;
    byte[] mUhdrImagedata;
    GainMapMetadata mMetadata;
    RawImage mDecodedUhdrRgbImage;

    public UltraHdrApp(String hdrIntentRawFile, String sdrIntentRawFile,
            String sdrIntentCompressedFile, String gainmapCompressedFile,
            String gainmapMetadataCfgFile, String exifFile, String outputFile, int width,
            int height, int hdrCf, int sdrCf, int hdrCg, int sdrCg, int hdrTf, int quality, int oTf,
            int oFmt, boolean isHdrCrFull, int gainmapScaleFactor, int gainmapQuality,
            boolean enableMultiChannelGainMap, float gamma, int encPreset, float minContentBoost,
            float maxContentBoost, float targetDispPeakBrightness) {
        mHdrIntentRawFile = hdrIntentRawFile;
        mSdrIntentRawFile = sdrIntentRawFile;
        mSdrIntentCompressedFile = sdrIntentCompressedFile;
        mGainMapCompressedFile = gainmapCompressedFile;
        mGainMapMetadaCfgFile = gainmapMetadataCfgFile;
        mExifFile = exifFile;
        mUhdrFile = null;
        mOutputFile = outputFile;
        mWidth = width;
        mHeight = height;
        mHdrCf = hdrCf;
        mSdrCf = sdrCf;
        mHdrCg = hdrCg;
        mSdrCg = sdrCg;
        mHdrTf = hdrTf;
        mQuality = quality;
        mOTF = oTf;
        mOfmt = oFmt;
        mFullRange = isHdrCrFull;
        mMapDimensionScaleFactor = gainmapScaleFactor;
        mMapCompressQuality = gainmapQuality;
        mUseMultiChannelGainMap = enableMultiChannelGainMap;
        mGamma = gamma;
        mEnableGLES = false;
        mEncPreset = encPreset;
        mMinContentBoost = minContentBoost;
        mMaxContentBoost = maxContentBoost;
        mTargetDispPeakBrightness = targetDispPeakBrightness;
    }

    public UltraHdrApp(String gainmapMetadataCfgFile, String uhdrFile, String outputFile, int oTF,
            int oFmt, boolean enableGLES) {
        mHdrIntentRawFile = null;
        mSdrIntentRawFile = null;
        mSdrIntentCompressedFile = null;
        mGainMapCompressedFile = null;
        mGainMapMetadaCfgFile = gainmapMetadataCfgFile;
        mExifFile = null;
        mUhdrFile = uhdrFile;
        mOutputFile = outputFile;
        mWidth = 0;
        mHeight = 0;
        mHdrCf = UHDR_IMG_FMT_UNSPECIFIED;
        mSdrCf = UHDR_IMG_FMT_UNSPECIFIED;
        mHdrCg = UHDR_CG_UNSPECIFIED;
        mSdrCg = UHDR_CG_UNSPECIFIED;
        mHdrTf = UHDR_CT_UNSPECIFIED;
        mQuality = 95;
        mOTF = oTF;
        mOfmt = oFmt;
        mFullRange = false;
        mMapDimensionScaleFactor = 1;
        mMapCompressQuality = 95;
        mUseMultiChannelGainMap = true;
        mGamma = 1.0f;
        mEnableGLES = enableGLES;
        mEncPreset = UHDR_USAGE_BEST_QUALITY;
        mMinContentBoost = Float.MIN_VALUE;
        mMaxContentBoost = Float.MAX_VALUE;
        mTargetDispPeakBrightness = -1.0f;
    }

    public byte[] readFile(String filename) throws IOException {
        byte[] data;
        try (FileInputStream fis = new FileInputStream(filename)) {
            File descriptor = new File(filename);
            long size = descriptor.length();
            if (size <= 0 || size > Integer.MAX_VALUE) {
                throw new IOException("Unexpected file size received for file: " + filename);
            }
            data = new byte[(int) size];
            if (fis.read(data) != size) {
                throw new IOException("Failed to read file: " + filename + " completely");
            }
        }
        return data;
    }

    public void fillP010ImageHandle() throws IOException {
        final int bpp = 2;
        final int lumaSampleCount = mWidth * mHeight;
        final int chromaSampleCount = (mWidth / 2) * (mHeight / 2) * 2;
        final int expectedSize = (lumaSampleCount + chromaSampleCount) * bpp;
        byte[] data = readFile(mHdrIntentRawFile);
        if (data.length < expectedSize) {
            throw new RuntimeException(
                    "For the configured width, height, P010 Image File is expected to contain "
                            + expectedSize + " bytes, but the file has " + data.length + " bytes");
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(data);
        byteBuffer.order(ByteOrder.nativeOrder());
        mP010YData = new short[lumaSampleCount];
        byteBuffer.asShortBuffer().get(mP010YData);
        byteBuffer.position(lumaSampleCount * bpp);
        mP010CbCrData = new short[chromaSampleCount];
        byteBuffer.asShortBuffer().get(mP010CbCrData);
    }

    public void fillRGBA1010102ImageHandle() throws IOException {
        final int bpp = 4;
        final int rgbSampleCount = mHeight * mWidth;
        final int expectedSize = rgbSampleCount * bpp;
        byte[] data = readFile(mHdrIntentRawFile);
        if (data.length < expectedSize) {
            throw new RuntimeException("For the configured width, height, RGBA1010102 Image File is"
                    + " expected to contain " + expectedSize + " bytes, but the file has "
                    + data.length + " bytes");
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(data);
        byteBuffer.order(ByteOrder.nativeOrder());
        mRgba1010102Data = new int[mHeight * mWidth];
        byteBuffer.asIntBuffer().get(mRgba1010102Data);
    }

    public void fillRGBAF16ImageHandle() throws IOException {
        final int bpp = 8;
        final int rgbSampleCount = mHeight * mWidth;
        final int expectedSize = rgbSampleCount * bpp;
        byte[] data = readFile(mHdrIntentRawFile);
        if (data.length < expectedSize) {
            throw new RuntimeException("For the configured width, height, RGBA1010102 Image File is"
                    + " expected to contain " + expectedSize + " bytes, but the file has "
                    + data.length + " bytes");
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(data);
        byteBuffer.order(ByteOrder.nativeOrder());
        mRgbaF16Data = new long[mHeight * mWidth];
        byteBuffer.asLongBuffer().get(mRgbaF16Data);
    }

    public void fillRGBA8888Handle() throws IOException {
        final int bpp = 4;
        final int rgbSampleCount = mHeight * mWidth;
        final int expectedSize = rgbSampleCount * bpp;
        byte[] data = readFile(mSdrIntentRawFile);
        if (data.length < expectedSize) {
            throw new RuntimeException("For the configured width, height, RGBA8888 Image File is"
                    + " expected to contain " + expectedSize + " bytes, but the file has "
                    + data.length + " bytes");
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(data);
        byteBuffer.order(ByteOrder.nativeOrder());
        mRgba8888Data = new int[mHeight * mWidth];
        byteBuffer.asIntBuffer().get(mRgba8888Data);
    }

    public void fillYUV420ImageHandle() throws IOException {
        final int lumaSampleCount = mWidth * mHeight;
        final int cbSampleCount = (mWidth / 2) * (mHeight / 2);
        final int crSampleCount = (mWidth / 2) * (mHeight / 2);
        try (FileInputStream fis = new FileInputStream(mSdrIntentRawFile)) {
            mYuv420YData = new byte[lumaSampleCount];
            int bytesRead = fis.read(mYuv420YData);
            if (bytesRead != lumaSampleCount) {
                throw new IOException("Failed to read " + lumaSampleCount + " bytes from file: "
                        + mSdrIntentRawFile);
            }
            mYuv420CbData = new byte[cbSampleCount];
            bytesRead = fis.read(mYuv420CbData);
            if (bytesRead != cbSampleCount) {
                throw new IOException("Failed to read " + cbSampleCount + " bytes from file: "
                        + mSdrIntentRawFile);
            }
            mYuv420CrData = new byte[crSampleCount];
            bytesRead = fis.read(mYuv420CrData);
            if (bytesRead != crSampleCount) {
                throw new IOException("Failed to read " + crSampleCount + " bytes from file: "
                        + mSdrIntentRawFile);
            }
        }
    }

    public void fillSdrCompressedImageHandle() throws IOException {
        mCompressedImageData = readFile(mSdrIntentCompressedFile);
    }

    public void fillGainMapCompressedImageHandle() throws IOException {
        mGainMapCompressedImageData = readFile(mGainMapCompressedFile);
    }

    public void fillExifMemoryBlock() throws IOException {
        mExifData = readFile(mExifFile);
    }

    public void fillUhdrImageHandle() throws IOException {
        mUhdrImagedata = readFile(mUhdrFile);
    }

    public void fillGainMapMetadataDescriptor() throws IOException {
        mMetadata = new GainMapMetadata();
        try (BufferedReader reader = new BufferedReader(new FileReader(mGainMapMetadaCfgFile))) {
            String line;
            while ((line = reader.readLine()) != null) {
                String[] parts = line.split("\\s+");
                if (parts.length == 2 && parts[0].startsWith("--")) {
                    String option = parts[0].substring(2); // remove the "--" prefix
                    float value = Float.parseFloat(parts[1]);
                    switch (option) {
                        case "maxContentBoost":
                            mMetadata.maxContentBoost = value;
                            break;
                        case "minContentBoost":
                            mMetadata.minContentBoost = value;
                            break;
                        case "gamma":
                            mMetadata.gamma = value;
                            break;
                        case "offsetSdr":
                            mMetadata.offsetSdr = value;
                            break;
                        case "offsetHdr":
                            mMetadata.offsetHdr = value;
                            break;
                        case "hdrCapacityMin":
                            mMetadata.hdrCapacityMin = value;
                            break;
                        case "hdrCapacityMax":
                            mMetadata.hdrCapacityMax = value;
                            break;
                        default:
                            System.err.println("ignoring option: " + option);
                            break;
                    }
                } else {
                    System.err.println("Unable to parse line : " + line);
                }
            }
        }
    }

    public void writeGainMapMetadataToFile(GainMapMetadata metadata) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(mGainMapMetadaCfgFile))) {
            writer.write("--maxContentBoost " + metadata.maxContentBoost + "\n");
            writer.write("--minContentBoost " + metadata.minContentBoost + "\n");
            writer.write("--gamma " + metadata.gamma + "\n");
            writer.write("--offsetSdr " + metadata.offsetSdr + "\n");
            writer.write("--offsetHdr " + metadata.offsetHdr + "\n");
            writer.write("--hdrCapacityMin " + metadata.hdrCapacityMin + "\n");
            writer.write("--hdrCapacityMax " + metadata.hdrCapacityMax + "\n");
        }
    }

    public void writeFile(String fileName, RawImage img) throws IOException {
        try (FileOutputStream fos = new FileOutputStream(fileName)) {
            if (img.fmt == UHDR_IMG_FMT_32bppRGBA8888 || img.fmt == UHDR_IMG_FMT_64bppRGBAHalfFloat
                    || img.fmt == UHDR_IMG_FMT_32bppRGBA1010102) {
                byte[] data = img.nativeOrderBuffer;
                int bpp = img.fmt == UHDR_IMG_FMT_64bppRGBAHalfFloat ? 8 : 4;
                int stride = img.stride * bpp;
                int length = img.w * bpp;
                for (int i = 0; i < img.h; i++) {
                    fos.write(data, i * stride, length);
                }
            } else {
                throw new RuntimeException("Unsupported color format ");
            }
        }
    }

    public void writeFile(String fileName, byte[] data) throws IOException {
        try (FileOutputStream fos = new FileOutputStream(fileName)) {
            fos.write(data);
        }
    }

    public void encode() throws Exception {
        try (UltraHDREncoder handle = new UltraHDREncoder()) {
            if (mHdrIntentRawFile != null) {
                if (mHdrCf == UHDR_IMG_FMT_24bppYCbCrP010) {
                    fillP010ImageHandle();
                    handle.setRawImage(mP010YData, mP010CbCrData, mWidth, mHeight, mWidth, mWidth,
                            mHdrCg, mHdrTf, mFullRange ? UHDR_CR_FULL_RANGE : UHDR_CR_LIMITED_RANGE,
                            mHdrCf, UHDR_HDR_IMG);
                } else if (mHdrCf == UHDR_IMG_FMT_32bppRGBA1010102) {
                    fillRGBA1010102ImageHandle();
                    handle.setRawImage(mRgba1010102Data, mWidth, mHeight, mWidth, mHdrCg, mHdrTf,
                            UHDR_CR_FULL_RANGE, mHdrCf, UHDR_HDR_IMG);
                } else if (mHdrCf == UHDR_IMG_FMT_64bppRGBAHalfFloat) {
                    fillRGBAF16ImageHandle();
                    handle.setRawImage(mRgbaF16Data, mWidth, mHeight, mWidth, mHdrCg, mHdrTf,
                            UHDR_CR_FULL_RANGE, mHdrCf, UHDR_HDR_IMG);
                } else {
                    throw new IllegalArgumentException("invalid hdr intent color format " + mHdrCf);
                }
            }
            if (mSdrIntentRawFile != null) {
                if (mSdrCf == UHDR_IMG_FMT_12bppYCbCr420) {
                    fillYUV420ImageHandle();
                    handle.setRawImage(mYuv420YData, mYuv420CbData, mYuv420CrData, mWidth, mHeight,
                            mWidth, mWidth / 2, mWidth / 2, mSdrCg, UHDR_CT_SRGB,
                            UHDR_CR_FULL_RANGE, mSdrCf, UHDR_SDR_IMG);
                } else if (mSdrCf == UHDR_IMG_FMT_32bppRGBA8888) {
                    fillRGBA8888Handle();
                    handle.setRawImage(mRgba8888Data, mWidth, mHeight, mWidth, mSdrCg, UHDR_CT_SRGB,
                            UHDR_CR_FULL_RANGE, mSdrCf, UHDR_SDR_IMG);
                } else {
                    throw new IllegalArgumentException("invalid sdr intent color format " + mSdrCf);
                }
            }
            if (mSdrIntentCompressedFile != null) {
                fillSdrCompressedImageHandle();
                handle.setCompressedImage(mCompressedImageData, mCompressedImageData.length, mSdrCg,
                        UHDR_CT_UNSPECIFIED, UHDR_CR_UNSPECIFIED,
                        (mGainMapCompressedFile != null && mGainMapMetadaCfgFile != null) ?
                                UHDR_BASE_IMG : UHDR_SDR_IMG);
            }
            if (mGainMapCompressedFile != null && mGainMapMetadaCfgFile != null) {
                fillGainMapCompressedImageHandle();
                fillGainMapMetadataDescriptor();
                handle.setGainMapImageInfo(mGainMapCompressedImageData,
                        mGainMapCompressedImageData.length, mMetadata.maxContentBoost,
                        mMetadata.minContentBoost, mMetadata.gamma, mMetadata.offsetSdr,
                        mMetadata.offsetHdr, mMetadata.hdrCapacityMin, mMetadata.hdrCapacityMax);
            }
            if (mExifFile != null) {
                fillExifMemoryBlock();
                handle.setExifData(mExifData, mExifData.length);
            }
            handle.setQualityFactor(mQuality, UHDR_BASE_IMG);
            handle.setQualityFactor(mMapCompressQuality, UHDR_GAIN_MAP_IMG);
            handle.setMultiChannelGainMapEncoding(mUseMultiChannelGainMap);
            handle.setGainMapScaleFactor(mMapDimensionScaleFactor);
            handle.setGainMapGamma(mGamma);
            handle.setEncPreset(mEncPreset);
            if (mMinContentBoost != Float.MIN_VALUE || mMaxContentBoost != Float.MAX_VALUE) {
                handle.setMinMaxContentBoost(mMinContentBoost, mMaxContentBoost);
            }
            if (mTargetDispPeakBrightness != -1.0f) {
                handle.setTargetDisplayPeakBrightness(mTargetDispPeakBrightness);
            }
            handle.encode();
            mUhdrImagedata = handle.getOutput();
            writeFile(mOutputFile, mUhdrImagedata);
        }
    }

    public void decode() throws Exception {
        fillUhdrImageHandle();
        try (UltraHDRDecoder handle = new UltraHDRDecoder()) {
            handle.setCompressedImage(mUhdrImagedata, mUhdrImagedata.length, UHDR_CG_UNSPECIFIED,
                    UHDR_CG_UNSPECIFIED, UHDR_CR_UNSPECIFIED);
            handle.setColorTransfer(mOTF);
            handle.setOutputFormat(mOfmt);
            if (mEnableGLES) {
                handle.enableGpuAcceleration(mEnableGLES ? 1 : 0);
            }
            handle.probe();
            if (mGainMapMetadaCfgFile != null) {
                GainMapMetadata metadata = handle.getGainmapMetadata();
                writeGainMapMetadataToFile(metadata);
            }
            handle.decode();
            mDecodedUhdrRgbImage = handle.getDecodedImage();
            writeFile(mOutputFile, mDecodedUhdrRgbImage);
        }
    }

    public static void usage() {
        System.out.println("\n## uhdr demo application. lib version: " + getVersionString());
        System.out.println("Usage : java -Djava.library.path=<path> -jar uhdr-java.jar");
        System.out.println("    -m    mode of operation. [0:encode, 1:decode]");
        System.out.println("\n## encoder options :");
        System.out.println("    -p    raw hdr intent input resource (10-bit), required for encoding"
                + " scenarios 0, 1, 2, 3.");
        System.out.println("    -y    raw sdr intent input resource (8-bit), required for encoding"
                + " scenarios 1, 2.");
        System.out.println("    -a    raw hdr intent color format, optional. [0:p010, "
                + "4: rgbahalffloat, 5:rgba1010102 (default)]");
        System.out.println("    -b    raw sdr intent color format, optional. [1:yuv420, 3:rgba8888"
                + " (default)]");
        System.out.println("    -i    compressed sdr intent input resource (jpeg), required for "
                + "encoding scenarios 2, 3, 4.");
        System.out.println("    -g    compressed gainmap input resource (jpeg), required for "
                + "encoding scenario 4.");
        System.out.println(
                "    -w    input file width, required for encoding scenarios 0, 1, 2, 3.");
        System.out.println(
                "    -h    input file height, required for encoding scenarios 0, 1, 2, 3.");
        System.out.println(
                "    -C    hdr intent color gamut, optional. [0:bt709, 1:p3 (default), 2:bt2100]");
        System.out.println(
                "    -c    sdr intent color gamut, optional. [0:bt709 (default), 1:p3, 2:bt2100]");
        System.out.println(
                "    -t    hdr intent color transfer, optional. [0:linear, 1:hlg (default), 2:pq]");
        System.out.println(
                "          It should be noted that not all combinations of input color format and"
                        + " input color transfer are supported.");
        System.out.println(
                "          srgb color transfer shall be paired with rgba8888 or yuv420 only.");
        System.out.println("          hlg, pq shall be paired with rgba1010102 or p010.");
        System.out.println("          linear shall be paired with rgbahalffloat.");
        System.out.println("    -q    quality factor to be used while encoding sdr intent, "
                + "optional. [0-100], 95 : default.");
        System.out.println("    -R    color range of hdr intent, optional. [0:narrow-range "
                + "(default), 1:full-range].");
        System.out.println("    -s    gainmap image downsample factor, optional. [integer values"
                + " in range [1 - 128] (1 : default)].");
        System.out.println("    -Q    quality factor to be used while encoding gain map image,"
                + " optional. [0-100], 95 : default.");
        System.out.println("    -G    gamma correction to be applied on the gainmap image, "
                + "optional. [any positive real number (1.0 : default)].");
        System.out.println("    -M    select multi channel gain map, optional. [0:disable, "
                + " 1:enable (default)].");
        System.out.println("    -D    select encoding preset, optional. [0:real time,"
                + " 1:best quality (default)].");
        System.out.println("    -k    min content boost recommendation, must be in linear scale,"
                + " optional. any positive real number");
        System.out.println("    -K    max content boost recommendation, must be in linear scale,"
                + " optional. any positive real number");
        System.out.println("    -L    set target display peak brightness in nits, optional");
        System.out.println("          For HLG content, this defaults to 1000 nits.");
        System.out.println("          For PQ content, this defaults to 10000 nits.");
        System.out.println("          any real number in range [203, 10000].");
        System.out.println("    -x    binary input resource containing exif data to insert, "
                + "optional.");
        System.out.println("\n## decoder options :");
        System.out.println("    -j    ultra hdr compressed input resource, required.");
        System.out.println("    -o    output transfer function, optional. [0:linear,"
                + " 1:hlg (default), 2:pq, 3:srgb]");
        System.out.println("    -O    output color format, optional. [3:rgba8888, 4:rgbahalffloat, "
                + "5:rgba1010102 (default)]");
        System.out.println("          It should be noted that not all combinations of output color"
                + " format and output");
        System.out.println("          transfer function are supported.");
        System.out.println(
                "          srgb output color transfer shall be paired with rgba8888 only.");
        System.out.println("          hlg, pq shall be paired with rgba1010102.");
        System.out.println("          linear shall be paired with rgbahalffloat.");
        System.out.println(
                "    -u    enable gles acceleration, optional. [0:disable (default), 1:enable].");
        System.out.println("\n## common options :");
        System.out.println("    -z    output filename, optional.");
        System.out.println("          in encoding mode, default output filename 'out.jpeg'.");
        System.out.println("          in decoding mode, default output filename 'outrgb.raw'.");
        System.out.println("    -f    gainmap metadata config file.");
        System.out.println("          in encoding mode, resource from which gainmap metadata is "
                + "read, required for encoding scenario 4.");
        System.out.println("          in decoding mode, resource to which gainmap metadata is "
                + "written, optional.");
        System.out.println("\n## examples of usage :");
        System.out.println("\n## encode scenario 0 :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_p010.yuv -w 1920 -h 1080 -q 97 -a 0");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_rgba1010102.raw -w  1920 -h 1080 -q 97 -a 5");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_p010.yuv -w 1920 -h 1080 -q 97 -C 1 -t 2 -a 0");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_rgba1010102.raw -w 1920 -h 1080 -q 97 -C 1 -t 2 -a 5");
        System.out.println("\n## encode scenario 1 :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 -h 1080 -q 97 "
                + "-a 0 -b 1");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_rgba1010102.raw -y cosmat_1920x1080_rgba8888.raw -w 1920 -h "
                + "1080 -q 97 -a 5 -b 3");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 -h 1080 -q 97 -C"
                + " 2 -c 1 -t 1 -a 0 -b 1");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_rgba1010102.raw -y cosmat_1920x1080_rgba8888.raw -w 1920 "
                + "-h 1080 -q 97 -C 2 -c 1 -t 1 -a 5 -b 3");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_p010.yuv -y cosmat_1920x1080_420.yuv -w 1920 -h 1080 -q 97 -C"
                + " 2 -c 1 -t 1 -a 0 -b 1");
        System.out.println("\n## encode scenario 2 :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -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 -O 3 -a 0 -b 1");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_rgba1010102.raw -y cosmat_1920x1080_420.yuv -i "
                + "cosmat_1920x1080_420_8bit.jpg -w 1920 -h 1080 -t 1 -o 3 -O 3 -a 5 -b 1");
        System.out.println("\n## encode scenario 3 :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_p010.yuv -i cosmat_1920x1080_420_8bit.jpg -w 1920 -h 1080 -t "
                + "1 -o 1 -O 5 -a 0");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "cosmat_1920x1080_rgba1010102.raw -i cosmat_1920x1080_420_8bit.jpg -w 1920 -h "
                + "1080 -t 1 -o 1 -O 5 -a 5");
        System.out.println("\n## encode scenario 4 :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -i "
                + "cosmat_1920x1080_420_8bit.jpg -g cosmat_1920x1080_420_8bit.jpg -f metadata.cfg");
        System.out.println("\n## encode at high quality :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 0 -p "
                + "hdr_intent.raw -y sdr_intent.raw -w 640 -h 480 -c <select> -C <select> -t "
                + "<select> -s 1 -M 1 -Q 98 -q 98 -D 1");
        System.out.println("\n## decode api :");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 1 "
                + "-j cosmat_1920x1080_hdr.jpg");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 1 -j "
                + "cosmat_1920x1080_hdr.jpg -o 3 -O 3");
        System.out.println("    java -Djava.library.path=<path> -jar uhdr-java.jar -m 1 -j "
                + "cosmat_1920x1080_hdr.jpg -o 1 -O 5");
        System.out.println("\n");
    }

    public static void main(String[] args) throws Exception {
        String hdr_intent_raw_file = null;
        String sdr_intent_raw_file = null;
        String sdr_intent_compressed_file = null;
        String gainmap_compressed_file = null;
        String uhdr_file = null;
        String gainmap_metadata_cfg_file = null;
        String output_file = null;
        String exif_file = null;
        int width = 0, height = 0;
        int hdr_cg = UHDR_CG_DISPLAY_P3;
        int sdr_cg = UHDR_CG_BT709;
        int hdr_cf = UHDR_IMG_FMT_32bppRGBA1010102;
        int sdr_cf = UHDR_IMG_FMT_32bppRGBA8888;
        int hdr_tf = UHDR_CT_HLG;
        int quality = 95;
        int out_tf = UHDR_CT_HLG;
        int out_cf = UHDR_IMG_FMT_32bppRGBA1010102;
        int mode = -1;
        int gain_map_scale_factor = 1;
        int gainmap_compression_quality = 95;
        int enc_preset = UHDR_USAGE_BEST_QUALITY;
        float gamma = 1.0f;
        boolean enable_gles = false;
        float min_content_boost = Float.MIN_VALUE;
        float max_content_boost = Float.MAX_VALUE;
        float target_disp_max_brightness = -1.0f;
        boolean use_full_range_color_hdr = false;
        boolean use_multi_channel_gainmap = true;

        for (int i = 0; i < args.length; i++) {
            if (args[i].length() == 2 && args[i].charAt(0) == '-') {
                switch (args[i].charAt(1)) {
                    case 'a':
                        hdr_cf = Integer.parseInt(args[++i]);
                        break;
                    case 'b':
                        sdr_cf = Integer.parseInt(args[++i]);
                        break;
                    case 'p':
                        hdr_intent_raw_file = args[++i];
                        break;
                    case 'y':
                        sdr_intent_raw_file = args[++i];
                        break;
                    case 'i':
                        sdr_intent_compressed_file = args[++i];
                        break;
                    case 'g':
                        gainmap_compressed_file = args[++i];
                        break;
                    case 'f':
                        gainmap_metadata_cfg_file = args[++i];
                        break;
                    case 'w':
                        width = Integer.parseInt(args[++i]);
                        break;
                    case 'h':
                        height = Integer.parseInt(args[++i]);
                        break;
                    case 'C':
                        hdr_cg = Integer.parseInt(args[++i]);
                        break;
                    case 'c':
                        sdr_cg = Integer.parseInt(args[++i]);
                        break;
                    case 't':
                        hdr_tf = Integer.parseInt(args[++i]);
                        break;
                    case 'q':
                        quality = Integer.parseInt(args[++i]);
                        break;
                    case 'O':
                        out_cf = Integer.parseInt(args[++i]);
                        break;
                    case 'o':
                        out_tf = Integer.parseInt(args[++i]);
                        break;
                    case 'm':
                        mode = Integer.parseInt(args[++i]);
                        break;
                    case 'R':
                        use_full_range_color_hdr = Integer.parseInt(args[++i]) == 1;
                        break;
                    case 's':
                        gain_map_scale_factor = Integer.parseInt(args[++i]);
                        break;
                    case 'M':
                        use_multi_channel_gainmap = Integer.parseInt(args[++i]) == 1;
                        break;
                    case 'Q':
                        gainmap_compression_quality = Integer.parseInt(args[++i]);
                        break;
                    case 'G':
                        gamma = Float.parseFloat(args[++i]);
                        break;
                    case 'j':
                        uhdr_file = args[++i];
                        break;
                    case 'z':
                        output_file = args[++i];
                        break;
                    case 'x':
                        exif_file = args[++i];
                        break;
                    case 'u':
                        enable_gles = Integer.parseInt(args[++i]) == 1;
                        break;
                    case 'D':
                        enc_preset = Integer.parseInt(args[++i]);
                        break;
                    case 'k':
                        min_content_boost = Float.parseFloat(args[++i]);
                        break;
                    case 'K':
                        max_content_boost = Float.parseFloat(args[++i]);
                        break;
                    case 'L':
                        target_disp_max_brightness = Float.parseFloat(args[++i]);
                        break;
                    default:
                        System.err.println("Unrecognized option, arg: " + args[i]);
                        usage();
                        return;
                }
            } else {
                System.err.println("Invalid argument format, arg: " + args[i]);
                usage();
                return;
            }
        }
        if (mode == 0) {
            if (width <= 0 && gainmap_metadata_cfg_file == null) {
                System.err.println("did not receive valid image width for encoding. width : "
                        + width);
                return;
            }
            if (height <= 0 && gainmap_metadata_cfg_file == null) {
                System.err.println("did not receive valid image height for encoding. height : "
                        + height);
                return;
            }
            if (hdr_intent_raw_file == null && (sdr_intent_compressed_file == null
                    || gainmap_compressed_file == null || gainmap_metadata_cfg_file == null)) {
                System.err.println("did not receive raw resources for encoding.");
                return;
            }
            UltraHdrApp appInput = new UltraHdrApp(hdr_intent_raw_file, sdr_intent_raw_file,
                    sdr_intent_compressed_file, gainmap_compressed_file, gainmap_metadata_cfg_file,
                    exif_file, output_file != null ? output_file : "out.jpeg", width, height,
                    hdr_cf, sdr_cf, hdr_cg, sdr_cg, hdr_tf, quality, out_tf, out_cf,
                    use_full_range_color_hdr, gain_map_scale_factor, gainmap_compression_quality,
                    use_multi_channel_gainmap, gamma, enc_preset, min_content_boost,
                    max_content_boost, target_disp_max_brightness);
            appInput.encode();
        } else if (mode == 1) {
            if (uhdr_file == null) {
                System.err.println("did not receive resources for decoding");
                return;
            }
            UltraHdrApp appInput = new UltraHdrApp(gainmap_metadata_cfg_file, uhdr_file,
                    output_file != null ? output_file : "outrgb.raw", out_tf, out_cf, enable_gles);
            appInput.decode();
        } else {
            if (args.length > 0) {
                System.err.println("did not receive valid mode of operation");
            }
            usage();
        }
    }
}