//

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

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

//

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

//

//      class DeepScanLineInputFile

//

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

#include "ImfDeepScanLineInputFile.h"

#include "ImfDeepFrameBuffer.h"

#include "ImfInputPartData.h"

#include "IlmThreadPool.h"

#if ILMTHREAD_THREADING_ENABLED

#    include "IlmThreadProcessGroup.h"

#    include <mutex>

#endif

#include "Iex.h"

#include <algorithm>

#include <limits>

#include <string>

#include <vector>

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

namespace {

// same as normal scanline but w/ deep framebuffer

// TODO: template?

struct ScanLineProcess

{

    ~ScanLineProcess ()

    {

        if (!first)

            exr_decoding_destroy (decoder.context, &decoder);

    }

    void run_mem_decode (

        exr_const_context_t ctxt,

        int pn,

        const char *rawdata,

        const DeepFrameBuffer *outfb,

        int fbY,

        int fbLastY,

        const std::vector<DeepSlice> &filllist);

    void run_decode (

        exr_const_context_t ctxt,

        int pn,

        const DeepFrameBuffer *outfb,

        int fbY,

        int fbLastY,

        const std::vector<DeepSlice> &filllist);

    void run_unpack (

        exr_const_context_t ctxt,

        int pn,

        const DeepFrameBuffer *outfb,

        int fbY,

        int fbLastY,

        const std::vector<DeepSlice> &filllist);

    void update_pointers (

        const DeepFrameBuffer *outfb,

        int fbY,

        int fbLastY);

    void run_fill (

        const DeepFrameBuffer *outfb,

        int fbY,

        const std::vector<DeepSlice> &filllist);

    void copy_sample_count (

        const DeepFrameBuffer *outfb,

        int fbY);

    exr_result_t          last_decode_err = EXR_ERR_UNKNOWN;

    bool                  first = true;

    bool                  counts_only = false;

    exr_chunk_info_t      cinfo;

    exr_decode_pipeline_t decoder = EXR_DECODE_PIPELINE_INITIALIZER;

    ScanLineProcess*      next;

};

#if ILMTHREAD_THREADING_ENABLED

using ScanLineProcessGroup = ILMTHREAD_NAMESPACE::ProcessGroup<ScanLineProcess>;

#endif

} // empty namespace

struct DeepScanLineInputFile::Data

{

    Data (Context *ctxt, int pN, int nT)

    : _ctxt (ctxt)

    , partNumber (pN)

    , numThreads (nT)

    {}

    void initialize ()

    {

        if (_ctxt->storage (partNumber) != EXR_STORAGE_DEEP_SCANLINE)

            throw IEX_NAMESPACE::ArgExc ("File part is not a deep scanline part");

        version = _ctxt->version ();

    }

    std::pair<int, int> getChunkRange (int y) const;

    void readData (const DeepFrameBuffer &fb, int scanLine1, int scanLine2, bool countsOnly);

    void readMemData (

        const DeepFrameBuffer &fb,

        const char *rawPixelData,

        int scanLine1,

        int scanLine2,

        bool countsOnly);

    void prepFillList (const DeepFrameBuffer &fb, std::vector<DeepSlice> &fill);

    Context* _ctxt;

    int partNumber;

    int numThreads;

    int version;

    Header header;

    bool header_filled = false;

    bool frameBufferValid = false;

    DeepFrameBuffer frameBuffer;

    std::vector<DeepSlice> fill_list;

#if ILMTHREAD_THREADING_ENABLED

    std::mutex _mx;

    class LineBufferTask final : public ILMTHREAD_NAMESPACE::Task

    {

    public:

        LineBufferTask (

            ILMTHREAD_NAMESPACE::TaskGroup* group,

            Data*                   ifd,

            ScanLineProcessGroup*   lineg,

            const DeepFrameBuffer*  outfb,

            const exr_chunk_info_t& cinfo,

            int                     fby,

            int                     endScan,

            bool                    countsOnly)

            : Task (group)

            , _outfb (outfb)

            , _ifd (ifd)

            , _fby (fby)

            , _last_fby (endScan)

            , _line (lineg->pop ())

            , _line_group (lineg)

