/*

 * Copyright 2022 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.

 */

#include <errno.h>

#include <setjmp.h>

#include <cmath>

#include <cstring>

#include "ultrahdr/ultrahdrcommon.h"

#include "ultrahdr/jpegdecoderhelper.h"

using namespace std;

namespace ultrahdr {

static const uint32_t kAPP0Marker = JPEG_APP0;      // JFIF

static const uint32_t kAPP1Marker = JPEG_APP0 + 1;  // EXIF, XMP

static const uint32_t kAPP2Marker = JPEG_APP0 + 2;  // ICC, ISO Metadata

static constexpr uint8_t kICCSig[] = {

    'I', 'C', 'C', '_', 'P', 'R', 'O', 'F', 'I', 'L', 'E', '\0',

};

static constexpr uint8_t kXmpNameSpace[] = {

    'h', 't', 't', 'p', ':', '/', '/', 'n', 's', '.', 'a', 'd', 'o', 'b', 'e',

    '.', 'c', 'o', 'm', '/', 'x', 'a', 'p', '/', '1', '.', '0', '/', '\0',

};

static constexpr uint8_t kExifIdCode[] = {

    'E', 'x', 'i', 'f', '\0', '\0',

};

static constexpr uint8_t kIsoMetadataNameSpace[] = {

    'u', 'r', 'n', ':', 'i', 's', 'o', ':', 's', 't', 'd', ':', 'i', 's',

    'o', ':', 't', 's', ':', '2', '1', '4', '9', '6', ':', '-', '1', '\0',

};

const int kMinWidth = 8;

const int kMinHeight = 8;

// if max dimension is not defined, default to 8k resolution

#ifndef UHDR_MAX_DIMENSION

#define UHDR_MAX_DIMENSION 8192

#endif

static_assert(UHDR_MAX_DIMENSION >= (std::max)(kMinHeight, kMinWidth),

              "configured UHDR_MAX_DIMENSION must be atleast max(minWidth, minHeight)");

static_assert(UHDR_MAX_DIMENSION <= JPEG_MAX_DIMENSION,

              "configured UHDR_MAX_DIMENSION must be <= JPEG_MAX_DIMENSION");

const int kMaxWidth = UHDR_MAX_DIMENSION;

const int kMaxHeight = UHDR_MAX_DIMENSION;

/*!\brief module for managing input */

struct jpeg_source_mgr_impl : jpeg_source_mgr {

  jpeg_source_mgr_impl(const uint8_t* ptr, size_t len);

  ~jpeg_source_mgr_impl() = default;

  const uint8_t* mBufferPtr;

  size_t mBufferLength;

};

/*!\brief module for managing error */

struct jpeg_error_mgr_impl : jpeg_error_mgr {

  jmp_buf setjmp_buffer;

};

static void jpegr_init_source(j_decompress_ptr cinfo) {

  jpeg_source_mgr_impl* src = static_cast<jpeg_source_mgr_impl*>(cinfo->src);

  src->next_input_byte = static_cast<const JOCTET*>(src->mBufferPtr);

  src->bytes_in_buffer = src->mBufferLength;

}

static boolean jpegr_fill_input_buffer(j_decompress_ptr /* cinfo */) {

  ALOGE("%s : should not reach here", __func__);

  return FALSE;

}

static void jpegr_skip_input_data(j_decompress_ptr cinfo, long num_bytes) {

  jpeg_source_mgr_impl* src = static_cast<jpeg_source_mgr_impl*>(cinfo->src);

  if (num_bytes > static_cast<long>(src->bytes_in_buffer)) {

    ALOGE("jpegr_skip_input_data - num_bytes > (long)src->bytes_in_buffer");

  } else {

    src->next_input_byte += num_bytes;

    src->bytes_in_buffer -= num_bytes;

  }

}

static void jpegr_term_source(j_decompress_ptr /*cinfo*/) {}

jpeg_source_mgr_impl::jpeg_source_mgr_impl(const uint8_t* ptr, size_t len)

