//

// SPDX-License-Identifier: BSD-3-Clause

// Copyright (c) Contributors to the OpenEXR Project.

//

#ifndef INCLUDED_IMF_COMPRESSOR_H

#define INCLUDED_IMF_COMPRESSOR_H

//-----------------------------------------------------------------------------

//

//  class Compressor

//

//-----------------------------------------------------------------------------

#include "ImfForward.h"

#include "ImfCompression.h"

#include "ImfContext.h"

#include "openexr_compression.h"

#include <Imath/ImathBox.h>

#include <stdlib.h>

#include <memory>

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER

class IMF_EXPORT_TYPE Compressor

{

public:

    //---------------------------------------------

    // Constructor -- hdr is the header of the file

    // that will be compressed or uncompressed

    //---------------------------------------------

    IMF_EXPORT

    Compressor (const Header& hdr,

                exr_compression_t compression_type,

                size_t maxScanLineSize,

                int scanlines = -1);

    //-----------

    // Destructor

    //-----------

    IMF_EXPORT

    virtual ~Compressor ();

    Compressor (const Compressor& other)            = delete;

    Compressor& operator= (const Compressor& other) = delete;

    Compressor (Compressor&& other)                 = delete;

    Compressor& operator= (Compressor&& other)      = delete;

    //----------------------------------------------

    // Maximum number of scan lines processed by

    // a single call to compress() and uncompress().

    //----------------------------------------------

    IMF_EXPORT

    virtual int numScanLines () const;

    //----------------------------------------------

    // Return the compression type used by this compressor.

    //----------------------------------------------

    exr_compression_t compressionType () const { return _comp_type; }

    //--------------------------------------------

    // Format of the pixel data read and written

    // by the compress() and uncompress() methods.

    // The default implementation of format()

    // returns XDR.

    //--------------------------------------------

    enum IMF_EXPORT_ENUM Format

    {

        NATIVE, // the machine's native format

        XDR     // Xdr format

    };

    IMF_EXPORT

    virtual Format format () const;

    //----------------------------

    // Access to the file's header

    //----------------------------

    const Header& header () const { return _header; }

    //-------------------------------------------------------------------------

    // Compress an array of bytes that represents the contents of up to

    // numScanLines() scan lines:

    //

    //      inPtr   Input buffer (uncompressed data).

    //

    //      inSize    Number of bytes in the input buffer

    //

    //      minY    Minimum y coordinate of the scan lines to

    //        be compressed

    //

    //      outPtr    Pointer to output buffer

    //

    //      return value  Size of compressed data in output buffer

    //

    // Arrangement of uncompressed pixel data in the input buffer:

    //

    //  Before calling

    //

    //          compress (buf, size, minY, ...);

    //

    //  the InputFile::writePixels() method gathers pixel data from the

    //  frame buffer, fb, and places them in buffer buf, like this:

    //

    //  char *endOfBuf = buf;

    //

    //  for (int y = minY;

    //       y <= min (minY + numScanLines() - 1, header().dataWindow().max.y);

    //       ++y)

    //  {

    //      for (ChannelList::ConstIterator c = header().channels().begin();

    //     c != header().channels().end();

    //     ++c)

    //      {

    //    if (modp (y, c.channel().ySampling) != 0)

    //        continue;

    //

    //    for (int x = header().dataWindow().min.x;

    //         x <= header().dataWindow().max.x;

    //         ++x)

    //    {

    //        if (modp (x, c.channel().xSampling) != 0)

    //      continue;

    //

    //        Xdr::write<CharPtrIO> (endOfBuf, fb.pixel (c, x, y));

    //    }

    //      }

    //  }

    //

    //  int size = endOfBuf - buf;

    //

    //-------------------------------------------------------------------------

    virtual int

    compress (const char* inPtr, int inSize, int minY, const char*& outPtr);

    IMF_EXPORT

    virtual int compressTile (

        const char*            inPtr,

        int                    inSize,

        IMATH_NAMESPACE::Box2i range,

        const char*&           outPtr);

    //-------------------------------------------------------------------------

    // Uncompress an array of bytes that has been compressed by compress():