        {

            _line->cinfo = cinfo;

            _line->counts_only = countsOnly;

        }

        ~LineBufferTask () override

        {

            _line_group->push (_line);

        }

        void execute () override;

    private:

        void run_decode ();

        const DeepFrameBuffer* _outfb;

        Data*                  _ifd;

        int                    _fby;

        int                    _last_fby;

        ScanLineProcess*       _line;

        ScanLineProcessGroup*  _line_group;

    };

#endif

};

DeepScanLineInputFile::DeepScanLineInputFile (InputPartData* part)

    : _ctxt (part->context),

      _data (std::make_shared<Data> (&_ctxt, part->partNumber, part->numThreads))

{

    _data->initialize ();

}

DeepScanLineInputFile::DeepScanLineInputFile (

    const char*               filename,

    const ContextInitializer& ctxtinit,

    int                       numThreads)

    : _ctxt (filename, ctxtinit, Context::read_mode_t{})

    , _data (std::make_shared<Data> (&_ctxt, 0, numThreads))

{

    _data->initialize ();

}

DeepScanLineInputFile::DeepScanLineInputFile (

    const char fileName[], int numThreads)

    : DeepScanLineInputFile (

        fileName,

        ContextInitializer ()

        .silentHeaderParse (true)

        .strictHeaderValidation (false),

        numThreads)

{

}

DeepScanLineInputFile::DeepScanLineInputFile (

    OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is, int numThreads)

    : DeepScanLineInputFile (

        is.fileName (),

        ContextInitializer ()

        .silentHeaderParse (true)

        .strictHeaderValidation (false)

        .setInputStream (&is),

        numThreads)

{

}

DeepScanLineInputFile::DeepScanLineInputFile (

    const Header&                            header,

    OPENEXR_IMF_INTERNAL_NAMESPACE::IStream* is,

    int                                      version,

    int                                      numThreads)

    : DeepScanLineInputFile (

        is->fileName (),

        ContextInitializer ()

        .silentHeaderParse (true)

        .strictHeaderValidation (false)

        .setInputStream (is),

        numThreads)

{

    // who uses this interface, can we remove it?

    _data->version = version;

    _data->header = header;

    _data->header_filled = true;

}

const char*

DeepScanLineInputFile::fileName () const

{

    return _ctxt.fileName ();

}

const Header&

DeepScanLineInputFile::header () const

{

#if ILMTHREAD_THREADING_ENABLED

    std::lock_guard<std::mutex> lock (_data->_mx);

#endif

    if (!_data->header_filled)

    {

        _data->header = _ctxt.header (_data->partNumber);

        _data->header_filled = true;

    }

    return _data->header;

}

int

DeepScanLineInputFile::version () const

{

    return _data->version;

}

void

DeepScanLineInputFile::setFrameBuffer (const DeepFrameBuffer& frameBuffer)

{

#if ILMTHREAD_THREADING_ENABLED

    std::lock_guard<std::mutex> lock (_data->_mx);

#endif

    _data->prepFillList (frameBuffer, _data->fill_list);

    _data->frameBuffer = frameBuffer;

    _data->frameBufferValid = true;

}

const DeepFrameBuffer&

DeepScanLineInputFile::frameBuffer () const

{

#if ILMTHREAD_THREADING_ENABLED

    std::lock_guard<std::mutex> lock (_data->_mx);

#endif

    return _data->frameBuffer;

}

bool

DeepScanLineInputFile::isComplete () const

{

    return _ctxt.chunkTableValid (_data->partNumber);

}

void

DeepScanLineInputFile::readPixels (int scanLine1, int scanLine2)

{

    if (!_data->frameBufferValid)

    {

        throw IEX_NAMESPACE::ArgExc (

            "readPixels called with no valid frame buffer");

    }

    _data->readData (_data->frameBuffer, scanLine1, scanLine2, false);

}

void

DeepScanLineInputFile::readPixels (int scanLine)

{

    readPixels (scanLine, scanLine);

}

#pragma pack(push, 1)

struct DeepChunkHeader

{

    int32_t scanline;

    uint64_t packedCountSize;

    uint64_t packedDataSize;