    : mBufferPtr(ptr), mBufferLength(len) {

  init_source = jpegr_init_source;

  fill_input_buffer = jpegr_fill_input_buffer;

  skip_input_data = jpegr_skip_input_data;

  resync_to_restart = jpeg_resync_to_restart;

  term_source = jpegr_term_source;

}

static void jpegrerror_exit(j_common_ptr cinfo) {

  jpeg_error_mgr_impl* err = reinterpret_cast<jpeg_error_mgr_impl*>(cinfo->err);

  longjmp(err->setjmp_buffer, 1);

}

static void output_message(j_common_ptr cinfo) {

  char buffer[JMSG_LENGTH_MAX];

  (*cinfo->err->format_message)(cinfo, buffer);

  ALOGE("%s\n", buffer);

}

static void jpeg_extract_marker_payload(const j_decompress_ptr cinfo, const uint32_t marker_code,

                                        const uint8_t* marker_fourcc_code,

                                        const uint32_t fourcc_length,

                                        std::vector<JOCTET>& destination,

                                        long& markerPayloadOffsetRelativeToSourceBuffer) {

  unsigned int pos = 2; /* position after reading SOI marker (0xffd8) */

  markerPayloadOffsetRelativeToSourceBuffer = -1;

  for (jpeg_marker_struct* marker = cinfo->marker_list; marker; marker = marker->next) {

    pos += 4; /* position after reading next marker and its size (0xFFXX, [SIZE = 2 bytes]) */

    if (marker->marker == marker_code && marker->data_length > fourcc_length &&

        !memcmp(marker->data, marker_fourcc_code, fourcc_length)) {

      destination.resize(marker->data_length);

      memcpy(static_cast<void*>(destination.data()), marker->data, marker->data_length);

      markerPayloadOffsetRelativeToSourceBuffer = pos;

      return;

    }

    pos += marker->original_length; /* position after marker's payload */

  }

}

static uhdr_img_fmt_t getOutputSamplingFormat(const j_decompress_ptr cinfo) {

  if (cinfo->num_components == 1)

    return UHDR_IMG_FMT_8bppYCbCr400;

  else {

    float ratios[6];

    for (int i = 0; i < 3; i++) {

      ratios[i * 2] = ((float)cinfo->comp_info[i].h_samp_factor) / cinfo->max_h_samp_factor;

      ratios[i * 2 + 1] = ((float)cinfo->comp_info[i].v_samp_factor) / cinfo->max_v_samp_factor;

    }

    if (ratios[0] == 1 && ratios[1] == 1 && ratios[2] == ratios[4] && ratios[3] == ratios[5]) {

      if (ratios[2] == 1 && ratios[3] == 1) {

        return UHDR_IMG_FMT_24bppYCbCr444;

      } else if (ratios[2] == 1 && ratios[3] == 0.5) {

        return UHDR_IMG_FMT_16bppYCbCr440;

      } else if (ratios[2] == 0.5 && ratios[3] == 1) {

        return UHDR_IMG_FMT_16bppYCbCr422;

      } else if (ratios[2] == 0.5 && ratios[3] == 0.5) {

        return UHDR_IMG_FMT_12bppYCbCr420;

      } else if (ratios[2] == 0.25 && ratios[3] == 1) {

        return UHDR_IMG_FMT_12bppYCbCr411;

      } else if (ratios[2] == 0.25 && ratios[3] == 0.5) {

        return UHDR_IMG_FMT_10bppYCbCr410;

      }

    }

  }

  return UHDR_IMG_FMT_UNSPECIFIED;

}

uhdr_error_info_t JpegDecoderHelper::decompressImage(const void* image, size_t length,

                                                     decode_mode_t mode) {

  if (image == nullptr) {

    uhdr_error_info_t status;

    status.error_code = UHDR_CODEC_INVALID_PARAM;

    status.has_detail = 1;

    snprintf(status.detail, sizeof status.detail, "received nullptr for compressed image data");

    return status;

  }

  if (length <= 0) {

    uhdr_error_info_t status;

    status.error_code = UHDR_CODEC_INVALID_PARAM;

    status.has_detail = 1;

    snprintf(status.detail, sizeof status.detail, "received bad compressed image size %zd", length);

    return status;

  }

  // reset context

  mResultBuffer.clear();

  mXMPBuffer.clear();

  mEXIFBuffer.clear();

  mICCBuffer.clear();

  mIsoMetadataBuffer.clear();

  mOutFormat = UHDR_IMG_FMT_UNSPECIFIED;

  mNumComponents = 1;

  for (int i = 0; i < kMaxNumComponents; i++) {

    mPlanesMCURow[i].reset();

    mPlaneWidth[i] = 0;

    mPlaneHeight[i] = 0;

    mPlaneHStride[i] = 0;

    mPlaneVStride[i] = 0;

  }

  mExifPayLoadOffset = -1;

  return decode(image, length, mode);

}

uhdr_error_info_t JpegDecoderHelper::decode(const void* image, size_t length, decode_mode_t mode) {

  jpeg_source_mgr_impl mgr(static_cast<const uint8_t*>(image), length);

  jpeg_decompress_struct cinfo;

  jpeg_error_mgr_impl myerr;

  uhdr_error_info_t status = g_no_error;

  cinfo.err = jpeg_std_error(&myerr);

  myerr.error_exit = jpegrerror_exit;

  myerr.output_message = output_message;

  if (0 == setjmp(myerr.setjmp_buffer)) {

    jpeg_create_decompress(&cinfo);

    cinfo.src = &mgr;

    jpeg_save_markers(&cinfo, kAPP0Marker, 0xFFFF);

    jpeg_save_markers(&cinfo, kAPP1Marker, 0xFFFF);

    jpeg_save_markers(&cinfo, kAPP2Marker, 0xFFFF);

    int ret_val = jpeg_read_header(&cinfo, TRUE /* require an image to be present */);

    if (JPEG_HEADER_OK != ret_val) {

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(status.detail, sizeof status.detail,

               "jpeg_read_header(...) returned %d, expected %d", ret_val, JPEG_HEADER_OK);

      jpeg_destroy_decompress(&cinfo);

      return status;

    }

    long payloadOffset = -1;

    jpeg_extract_marker_payload(&cinfo, kAPP1Marker, kXmpNameSpace,

                                sizeof kXmpNameSpace / sizeof kXmpNameSpace[0], mXMPBuffer,

                                payloadOffset);

    jpeg_extract_marker_payload(&cinfo, kAPP1Marker, kExifIdCode,

                                sizeof kExifIdCode / sizeof kExifIdCode[0], mEXIFBuffer,

                                mExifPayLoadOffset);

    jpeg_extract_marker_payload(&cinfo, kAPP2Marker, kICCSig, sizeof kICCSig / sizeof kICCSig[0],

                                mICCBuffer, payloadOffset);

    jpeg_extract_marker_payload(&cinfo, kAPP2Marker, kIsoMetadataNameSpace,

                                sizeof kIsoMetadataNameSpace / sizeof kIsoMetadataNameSpace[0],

                                mIsoMetadataBuffer, payloadOffset);

    if (cinfo.image_width < 1 || cinfo.image_height < 1) {

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(status.detail, sizeof status.detail,

               "received bad image width or height, wd = %d, ht = %d. wd and height shall be >= 1",

               cinfo.image_width, cinfo.image_height);

      jpeg_destroy_decompress(&cinfo);

      return status;

    }

    if ((int)cinfo.image_width > kMaxWidth || (int)cinfo.image_height > kMaxHeight) {

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(

          status.detail, sizeof status.detail,

          "max width, max supported by library are %d, %d respectively. Current image width and "

          "height are %d, %d. Recompile library with updated max supported dimensions to proceed",

          kMaxWidth, kMaxHeight, cinfo.image_width, cinfo.image_height);

      jpeg_destroy_decompress(&cinfo);

      return status;

    }

    if (cinfo.num_components != 1 && cinfo.num_components != 3) {

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(

          status.detail, sizeof status.detail,

          "ultrahdr primary image and supplimentary images are images encoded with 1 component "

          "(grayscale) or 3 components (YCbCr / RGB). Unrecognized number of components %d",

          cinfo.num_components);

      jpeg_destroy_decompress(&cinfo);

      return status;

    }

    for (int i = 0, product = 0; i < cinfo.num_components; i++) {

      if (cinfo.comp_info[i].h_samp_factor < 1 || cinfo.comp_info[i].h_samp_factor > 4) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "received bad horizontal sampling factor for component index %d, sample factor h "

                 "= %d, this is expected to be with in range [1-4]",

                 i, cinfo.comp_info[i].h_samp_factor);

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

      if (cinfo.comp_info[i].v_samp_factor < 1 || cinfo.comp_info[i].v_samp_factor > 4) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "received bad vertical sampling factor for component index %d, sample factor v = "

                 "%d, this is expected to be with in range [1-4]",

                 i, cinfo.comp_info[i].v_samp_factor);

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

      product += cinfo.comp_info[i].h_samp_factor * cinfo.comp_info[i].v_samp_factor;

      if (product > 10) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "received bad sampling factors for components, sum of product of h_samp_factor, "

                 "v_samp_factor across all components exceeds 10");

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

    }

    mNumComponents = cinfo.num_components;

    for (int i = 0; i < cinfo.num_components; i++) {

      mPlaneWidth[i] = std::ceil(((float)cinfo.image_width * cinfo.comp_info[i].h_samp_factor) /

                                 cinfo.max_h_samp_factor);

      mPlaneHStride[i] = mPlaneWidth[i];

      mPlaneHeight[i] = std::ceil(((float)cinfo.image_height * cinfo.comp_info[i].v_samp_factor) /

                                  cinfo.max_v_samp_factor);

      mPlaneVStride[i] = mPlaneHeight[i];

    }

    if (cinfo.num_components == 3) {

      if (mPlaneWidth[1] > mPlaneWidth[0] || mPlaneHeight[2] > mPlaneHeight[0]) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "cb, cr planes are upsampled wrt luma plane. luma width %d, luma height %d, cb "

                 "width %d, cb height %d, cr width %d, cr height %d",

                 (int)mPlaneWidth[0], (int)mPlaneHeight[0], (int)mPlaneWidth[1],

                 (int)mPlaneHeight[1], (int)mPlaneWidth[2], (int)mPlaneHeight[2]);

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

      if (mPlaneWidth[1] != mPlaneWidth[2] || mPlaneHeight[1] != mPlaneHeight[2]) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "cb, cr planes are not sampled identically. cb width %d, cb height %d, cr width "

                 "%d, cr height %d",

                 (int)mPlaneWidth[1], (int)mPlaneHeight[1], (int)mPlaneWidth[2],

                 (int)mPlaneHeight[2]);

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

    }

    if (PARSE_STREAM == mode) {

      jpeg_destroy_decompress(&cinfo);

      return status;

    }

    if (DECODE_STREAM == mode) {

      mode = cinfo.num_components == 1 ? DECODE_TO_YCBCR_CS : DECODE_TO_RGB_CS;

    }

    if (DECODE_TO_RGB_CS == mode) {

      if (cinfo.jpeg_color_space != JCS_YCbCr && cinfo.jpeg_color_space != JCS_RGB) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "expected input color space to be JCS_YCbCr or JCS_RGB but got %d",

                 cinfo.jpeg_color_space);

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

      mPlaneHStride[0] = cinfo.image_width;

      mPlaneVStride[0] = cinfo.image_height;

      for (int i = 1; i < kMaxNumComponents; i++) {

        mPlaneHStride[i] = 0;

        mPlaneVStride[i] = 0;

      }