    //

    //      inPtr   Input buffer (compressed data).

    //

    //      inSize    Number of bytes in the input buffer

    //

    //      minY    Minimum y coordinate of the scan lines to

    //        be uncompressed

    //

    //      outPtr    Pointer to output buffer

    //

    //      return value  Size of uncompressed data in output buffer

    //

    //-------------------------------------------------------------------------

    virtual int uncompress (

        const char* inPtr, int inSize, int minY, const char*& outPtr);

    IMF_EXPORT

    virtual int uncompressTile (

        const char*            inPtr,

        int                    inSize,

        IMATH_NAMESPACE::Box2i range,

        const char*&           outPtr);

    void setExpectedSize (size_t sz) { _expectedSize = sz; }

    void setTileLevel (int lx, int ly) { _levelX = lx; _levelY = ly; }

    exr_storage_t storageType () const { return _store_type; }

    void setStorageType (exr_storage_t st) { _store_type = st; }

protected:

    friend int compressWithSampleCountTable (

        Compressor&  compressor,

        const char*  inPtr,

        int          inSize,

        int          minY,

        const char*& outPtr,

        const char*  sampleCountTable,

        int          sampleCountTableSize);

    friend int compressTileWithSampleCountTable (

        Compressor&            compressor,

        const char*            inPtr,

        int                    inSize,

        IMATH_NAMESPACE::Box2i range,

        const char*&           outPtr,

        const char*            sampleCountTable,

        int                    sampleCountTableSize);

    Context _ctxt;

    const Header& _header;

    size_t _maxScanLineSize = 0;

    int _numScanLines = -1;

    exr_compression_t _comp_type;

    exr_storage_t _store_type;

    exr_decode_pipeline_t _decoder = EXR_DECODE_PIPELINE_INITIALIZER;

    exr_encode_pipeline_t _encoder = EXR_ENCODE_PIPELINE_INITIALIZER;

    bool _decoder_init = false;

    bool _encoder_init = false;

    std::unique_ptr<char[]> _memory_buffer;

    uint64_t _buf_sz = 0;

    size_t _expectedSize = 0;

    int _levelX = 0;

    int _levelY = 0;

    uint64_t runEncodeStep (

        const char* inPtr,

        int inSize,

        IMATH_NAMESPACE::Box2i range,

        const char*& outPtr,

        const char* sampleCountTable = nullptr,

        int sampleCountTableSize     = 0);

    uint64_t runDecodeStep (

        const char* inPtr,

        int inSize,

        IMATH_NAMESPACE::Box2i range,

        const char*& outPtr);

};

//-----------------------------------------------------------------

// Construct a Compressor for compression type c:

//

//  maxScanLineSize Maximum number of bytes per uncompressed

//      scan line.

//

//  header    Header of the input or output file whose

//      pixels will be compressed or uncompressed.

//

//  return value  A pointer to a new Compressor object (it

//      is the caller's responsibility to delete

//      the object), or 0 (if c is NO_COMPRESSION).

//

//-----------------------------------------------------------------

IMF_EXPORT

Compressor*

newCompressor (Compression c, size_t maxScanLineSize, const Header& hdr);

//-----------------------------------------------------------------

// Construct a Compressor for compression type c for a tiled image:

//

//  tileLineSize  Maximum number of bytes per uncompressed

//      line in a tile.

//

//  numTileLines  Maximum number of lines in a tile.

//

//  header    Header of the input or output file whose

//      pixels will be compressed or uncompressed.

//

//  return value  A pointer to a new Compressor object (it

//      is the caller's responsibility to delete

//      the object), or 0 (if c is NO_COMPRESSION).

//

//-----------------------------------------------------------------

IMF_EXPORT

Compressor* newTileCompressor (

    Compression c, size_t tileLineSize, size_t numTileLines, const Header& hdr);

//-----------------------------------------------------------------

// Return the maximum number of scanlines in each chunk

// of a scanline image using the given compression scheme

//-----------------------------------------------------------------

IMF_EXPORT

int numLinesInBuffer (Compression comp);

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT

#endif