    uint64_t unpackedDataSize;

};

#pragma pack(pop)

void

DeepScanLineInputFile::rawPixelData (

    int firstScanLine, char* pixelData, uint64_t& pixelDataSize)

{

    exr_chunk_info_t cinfo;

    static_assert (sizeof(DeepChunkHeader) == 28, "Expect a 28-byte chunk header");

    // api is kind of different than the normal scanline raw pixel data

    // in that it also includes the chunk header block, so the full chunk

    if (EXR_ERR_SUCCESS == exr_read_scanline_chunk_info (

            _ctxt, _data->partNumber, firstScanLine, &cinfo))

    {

        uint64_t cbytes;

        cbytes = sizeof (DeepChunkHeader);

        cbytes += cinfo.sample_count_table_size;

        cbytes += cinfo.packed_size;

        if (!pixelData || cbytes > pixelDataSize)

        {

            pixelDataSize = cbytes;

            return;

        }

        pixelDataSize = cbytes;

        DeepChunkHeader* dch = reinterpret_cast<DeepChunkHeader*> (pixelData);

        dch->scanline = cinfo.start_y;

        dch->packedCountSize = cinfo.sample_count_table_size;

        dch->packedDataSize = cinfo.packed_size;

        dch->unpackedDataSize = cinfo.unpacked_size;

        pixelData += sizeof(DeepChunkHeader);

        if (EXR_ERR_SUCCESS !=

            exr_read_deep_chunk (

                _ctxt,

                _data->partNumber,

                &cinfo,

                pixelData + cinfo.sample_count_table_size,

                pixelData))

        {

            THROW (

                IEX_NAMESPACE::ArgExc,

                "Error reading deep pixel data from image "

                "file \""

                << fileName () << "\". Unable to read raw pixel data of "

                << pixelDataSize << " bytes.");

        }

    }

    else

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "Error reading deep pixel data from image "

            "file \""

            << fileName ()

            << "\". Unable to query data block information.");

    }

}

void

DeepScanLineInputFile::readPixels (

    const char*            rawPixelData,

    const DeepFrameBuffer& frameBuffer,

    int                    scanLine1,

    int                    scanLine2) const

{

    _data->readMemData (frameBuffer, rawPixelData, scanLine1, scanLine2, false);

}

void

DeepScanLineInputFile::readPixelSampleCounts (

    const char*            rawPixelData,

    const DeepFrameBuffer& frameBuffer,

    int                    scanLine1,

    int                    scanLine2) const

{

    _data->readMemData (frameBuffer, rawPixelData, scanLine1, scanLine2, true);

}

void

DeepScanLineInputFile::readPixelSampleCounts (int scanline1, int scanline2)

{

    if (!_data->frameBufferValid)

    {

        throw IEX_NAMESPACE::ArgExc (

            "readPixelSampleCounts called with no valid frame buffer");

    }

    _data->readData (_data->frameBuffer, scanline1, scanline2, true);

}

void

DeepScanLineInputFile::readPixelSampleCounts (int scanline)

{

    readPixelSampleCounts (scanline, scanline);

}

int

DeepScanLineInputFile::firstScanLineInChunk (int y) const

{

    return _data->getChunkRange (y).first;

}

int

DeepScanLineInputFile::lastScanLineInChunk (int y) const

{

    return _data->getChunkRange (y).second;

}

std::pair<int, int> DeepScanLineInputFile::Data::getChunkRange (int y) const

{

    exr_attr_box2i_t dw = _ctxt->dataWindow (partNumber);

    int32_t scansperchunk = 1;

    if (y < dw.min.y || y > dw.max.y)

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "Requested scanline " << y << " is outside "

            "the image file's data window: "

            << dw.min.y << " - " << dw.max.y);

    }

    if (EXR_ERR_SUCCESS != exr_get_scanlines_per_chunk (*_ctxt, partNumber, &scansperchunk))

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "Error querying scanline counts from image "

            "file \"" << _ctxt->fileName () << "\".");

    }

    if (scansperchunk == 1)

        return std::make_pair( y, y );

    std::pair<int, int> ret;

    int64_t yoff;

    yoff = (int64_t) y;

    yoff -= (int64_t) dw.min.y;

    yoff /= (int64_t) scansperchunk;

    yoff *= (int64_t) scansperchunk;

    yoff += (int64_t) dw.min.y;

    ret.first = (int32_t) yoff;

    yoff += (int64_t) scansperchunk;

    yoff = std::min (yoff, (int64_t) dw.max.y);

    ret.second = (int32_t) yoff;

    return ret;

}