#ifdef JCS_ALPHA_EXTENSIONS

      mResultBuffer.resize((size_t)mPlaneHStride[0] * mPlaneVStride[0] * 4);

      cinfo.out_color_space = JCS_EXT_RGBA;

#else

      mResultBuffer.resize((size_t)mPlaneHStride[0] * mPlaneVStride[0] * 3);

      cinfo.out_color_space = JCS_RGB;

#endif

    } else if (DECODE_TO_YCBCR_CS == mode) {

      if (cinfo.jpeg_color_space != JCS_YCbCr && cinfo.jpeg_color_space != JCS_GRAYSCALE) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "expected input color space to be JCS_YCbCr or JCS_GRAYSCALE but got %d",

                 cinfo.jpeg_color_space);

        jpeg_destroy_decompress(&cinfo);

        return status;

      }

      size_t size = 0;

      for (int i = 0; i < cinfo.num_components; i++) {

        mPlaneHStride[i] = ALIGNM(mPlaneWidth[i], cinfo.max_h_samp_factor);

        mPlaneVStride[i] = ALIGNM(mPlaneHeight[i], cinfo.max_v_samp_factor);

        size += (size_t)mPlaneHStride[i] * mPlaneVStride[i];

      }

      mResultBuffer.resize(size);

      cinfo.out_color_space = cinfo.jpeg_color_space;

      cinfo.raw_data_out = TRUE;

    }

    cinfo.dct_method = JDCT_ISLOW;

    jpeg_start_decompress(&cinfo);

    status = decode(&cinfo, static_cast<uint8_t*>(mResultBuffer.data()));

    if (status.error_code != UHDR_CODEC_OK) {

      jpeg_destroy_decompress(&cinfo);

      return status;

    }

  } else {

    status.error_code = UHDR_CODEC_ERROR;

    status.has_detail = 1;

    cinfo.err->format_message((j_common_ptr)&cinfo, status.detail);

    jpeg_destroy_decompress(&cinfo);

    return status;

  }

  jpeg_finish_decompress(&cinfo);

  jpeg_destroy_decompress(&cinfo);

  return status;

}

