/*
 * 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