void

DeepScanLineInputFile::Data::readData (

    const DeepFrameBuffer &fb, int scanLine1, int scanLine2, bool countsOnly)

{

    exr_attr_box2i_t dw = _ctxt->dataWindow (partNumber);

    exr_chunk_info_t cinfo;

    int32_t          scansperchunk = 1;

    if (EXR_ERR_SUCCESS != exr_get_scanlines_per_chunk (*_ctxt, partNumber, &scansperchunk))

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "Error querying scanline counts from image "

            "file \"" << _ctxt->fileName () << "\".");

    }

    if (scanLine2 < scanLine1)

        std::swap (scanLine1, scanLine2);

    if (scanLine1 < dw.min.y || scanLine2 > dw.max.y)

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "Tried to read scan line outside "

            "the image file's data window: "

            << scanLine1 << " - " << scanLine2

            << " vs datawindow "

            << dw.min.y << " - " << dw.max.y);

    }

#if ILMTHREAD_THREADING_ENABLED

    int64_t nchunks;

    nchunks = ((int64_t) scanLine2 - (int64_t) scanLine1);

    nchunks /= (int64_t) scansperchunk;

    nchunks += 1;

    if (nchunks > 1 && numThreads > 1)

    {

        // we need the lifetime of this to last longer than the

        // lifetime of the task group below such that we don't get use

        // after free type error, so use scope rules to accomplish

        // this

        ScanLineProcessGroup sg (numThreads);

        {

            ILMTHREAD_NAMESPACE::TaskGroup tg;

            for (int y = scanLine1; y <= scanLine2; )

            {

                if (EXR_ERR_SUCCESS != exr_read_scanline_chunk_info (*_ctxt, partNumber, y, &cinfo))

                    throw IEX_NAMESPACE::InputExc ("Unable to query scanline information");

                ILMTHREAD_NAMESPACE::ThreadPool::addGlobalTask (

                    new LineBufferTask (&tg, this, &sg, &fb, cinfo, y, scanLine2, countsOnly) );

                y += scansperchunk - (y - cinfo.start_y);

            }

        }

        sg.throw_on_failure ();

    }

    else

#endif

    {

        ScanLineProcess sp;

        bool redo = true;

        sp.counts_only = countsOnly;

        for (int y = scanLine1; y <= scanLine2; )

        {

            if (EXR_ERR_SUCCESS != exr_read_scanline_chunk_info (*_ctxt, partNumber, y, &cinfo))

                throw IEX_NAMESPACE::InputExc ("Unable to query scanline information");

            // Check if we have the same chunk where we can just

            // re-run the unpack (i.e. people reading 1 scan at a time

            // in a multi-scanline chunk)

            if (!redo &&

                sp.cinfo.idx == cinfo.idx &&

                sp.last_decode_err == EXR_ERR_SUCCESS)

            {

                sp.run_unpack (

                    *_ctxt,

                    partNumber,

                    &fb,

                    y,

                    scanLine2,

                    fill_list);

            }

            else

            {

                sp.cinfo = cinfo;

                sp.run_decode (

                    *_ctxt,

                    partNumber,

                    &fb,

                    y,

                    scanLine2,

                    fill_list);

                redo = false;

            }

            y += scansperchunk - (y - cinfo.start_y);

        }

    }

}

////////////////////////////////////////

void

DeepScanLineInputFile::Data::readMemData (

        const DeepFrameBuffer &fb,

        const char *rawPixelData,

        int scanLine1,

        int scanLine2,

        bool countsOnly)