uhdr_error_info_t JpegDecoderHelper::decode(jpeg_decompress_struct* cinfo, uint8_t* dest) {

  uhdr_error_info_t status = g_no_error;

  switch (cinfo->out_color_space) {

    case JCS_GRAYSCALE:

      [[fallthrough]];

    case JCS_YCbCr:

      mOutFormat = getOutputSamplingFormat(cinfo);

      if (mOutFormat == UHDR_IMG_FMT_UNSPECIFIED) {

        status.error_code = UHDR_CODEC_ERROR;

        status.has_detail = 1;

        snprintf(status.detail, sizeof status.detail,

                 "unrecognized subsampling format for output color space JCS_YCbCr");

      }

      return decodeToCSYCbCr(cinfo, dest);

#ifdef JCS_ALPHA_EXTENSIONS

    case JCS_EXT_RGBA:

      mOutFormat = UHDR_IMG_FMT_32bppRGBA8888;

      return decodeToCSRGB(cinfo, dest);

#endif

    case JCS_RGB:

      mOutFormat = UHDR_IMG_FMT_24bppRGB888;

      return decodeToCSRGB(cinfo, dest);

    default:

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(status.detail, sizeof status.detail, "unrecognized output color space %d",

               cinfo->out_color_space);

  }

  return status;

}

