/*

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

 */

#ifndef ULTRAHDR_JPEGENCODERHELPER_H

#define ULTRAHDR_JPEGENCODERHELPER_H

#include <stdio.h>  // For jpeglib.h.

// C++ build requires extern C for jpeg internals.

#ifdef __cplusplus

extern "C" {

#endif

#include <jerror.h>

#include <jpeglib.h>

#ifdef __cplusplus

}  // extern "C"

#endif

#include <cstdint>

#include <vector>

#include "ultrahdr_api.h"

namespace ultrahdr {

/*!\brief module for managing output */

struct destination_mgr_impl : jpeg_destination_mgr {

  static const int kBlockSize = 16384;  // result buffer resize step

  std::vector<JOCTET> mResultBuffer;    // buffer to store encoded data

};

/*!\brief Encapsulates a converter from raw to jpg image format. This class is not thread-safe */

class JpegEncoderHelper {

 public:

  JpegEncoderHelper() = default;

  ~JpegEncoderHelper() = default;

  /*!\brief This function encodes the raw image that is passed to it and stores the results

   * internally. The result is accessible via getter functions.

   *

   * \param[in]  img        image to encode

   * \param[in]  qfactor    quality factor [1 - 100, 1 being poorest and 100 being best quality]

   * \param[in]  iccBuffer  pointer to icc segment that needs to be added to the compressed image

   * \param[in]  iccSize    size of icc segment

   *

   * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise.

   */

  uhdr_error_info_t compressImage(const uhdr_raw_image_t* img, const int qfactor,

                                  const void* iccBuffer, const size_t iccSize);

  /*!\brief This function encodes the raw image that is passed to it and stores the results

   * internally. The result is accessible via getter functions.

   *

   * \param[in]  planes     pointers of all planes of input image

   * \param[in]  strides    strides of all planes of input image

   * \param[in]  width      image width

   * \param[in]  height     image height

   * \param[in]  format     input raw image format

   * \param[in]  qfactor    quality factor [1 - 100, 1 being poorest and 100 being best quality]

   * \param[in]  iccBuffer  pointer to icc segment that needs to be added to the compressed image

   * \param[in]  iccSize    size of icc segment

   *

   * \return uhdr_error_info_t #UHDR_CODEC_OK if operation succeeds, uhdr_codec_err_t otherwise.

   */

  uhdr_error_info_t compressImage(const uint8_t* planes[3], const unsigned int strides[3],

                                  const int width, const int height, const uhdr_img_fmt_t format,

                                  const int qfactor, const void* iccBuffer, const size_t iccSize);

  /*! Below public methods are only effective if a call to compressImage() is made and it returned

   * true. */

  /*!\brief returns pointer to compressed image output */

  uhdr_compressed_image_t getCompressedImage();

  /*!\brief returns pointer to compressed image output

   * \deprecated This function is deprecated instead use getCompressedImage().

   */

  void* getCompressedImagePtr() { return mDestMgr.mResultBuffer.data(); }

  /*!\brief returns size of compressed image

   * \deprecated This function is deprecated instead use getCompressedImage().

   */

  size_t getCompressedImageSize() { return mDestMgr.mResultBuffer.size(); }

 private:

  // max number of components supported

  static constexpr int kMaxNumComponents = 3;

  uhdr_error_info_t encode(const uint8_t* planes[3], const unsigned int strides[3], const int width,

                           const int height, const uhdr_img_fmt_t format, const int qfactor,

                           const void* iccBuffer, const size_t iccSize);

  uhdr_error_info_t compressYCbCr(jpeg_compress_struct* cinfo, const uint8_t* planes[3],

                                  const unsigned int strides[3]);

  destination_mgr_impl mDestMgr;  // object for managing output

  // temporary storage

  std::unique_ptr<uint8_t[]> mPlanesMCURow[kMaxNumComponents];

  unsigned int mPlaneWidth[kMaxNumComponents];

  unsigned int mPlaneHeight[kMaxNumComponents];

};

} /* namespace ultrahdr  */

#endif  // ULTRAHDR_JPEGENCODERHELPER_H