{

    const DeepChunkHeader* dch = reinterpret_cast<const DeepChunkHeader*> (rawPixelData);

    std::pair<int, int> range = getChunkRange (scanLine1);

    if (dch->scanline != scanLine1)

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "readPixelSampleCounts(rawPixelData,frameBuffer,"

                << scanLine1 << ',' << scanLine2

                << ") called with incorrect start scanline - should be "

                << dch->scanline);

    }

    if (scanLine2 != range.second)

    {

        THROW (

            IEX_NAMESPACE::ArgExc,

            "readPixelSampleCounts(rawPixelData,frameBuffer,"

                << scanLine1 << ',' << scanLine2

                << ") called with incorrect end scanline - should be " << range.second);

    }

    rawPixelData += sizeof(DeepChunkHeader);

    std::vector<DeepSlice> fills;

    ScanLineProcess proc;

    if (countsOnly)

    {

        const Slice& scslice = fb.getSampleCountSlice ();

        if (!scslice.base)

        {

            throw IEX_NAMESPACE::ArgExc (

                "Invalid base pointer, please set a proper sample count slice.");

        }

        if (scslice.type != OPENEXR_IMF_INTERNAL_NAMESPACE::UINT)

        {

            throw IEX_NAMESPACE::ArgExc (

                "The type of sample count slice should be UINT.");

        }

    }

    if (!countsOnly)

        prepFillList(fb, fills);

    if (EXR_ERR_SUCCESS != exr_read_scanline_chunk_info (

            *_ctxt, partNumber, scanLine1, &proc.cinfo))

        throw IEX_NAMESPACE::InputExc ("Unable to query scanline information");

    proc.counts_only = countsOnly;

    proc.run_mem_decode (

        *_ctxt,

        partNumber,

        rawPixelData,

        &fb,

        scanLine1,

        scanLine2,

        fills);

}

////////////////////////////////////////

void DeepScanLineInputFile::Data::prepFillList (

    const DeepFrameBuffer &fb, std::vector<DeepSlice> &fill)

{

    const Slice& sampleCountSlice = fb.getSampleCountSlice ();

    fill.clear ();

    if (!sampleCountSlice.base)

    {

        throw IEX_NAMESPACE::ArgExc (

            "Invalid base pointer, please set a proper sample count slice.");

    }

    for (DeepFrameBuffer::ConstIterator j = fb.begin (); j != fb.end (); ++j)

    {

        const exr_attr_chlist_entry_t* curc = _ctxt->findChannel (

            partNumber, j.name ());

        if (!curc)

        {

            fill.push_back (j.slice ());

            continue;

        }

        if (curc->x_sampling != j.slice ().xSampling ||

            curc->y_sampling != j.slice ().ySampling)

            THROW (

                IEX_NAMESPACE::ArgExc,

                "X and/or y subsampling factors "

                "of \""

                    << j.name ()

                    << "\" channel "

                       "of input file \""

                    << _ctxt->fileName ()

                    << "\" are "

                       "not compatible with the frame buffer's "

                       "subsampling factors.");

    }

}

////////////////////////////////////////

#if ILMTHREAD_THREADING_ENABLED

void DeepScanLineInputFile::Data::LineBufferTask::execute ()

{

    try

    {

        _line->run_decode (

            *(_ifd->_ctxt),

            _ifd->partNumber,

            _outfb,

            _fby,

            _last_fby,

            _ifd->fill_list);

    }

    catch (std::exception &e)

    {

        _line_group->record_failure (e.what ());

    }

    catch (...)

    {

        _line_group->record_failure ("Unknown exception");

    }

}

#endif

////////////////////////////////////////

static exr_result_t

mem_skip_read_chunk (exr_decode_pipeline_t* decode)

{

    return EXR_ERR_SUCCESS;

}

void ScanLineProcess::run_mem_decode (

        exr_const_context_t ctxt,

        int pn,

        const char *rawdata,

        const DeepFrameBuffer *outfb,

        int fbY,

        int fbLastY,

        const std::vector<DeepSlice> &filllist)