uhdr_error_info_t JpegDecoderHelper::decodeToCSRGB(jpeg_decompress_struct* cinfo, uint8_t* dest) {

  JSAMPLE* out = (JSAMPLE*)dest;

  while (cinfo->output_scanline < cinfo->image_height) {

    JDIMENSION read_lines = jpeg_read_scanlines(cinfo, &out, 1);

    if (1 != read_lines) {

      uhdr_error_info_t status;

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(status.detail, sizeof status.detail, "jpeg_read_scanlines returned %d, expected %d",

               read_lines, 1);

      return status;

    }

#ifdef JCS_ALPHA_EXTENSIONS

    out += (size_t)mPlaneHStride[0] * 4;

#else

    out += (size_t)mPlaneHStride[0] * 3;

#endif

  }

  return g_no_error;

}

uhdr_error_info_t JpegDecoderHelper::decodeToCSYCbCr(jpeg_decompress_struct* cinfo, uint8_t* dest) {

  JSAMPROW mcuRows[kMaxNumComponents][4 * DCTSIZE];

  JSAMPROW mcuRowsTmp[kMaxNumComponents][4 * DCTSIZE];

  uint8_t* planes[kMaxNumComponents]{};

  size_t alignedPlaneWidth[kMaxNumComponents]{};

  JSAMPARRAY subImage[kMaxNumComponents];

  for (int i = 0, plane_offset = 0; i < cinfo->num_components; i++) {

    planes[i] = dest + plane_offset;

    plane_offset += mPlaneHStride[i] * mPlaneVStride[i];

    alignedPlaneWidth[i] = ALIGNM(mPlaneHStride[i], DCTSIZE);

    if (mPlaneHStride[i] != alignedPlaneWidth[i]) {

      mPlanesMCURow[i] = std::make_unique<uint8_t[]>(alignedPlaneWidth[i] * DCTSIZE *

                                                     cinfo->comp_info[i].v_samp_factor);

      uint8_t* mem = mPlanesMCURow[i].get();

      for (int j = 0; j < DCTSIZE * cinfo->comp_info[i].v_samp_factor;

           j++, mem += alignedPlaneWidth[i]) {

        mcuRowsTmp[i][j] = mem;

      }

    } else if (mPlaneVStride[i] % DCTSIZE != 0) {

      mPlanesMCURow[i] = std::make_unique<uint8_t[]>(alignedPlaneWidth[i]);

    }

    subImage[i] = mPlaneHStride[i] == alignedPlaneWidth[i] ? mcuRows[i] : mcuRowsTmp[i];

  }

  while (cinfo->output_scanline < cinfo->image_height) {

    JDIMENSION mcu_scanline_start[kMaxNumComponents];

    for (int i = 0; i < cinfo->num_components; i++) {

      mcu_scanline_start[i] =

          std::ceil(((float)cinfo->output_scanline * cinfo->comp_info[i].v_samp_factor) /

                    cinfo->max_v_samp_factor);

      for (int j = 0; j < cinfo->comp_info[i].v_samp_factor * DCTSIZE; j++) {

        JDIMENSION scanline = mcu_scanline_start[i] + j;

        if (scanline < mPlaneVStride[i]) {

          mcuRows[i][j] = planes[i] + (size_t)scanline * mPlaneHStride[i];

        } else {

          mcuRows[i][j] = mPlanesMCURow[i].get();

        }

      }

    }

    int processed = jpeg_read_raw_data(cinfo, subImage, DCTSIZE * cinfo->max_v_samp_factor);

    if (processed != DCTSIZE * cinfo->max_v_samp_factor) {

      uhdr_error_info_t status;

      status.error_code = UHDR_CODEC_ERROR;

      status.has_detail = 1;

      snprintf(status.detail, sizeof status.detail,

               "number of scan lines read %d does not equal requested scan lines %d ", processed,

               DCTSIZE * cinfo->max_v_samp_factor);

      return status;

    }

    for (int i = 0; i < cinfo->num_components; i++) {

      if (mPlaneHStride[i] != alignedPlaneWidth[i]) {

        for (int j = 0; j < cinfo->comp_info[i].v_samp_factor * DCTSIZE; j++) {

          JDIMENSION scanline = mcu_scanline_start[i] + j;

          if (scanline < mPlaneVStride[i]) {

            memcpy(mcuRows[i][j], mcuRowsTmp[i][j], mPlaneWidth[i]);

          }

        }

      }

    }

  }

  return g_no_error;

}

uhdr_raw_image_t JpegDecoderHelper::getDecompressedImage() {

  uhdr_raw_image_t img;

  img.fmt = mOutFormat;

  img.cg = UHDR_CG_UNSPECIFIED;

  img.ct = UHDR_CT_UNSPECIFIED;

  img.range = UHDR_CR_FULL_RANGE;

  img.w = mPlaneWidth[0];

  img.h = mPlaneHeight[0];

  uint8_t* data = mResultBuffer.data();

  for (int i = 0; i < 3; i++) {

    img.planes[i] = data;

    img.stride[i] = mPlaneHStride[i];

    data += (size_t)mPlaneHStride[i] * mPlaneVStride[i];

  }

  return img;

}

}  // namespace ultrahdr