{

    if (!first)

        throw IEX_NAMESPACE::ArgExc ("Expect single-use process");

    if (EXR_ERR_SUCCESS != exr_decoding_initialize (ctxt, pn, &cinfo, &decoder))

        throw IEX_NAMESPACE::IoExc ("Unable to initialize decode pipeline");

    // Set first to false to allow destructor to deallocate any buffers

    // allocated during decoding.

    first = false;

    decoder.decode_flags |= EXR_DECODE_NON_IMAGE_DATA_AS_POINTERS;

    decoder.decode_flags |= EXR_DECODE_SAMPLE_COUNTS_AS_INDIVIDUAL;

    if (counts_only)

        decoder.decode_flags |= EXR_DECODE_SAMPLE_DATA_ONLY;

    update_pointers (outfb, fbY, fbLastY);

    if (EXR_ERR_SUCCESS !=

        exr_decoding_choose_default_routines (ctxt, pn, &decoder))

    {

        throw IEX_NAMESPACE::IoExc ("Unable to choose decoder routines");

    }

    decoder.read_fn = &mem_skip_read_chunk;

    // leave alloc sizes at 0 such that the decode pipeline doesn't

    // attempt to free, making it safe to cast const away

    decoder.packed_sample_count_table = const_cast<char*> (rawdata);

    rawdata += cinfo.sample_count_table_size;

    decoder.packed_buffer = const_cast<char*> (rawdata);

    last_decode_err = exr_decoding_run (ctxt, pn, &decoder);

    if (EXR_ERR_SUCCESS != last_decode_err)

        throw IEX_NAMESPACE::IoExc ("Unable to run decoder");

    copy_sample_count (outfb, fbY);

    if (counts_only)

        return;

    run_fill (outfb, fbY, filllist);

}

////////////////////////////////////////

void ScanLineProcess::run_decode (

    exr_const_context_t ctxt,

    int pn,

    const DeepFrameBuffer *outfb,

    int fbY,

    int fbLastY,

    const std::vector<DeepSlice> &filllist)

{

    last_decode_err = EXR_ERR_UNKNOWN;

    uint8_t flags;

    if (first)

    {

        if (EXR_ERR_SUCCESS !=

            exr_decoding_initialize (ctxt, pn, &cinfo, &decoder))

        {

            throw IEX_NAMESPACE::IoExc ("Unable to initialize decode pipeline");

        }

        decoder.decode_flags |= EXR_DECODE_NON_IMAGE_DATA_AS_POINTERS;

        decoder.decode_flags |= EXR_DECODE_SAMPLE_COUNTS_AS_INDIVIDUAL;

        flags = 0;

        first = false;

    }

    else

    {

        if (EXR_ERR_SUCCESS !=

            exr_decoding_update (ctxt, pn, &cinfo, &decoder))

        {

            throw IEX_NAMESPACE::IoExc ("Unable to update decode pipeline");

        }

        flags = decoder.decode_flags;

    }

    if (counts_only)

        decoder.decode_flags |= EXR_DECODE_SAMPLE_DATA_ONLY;

    else

        decoder.decode_flags = decoder.decode_flags & ~EXR_DECODE_SAMPLE_DATA_ONLY;

    update_pointers (outfb, fbY, fbLastY);

    if (flags != decoder.decode_flags)

    {

        if (EXR_ERR_SUCCESS !=

            exr_decoding_choose_default_routines (ctxt, pn, &decoder))

        {

            throw IEX_NAMESPACE::IoExc ("Unable to choose decoder routines");

        }

    }

    last_decode_err = exr_decoding_run (ctxt, pn, &decoder);

    if (EXR_ERR_SUCCESS != last_decode_err)

        throw IEX_NAMESPACE::IoExc ("Unable to run decoder");

    copy_sample_count (outfb, fbY);

    if (counts_only)

        return;

    run_fill (outfb, fbY, filllist);

}

////////////////////////////////////////

void ScanLineProcess::run_unpack (

    exr_const_context_t ctxt,

    int pn,

    const DeepFrameBuffer *outfb,

    int fbY,

    int fbLastY,

    const std::vector<DeepSlice> &filllist)

{

    update_pointers (outfb, fbY, fbLastY);

    copy_sample_count (outfb, fbY);

    if (counts_only)

        return;

    /* won't work for deep where we need to re-allocate the number of

     * samples but for scenario where we have separated sample count read

     * and deep sample alloc, should be fine to bypass pipe

     * and run the unpacker */

    if (decoder.chunk.unpacked_size > 0 && decoder.unpack_and_convert_fn)

    {

        last_decode_err = decoder.unpack_and_convert_fn (&decoder);

        if (EXR_ERR_SUCCESS != last_decode_err)

            throw IEX_NAMESPACE::IoExc ("Unable to run decoder");

    }

    run_fill (outfb, fbY, filllist);

}

////////////////////////////////////////

void ScanLineProcess::update_pointers (

    const DeepFrameBuffer *outfb, int fbY, int fbLastY)

{

    decoder.user_line_begin_skip = fbY - cinfo.start_y;

    decoder.user_line_end_ignore = 0;

    int64_t endY = (int64_t)cinfo.start_y + (int64_t)cinfo.height - 1;

    if ((int64_t)fbLastY < endY)

        decoder.user_line_end_ignore = (int32_t)(endY - fbLastY);

    if (counts_only)

        return;

    for (int c = 0; c < decoder.channel_count; ++c)

    {

        exr_coding_channel_info_t& curchan = decoder.channels[c];

        uint8_t*                   ptr;

        const DeepSlice*           fbslice;

        fbslice = outfb->findSlice (curchan.channel_name);

        if (curchan.height == 0 || !fbslice)

        {

            curchan.decode_to_ptr     = NULL;

            curchan.user_pixel_stride = 0;

            curchan.user_line_stride  = 0;

            continue;

        }

        curchan.user_bytes_per_element = fbslice->sampleStride;

        curchan.user_data_type         = (exr_pixel_type_t)fbslice->type;

        curchan.user_pixel_stride      = fbslice->xStride;

        curchan.user_line_stride       = fbslice->yStride;

        ptr  = reinterpret_cast<uint8_t*> (fbslice->base);

        ptr += int64_t (cinfo.start_x) * int64_t (fbslice->xStride);

        ptr += int64_t (fbY) * int64_t (fbslice->yStride);

        curchan.decode_to_ptr = ptr;

    }

}

////////////////////////////////////////

void ScanLineProcess::run_fill (

    const DeepFrameBuffer *outfb,

    int fbY,

    const std::vector<DeepSlice> &filllist)

{

    for (auto& fills: filllist)

    {

        uint8_t*       ptr;

        if (fills.xSampling != 1 || fills.ySampling != 1)

            throw IEX_NAMESPACE::InputExc ("Expect sampling of 1");

        ptr  = reinterpret_cast<uint8_t*> (fills.base);

        ptr += int64_t (cinfo.start_x) * int64_t (fills.xStride);

        ptr += int64_t (fbY) * int64_t (fills.yStride);

        // TODO: update ImfMisc, lift fill type / value

        int stop = cinfo.start_y + cinfo.height - decoder.user_line_end_ignore;

        for ( int y = fbY; y < stop; ++y )

        {

            const int32_t* counts = decoder.sample_count_table;

            counts += ((int64_t) y - (int64_t) cinfo.start_y) * (int64_t) cinfo.width;

            uint8_t* outptr = ptr;

            for ( int sx = 0, ex = cinfo.width; sx < ex; ++sx )

            {

                int32_t samps = counts[sx];

                void *dest = *((void **)outptr);

                if (samps == 0 || dest == nullptr)

                {

                    outptr += fills.xStride;

                    continue;

                }

                switch (fills.type)

                {

                    case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                    {

                        unsigned int fillVal = (unsigned int) (fills.fillValue);

                        unsigned int* fillptr = static_cast<unsigned int*> (dest);

                        for ( int32_t s = 0; s < samps; ++s )

                            fillptr[s] = fillVal;

                        break;

                    }

                    case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                    {

                        half fillVal = half (fills.fillValue);

                        half* fillptr = static_cast<half*> (dest);

                        for ( int32_t s = 0; s < samps; ++s )

                            fillptr[s] = fillVal;

                        break;

                    }

                    case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                    {

                        float fillVal = float (fills.fillValue);

                        float* fillptr = static_cast<float*> (dest);

                        for ( int32_t s = 0; s < samps; ++s )

                            fillptr[s] = fillVal;

                        break;

                    }

                    default: