/*

 * Copyright (c) 2006 Konstantin Shishkov

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

/**

 * @file

 * TIFF image decoder

 * @author Konstantin Shishkov

 */

#include "config.h"

#if CONFIG_ZLIB

#include <zlib.h>

#endif

#if CONFIG_LZMA

#define LZMA_API_STATIC

#include <lzma.h>

#endif

#include <float.h>

#include "libavutil/attributes.h"

#include "libavutil/attributes_internal.h"

#include "libavutil/avstring.h"

#include "libavutil/error.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/mem.h"

#include "libavutil/opt.h"

#include "libavutil/reverse.h"

#include "avcodec.h"

#include "bytestream.h"

#include "codec_internal.h"

#include "decode.h"

#include "exif_internal.h"

#include "faxcompr.h"

#include "lzw.h"

#include "tiff.h"

#include "tiff_common.h"

#include "tiff_data.h"

#include "mjpegdec.h"

#include "thread.h"

#include "get_bits.h"

typedef struct TiffContext {

    AVClass *class;

    AVCodecContext *avctx;

    GetByteContext gb;

    /* JPEG decoding for DNG */

    AVCodecContext *avctx_mjpeg; // wrapper context for MJPEG

    AVPacket *jpkt;              // encoded JPEG tile

    AVFrame *jpgframe;           // decoded JPEG tile

    int get_subimage;

    uint16_t get_page;

    int get_thumbnail;

    enum TiffType tiff_type;

    int width, height;

    unsigned int bpp, bppcount;

    uint32_t palette[256];

    int palette_is_set;

    int le;

    enum TiffCompr compr;

    enum TiffPhotometric photometric;

    int planar;

    int subsampling[2];

    int fax_opts;

    int predictor;

    int fill_order;

    uint32_t res[4];

    int is_thumbnail;

    unsigned last_tag;

    int is_bayer;

    int use_color_matrix;

    uint8_t pattern[4];

    float   analog_balance[4];

    float   as_shot_neutral[4];

    float   as_shot_white[4];

    float   color_matrix[3][4];

    float   camera_calibration[4][4];

    float   premultiply[4];

    float   black_level[4];

    unsigned white_level;

    uint16_t dng_lut[65536];

    uint32_t sub_ifd;

    uint16_t cur_page;

    int strips, rps, sstype;

    int sot;

    int stripsizesoff, stripsize, stripoff, strippos;

    LZWState *lzw;

    /* Tile support */

    int is_tiled;

    int tile_byte_counts_offset, tile_offsets_offset;

    int tile_width, tile_length;

    int is_jpeg;

    uint8_t *deinvert_buf;

    int deinvert_buf_size;

    uint8_t *yuv_line;

    unsigned int yuv_line_size;

    int geotag_count;

    TiffGeoTag *geotags;

    AVExifMetadata exif_meta;

} TiffContext;

static const float d65_white[3] = { 0.950456f, 1.f, 1.088754f };

static void tiff_set_type(TiffContext *s, enum TiffType tiff_type) {

    if (s->tiff_type < tiff_type) // Prioritize higher-valued entries

        s->tiff_type = tiff_type;

}

static void free_geotags(TiffContext *const s)

{

    for (int i = 0; i < s->geotag_count; i++)

        av_freep(&s->geotags[i].val);

    av_freep(&s->geotags);

    s->geotag_count = 0;

}

static const char *get_geokey_name(int key)

{

#define RET_GEOKEY_STR(TYPE, array)\

    if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\

        key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\

        return tiff_##array##_name_type_string + tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].offset;

    RET_GEOKEY_STR(VERT, vert);

    RET_GEOKEY_STR(PROJ, proj);

    RET_GEOKEY_STR(GEOG, geog);

    RET_GEOKEY_STR(CONF, conf);

    return NULL;

}

static int get_geokey_type(int key)

{

#define RET_GEOKEY_TYPE(TYPE, array)\

    if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\

        key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\

        return tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].type;

    RET_GEOKEY_TYPE(VERT, vert);

    RET_GEOKEY_TYPE(PROJ, proj);

    RET_GEOKEY_TYPE(GEOG, geog);

    RET_GEOKEY_TYPE(CONF, conf);

    return AVERROR_INVALIDDATA;

}

static int cmp_id_key(const void *id, const void *k)

{

    return *(const int*)id - ((const TiffGeoTagKeyName*)k)->key;

}

static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id)

{

    const TiffGeoTagKeyName *r = bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key);

    if(r)

        return r->name;

    return NULL;

}

static const char *get_geokey_val(int key, uint16_t val)

{

    if (val == TIFF_GEO_KEY_UNDEFINED)

        return "undefined";

    if (val == TIFF_GEO_KEY_USER_DEFINED)

        return "User-Defined";

#define RET_GEOKEY_VAL(TYPE, array)\

    if (val >= TIFF_##TYPE##_OFFSET &&\

        val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_codes))\

        return tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET];

    switch (key) {

    case TIFF_GT_MODEL_TYPE_GEOKEY:

        RET_GEOKEY_VAL(GT_MODEL_TYPE, gt_model_type);

        break;

    case TIFF_GT_RASTER_TYPE_GEOKEY:

        RET_GEOKEY_VAL(GT_RASTER_TYPE, gt_raster_type);

        break;

    case TIFF_GEOG_LINEAR_UNITS_GEOKEY:

    case TIFF_PROJ_LINEAR_UNITS_GEOKEY:

    case TIFF_VERTICAL_UNITS_GEOKEY:

        RET_GEOKEY_VAL(LINEAR_UNIT, linear_unit);

        break;

    case TIFF_GEOG_ANGULAR_UNITS_GEOKEY:

    case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY:

        RET_GEOKEY_VAL(ANGULAR_UNIT, angular_unit);

        break;

    case TIFF_GEOGRAPHIC_TYPE_GEOKEY:

        RET_GEOKEY_VAL(GCS_TYPE, gcs_type);

        RET_GEOKEY_VAL(GCSE_TYPE, gcse_type);

        break;

    case TIFF_GEOG_GEODETIC_DATUM_GEOKEY:

        RET_GEOKEY_VAL(GEODETIC_DATUM, geodetic_datum);

        RET_GEOKEY_VAL(GEODETIC_DATUM_E, geodetic_datum_e);

        break;

    case TIFF_GEOG_ELLIPSOID_GEOKEY:

        RET_GEOKEY_VAL(ELLIPSOID, ellipsoid);

        break;

    case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY:

        RET_GEOKEY_VAL(PRIME_MERIDIAN, prime_meridian);

        break;

    case TIFF_PROJECTED_CS_TYPE_GEOKEY:

        return search_keyval(tiff_proj_cs_type_codes, FF_ARRAY_ELEMS(tiff_proj_cs_type_codes), val);

    case TIFF_PROJECTION_GEOKEY:

        return search_keyval(tiff_projection_codes, FF_ARRAY_ELEMS(tiff_projection_codes), val);

    case TIFF_PROJ_COORD_TRANS_GEOKEY:

        RET_GEOKEY_VAL(COORD_TRANS, coord_trans);

        break;

    case TIFF_VERTICAL_CS_TYPE_GEOKEY:

        RET_GEOKEY_VAL(VERT_CS, vert_cs);

        RET_GEOKEY_VAL(ORTHO_VERT_CS, ortho_vert_cs);

        break;

    }

    return NULL;

}

static char *doubles2str(double *dp, int count, const char *sep)

{

    int i;

    char *ap, *ap0;

    uint64_t component_len;

    if (!sep) sep = ", ";

    component_len = 24LL + strlen(sep);

    if (count >= (INT_MAX - 1)/component_len)

        return NULL;

    ap = av_malloc(component_len * count + 1);

    if (!ap)

        return NULL;

    ap0   = ap;

    ap[0] = '\0';

    for (i = 0; i < count; i++) {

        unsigned l = snprintf(ap, component_len, "%.15g%s", dp[i], sep);

        if(l >= component_len) {

            av_free(ap0);

            return NULL;

        }

        ap += l;

    }

    ap0[strlen(ap0) - strlen(sep)] = '\0';

    return ap0;

}

static int add_metadata(int count, int type,

                        const char *name, const char *sep, TiffContext *s, AVFrame *frame)

{

    switch(type) {

    case AV_TIFF_DOUBLE: return ff_tadd_doubles_metadata(count, name, sep, &s->gb, s->le, &frame->metadata);

    case AV_TIFF_SHORT : return ff_tadd_shorts_metadata(count, name, sep, &s->gb, s->le, 0, &frame->metadata);

    case AV_TIFF_STRING: return ff_tadd_string_metadata(count, name, &s->gb, s->le, &frame->metadata);

    default         : return AVERROR_INVALIDDATA;

    };

}

/**

 * Map stored raw sensor values into linear reference values (see: DNG Specification - Chapter 5)

 */

static uint16_t av_always_inline dng_process_color16(uint16_t value,

                                                     const uint16_t *lut,

                                                     float black_level,

                                                     float scale_factor)

{

    float value_norm;

    // Lookup table lookup

    value = lut[value];

    // Black level subtraction

    // Color scaling

    value_norm = ((float)value - black_level) * scale_factor;

    value = av_clip_uint16(lrintf(value_norm));

    return value;

}

static uint16_t av_always_inline dng_process_color8(uint16_t value,

                                                    const uint16_t *lut,

                                                    float black_level,

                                                    float scale_factor)

{

    return dng_process_color16(value, lut, black_level, scale_factor) >> 8;

}

static void av_always_inline dng_blit(TiffContext *s, uint8_t *dst, int dst_stride,

                                      const uint8_t *src, int src_stride, int width, int height,

                                      int is_single_comp, int is_u16, int odd_line)

{

    float scale_factor[4];

    int line, col;

    if (s->is_bayer) {

        for (int i = 0; i < 4; i++)

            scale_factor[i] = s->premultiply[s->pattern[i]] * 65535.f / (s->white_level - s->black_level[i]);

    } else {

        for (int i = 0; i < 4; i++)

            scale_factor[i] = s->premultiply[           i ] * 65535.f / (s->white_level - s->black_level[i]);

    }

    if (is_single_comp) {

        if (!is_u16)

            return; /* <= 8bpp unsupported */

        /* Image is double the width and half the height we need, each row comprises 2 rows of the output

           (split vertically in the middle). */

        for (line = 0; line < height / 2; line++) {

            uint16_t *dst_u16 = (uint16_t *)dst;

            const uint16_t *src_u16 = (const uint16_t *)src;

            /* Blit first half of input row row to initial row of output */

            for (col = 0; col < width; col++)

                *dst_u16++ = dng_process_color16(*src_u16++, s->dng_lut, s->black_level[col&1], scale_factor[col&1]);

            /* Advance the destination pointer by a row (source pointer remains in the same place) */

            dst += dst_stride * sizeof(uint16_t);

            dst_u16 = (uint16_t *)dst;

            /* Blit second half of input row row to next row of output */

            for (col = 0; col < width; col++)

                *dst_u16++ = dng_process_color16(*src_u16++, s->dng_lut, s->black_level[(col&1) + 2], scale_factor[(col&1) + 2]);

            dst += dst_stride * sizeof(uint16_t);

            src += src_stride * sizeof(uint16_t);

        }

    } else {

        /* Input and output image are the same size and the MJpeg decoder has done per-component

           deinterleaving, so blitting here is straightforward. */

        if (is_u16) {

            for (line = 0; line < height; line++) {

                uint16_t *dst_u16 = (uint16_t *)dst;

                const uint16_t *src_u16 = (const uint16_t *)src;

                for (col = 0; col < width; col++)

                    *dst_u16++ = dng_process_color16(*src_u16++, s->dng_lut,

                                                     s->black_level[(col&1) + 2 * ((line&1) + odd_line)],

                                                     scale_factor[(col&1) + 2 * ((line&1) + odd_line)]);

                dst += dst_stride * sizeof(uint16_t);

                src += src_stride * sizeof(uint16_t);

            }

        } else {

            for (line = 0; line < height; line++) {

                uint8_t *dst_u8 = dst;

                const uint8_t *src_u8 = src;

                for (col = 0; col < width; col++)

                    *dst_u8++ = dng_process_color8(*src_u8++, s->dng_lut,

                                                   s->black_level[(col&1) + 2 * ((line&1) + odd_line)],

                                                   scale_factor[(col&1) + 2 * ((line&1) + odd_line)]);

                dst += dst_stride;

                src += src_stride;

            }

        }

    }

}

static void av_always_inline horizontal_fill(TiffContext *s,

                                             unsigned int bpp, uint8_t* dst,

                                             int usePtr, const uint8_t *src,

                                             uint8_t c, int width, int offset)

{

    switch (bpp) {

    case 1:

        while (--width >= 0) {

            dst[(width+offset)*8+7] = (usePtr ? src[width] : c)      & 0x1;

            dst[(width+offset)*8+6] = (usePtr ? src[width] : c) >> 1 & 0x1;

            dst[(width+offset)*8+5] = (usePtr ? src[width] : c) >> 2 & 0x1;

            dst[(width+offset)*8+4] = (usePtr ? src[width] : c) >> 3 & 0x1;

            dst[(width+offset)*8+3] = (usePtr ? src[width] : c) >> 4 & 0x1;

            dst[(width+offset)*8+2] = (usePtr ? src[width] : c) >> 5 & 0x1;

            dst[(width+offset)*8+1] = (usePtr ? src[width] : c) >> 6 & 0x1;

            dst[(width+offset)*8+0] = (usePtr ? src[width] : c) >> 7;

        }

        break;

    case 2:

        while (--width >= 0) {

            dst[(width+offset)*4+3] = (usePtr ? src[width] : c) & 0x3;

            dst[(width+offset)*4+2] = (usePtr ? src[width] : c) >> 2 & 0x3;

            dst[(width+offset)*4+1] = (usePtr ? src[width] : c) >> 4 & 0x3;

            dst[(width+offset)*4+0] = (usePtr ? src[width] : c) >> 6;

        }

        break;

    case 4:

        while (--width >= 0) {

            dst[(width+offset)*2+1] = (usePtr ? src[width] : c) & 0xF;

            dst[(width+offset)*2+0] = (usePtr ? src[width] : c) >> 4;

        }

        break;

    case 10:

    case 12:

    case 14: {

            uint16_t *dst16 = (uint16_t *)dst;

            int is_dng = (s->tiff_type == TIFF_TYPE_DNG || s->tiff_type == TIFF_TYPE_CINEMADNG);

            uint8_t shift = is_dng ? 0 : 16 - bpp;

            GetBitContext gb;

            av_unused int ret = init_get_bits8(&gb, src, width);

            av_assert1(ret >= 0);

            for (int i = 0; i < s->width; i++) {

                dst16[i] = get_bits(&gb, bpp) << shift;

            }

        }

        break;

    default:

        if (usePtr) {

            memcpy(dst + offset, src, width);

        } else {

            memset(dst + offset, c, width);

        }

    }

}

static int deinvert_buffer(TiffContext *s, const uint8_t *src, int size)

{

    int i;

    av_fast_padded_malloc(&s->deinvert_buf, &s->deinvert_buf_size, size);

    if (!s->deinvert_buf)

        return AVERROR(ENOMEM);

    for (i = 0; i < size; i++)

        s->deinvert_buf[i] = ff_reverse[src[i]];

    return 0;

}

static void unpack_gray(TiffContext *s, AVFrame *p,

                       const uint8_t *src, int lnum, int width, int bpp)

{

    GetBitContext gb;

    uint16_t *dst = (uint16_t *)(p->data[0] + lnum * p->linesize[0]);

    av_unused int ret = init_get_bits8(&gb, src, width);

    av_assert1(ret >= 0);

    for (int i = 0; i < s->width; i++) {

        dst[i] = get_bits(&gb, bpp);

    }

}

static void unpack_yuv(TiffContext *s, AVFrame *p,

                       const uint8_t *src, int lnum)

{

    int i, j, k;

    int w       = (s->width - 1) / s->subsampling[0] + 1;

    uint8_t *pu = &p->data[1][lnum / s->subsampling[1] * p->linesize[1]];

    uint8_t *pv = &p->data[2][lnum / s->subsampling[1] * p->linesize[2]];

    if (s->width % s->subsampling[0] || s->height % s->subsampling[1]) {

        for (i = 0; i < w; i++) {

            for (j = 0; j < s->subsampling[1]; j++)

                for (k = 0; k < s->subsampling[0]; k++)

                    p->data[0][FFMIN(lnum + j, s->height-1) * p->linesize[0] +

                               FFMIN(i * s->subsampling[0] + k, s->width-1)] = *src++;

            *pu++ = *src++;

            *pv++ = *src++;

        }

    }else{

        for (i = 0; i < w; i++) {

            for (j = 0; j < s->subsampling[1]; j++)

                for (k = 0; k < s->subsampling[0]; k++)

                    p->data[0][(lnum + j) * p->linesize[0] +

                               i * s->subsampling[0] + k] = *src++;

            *pu++ = *src++;

            *pv++ = *src++;

        }

    }

}

#if CONFIG_ZLIB

static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,

                           int size)

{

    z_stream zstream = { 0 };

    int zret;

    zstream.next_in   = src;

    zstream.avail_in  = size;

    zstream.next_out  = dst;

    zstream.avail_out = *len;

    zret              = inflateInit(&zstream);

    if (zret != Z_OK) {

        av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);

        return zret;

    }

    zret = inflate(&zstream, Z_SYNC_FLUSH);

    inflateEnd(&zstream);

    *len = zstream.total_out;

    return zret == Z_STREAM_END ? Z_OK : zret;

}

static int tiff_unpack_zlib(TiffContext *s, AVFrame *p, uint8_t *dst, int stride,

                            const uint8_t *src, int size, int width, int lines,

                            int strip_start, int is_yuv)

{

    uint8_t *zbuf;

    unsigned long outlen;

    int ret, line;

    int rows = is_yuv ? (lines + s->subsampling[1] - 1) / s->subsampling[1] : lines;

    outlen = width * lines;

    zbuf   = av_malloc(outlen);

    if (!zbuf)

        return AVERROR(ENOMEM);

    if (s->fill_order) {

        if ((ret = deinvert_buffer(s, src, size)) < 0) {

            av_free(zbuf);

            return ret;

        }

        src = s->deinvert_buf;

    }

    ret = tiff_uncompress(zbuf, &outlen, src, size);

    if (ret != Z_OK) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Uncompressing failed (%lu of %lu) with error %d\n", outlen,

               (unsigned long)width * lines, ret);

        av_free(zbuf);

        return AVERROR_UNKNOWN;

    }

    if (outlen < (unsigned long)width * rows) {

        av_log(s->avctx, AV_LOG_ERROR, "Deflated %lu bytes, but %lu are needed\n",

               outlen, (unsigned long)width * rows);

        av_free(zbuf);

        return AVERROR_INVALIDDATA;

    }

    src = zbuf;

    for (line = 0; line < lines; line++) {

        if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {

            horizontal_fill(s, s->bpp, dst, 1, src, 0, width, 0);

        } else {

            memcpy(dst, src, width);

        }

        if (is_yuv) {

            unpack_yuv(s, p, dst, strip_start + line);

            line += s->subsampling[1] - 1;

        }

        dst += stride;

        src += width;

    }

    av_free(zbuf);

    return 0;

}

#endif

#if CONFIG_LZMA

static int tiff_uncompress_lzma(uint8_t *dst, uint64_t *len, const uint8_t *src,

                                int size)

{

    lzma_stream stream = LZMA_STREAM_INIT;

    lzma_ret ret;

    stream.next_in   = src;

    stream.avail_in  = size;

    stream.next_out  = dst;

    stream.avail_out = *len;

    ret              = lzma_stream_decoder(&stream, UINT64_MAX, 0);

    if (ret != LZMA_OK) {

        av_log(NULL, AV_LOG_ERROR, "LZMA init error: %d\n", ret);

        return ret;

    }

    ret = lzma_code(&stream, LZMA_RUN);

    lzma_end(&stream);

    *len = stream.total_out;

    return ret == LZMA_STREAM_END ? LZMA_OK : ret;

}

static int tiff_unpack_lzma(TiffContext *s, AVFrame *p, uint8_t *dst, int stride,

                            const uint8_t *src, int size, int width, int lines,

                            int strip_start, int is_yuv)

{

    uint64_t outlen = width * (uint64_t)lines;

    int ret, line;

    int rows = is_yuv ? (lines + s->subsampling[1] - 1) / s->subsampling[1] : lines;

    uint8_t *buf = av_malloc(outlen);

    if (!buf)

        return AVERROR(ENOMEM);

    if (s->fill_order) {

        if ((ret = deinvert_buffer(s, src, size)) < 0) {

            av_free(buf);

            return ret;

        }

        src = s->deinvert_buf;

    }

    ret = tiff_uncompress_lzma(buf, &outlen, src, size);

    if (ret != LZMA_OK) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Uncompressing failed (%"PRIu64" of %"PRIu64") with error %d\n", outlen,

               (uint64_t)width * lines, ret);

        av_free(buf);

        return AVERROR_UNKNOWN;

    }

    if (outlen < (uint64_t)width * rows) {

        av_log(s->avctx, AV_LOG_ERROR, "Uncompressed %"PRIu64" bytes, but %"PRIu64" are needed\n",

               outlen, (uint64_t)width * rows);

        av_free(buf);

        return AVERROR_INVALIDDATA;

    }

    src = buf;

    for (line = 0; line < lines; line++) {

        if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {

            horizontal_fill(s, s->bpp, dst, 1, src, 0, width, 0);

        } else {

            memcpy(dst, src, width);

        }

        if (is_yuv) {

            unpack_yuv(s, p, dst, strip_start + line);

            line += s->subsampling[1] - 1;

        }

        dst += stride;

        src += width;

    }

    av_free(buf);

    return 0;

}

#endif

static int tiff_unpack_fax(TiffContext *s, uint8_t *dst, int stride,

                           const uint8_t *src, int size, int width, int lines)

{

    int line;

    int ret;

    if (s->fill_order) {

        if ((ret = deinvert_buffer(s, src, size)) < 0)

            return ret;

        src = s->deinvert_buf;

    }

    ret = ff_ccitt_unpack(s->avctx, src, size, dst, lines, stride,

                          s->compr, s->fax_opts);

    if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8)

        for (line = 0; line < lines; line++) {

            horizontal_fill(s, s->bpp, dst, 1, dst, 0, width, 0);

            dst += stride;

        }

    return ret;

}

static int dng_decode_jpeg(AVCodecContext *avctx, AVFrame *frame,

                           int tile_byte_count, int dst_x, int dst_y, int w, int h)

{

    TiffContext *s = avctx->priv_data;

    uint8_t *dst_data, *src_data;

    uint32_t dst_offset; /* offset from dst buffer in pixels */

    int is_single_comp, is_u16, pixel_size;

    int ret;

    if (tile_byte_count < 0 || tile_byte_count > bytestream2_get_bytes_left(&s->gb))

        return AVERROR_INVALIDDATA;

    /* Prepare a packet and send to the MJPEG decoder */

    av_packet_unref(s->jpkt);

    s->jpkt->data = (uint8_t*)s->gb.buffer;

    s->jpkt->size = tile_byte_count;

    if (s->is_bayer) {

        MJpegDecodeContext *mjpegdecctx = s->avctx_mjpeg->priv_data;

        /* We have to set this information here, there is no way to know if a given JPEG is a DNG-embedded

           image or not from its own data (and we need that information when decoding it). */

        mjpegdecctx->bayer = 1;

    }

    ret = avcodec_send_packet(s->avctx_mjpeg, s->jpkt);

    if (ret < 0) {

        av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");

        return ret;

    }

    ret = avcodec_receive_frame(s->avctx_mjpeg, s->jpgframe);

    if (ret < 0) {

        av_log(avctx, AV_LOG_ERROR, "JPEG decoding error: %s.\n", av_err2str(ret));

        /* Normally skip, error if explode */

        if (avctx->err_recognition & AV_EF_EXPLODE)

            return AVERROR_INVALIDDATA;

        else

            return 0;

    }

    is_u16 = (s->bpp > 8);

    /* Copy the outputted tile's pixels from 'jpgframe' to 'frame' (final buffer) */

    if (s->jpgframe->width  != s->avctx_mjpeg->width  ||

        s->jpgframe->height != s->avctx_mjpeg->height ||

        s->jpgframe->format != s->avctx_mjpeg->pix_fmt)

        return AVERROR_INVALIDDATA;

    /* See dng_blit for explanation */

    if (s->avctx_mjpeg->width  == w * 2 &&

        s->avctx_mjpeg->height == h / 2 &&

        s->avctx_mjpeg->pix_fmt == AV_PIX_FMT_GRAY16LE) {

        is_single_comp = 1;

    } else if (s->avctx_mjpeg->width  >= w &&

               s->avctx_mjpeg->height >= h &&

               s->avctx_mjpeg->pix_fmt == (is_u16 ? AV_PIX_FMT_GRAY16 : AV_PIX_FMT_GRAY8)

              ) {

        is_single_comp = 0;

    } else

        return AVERROR_INVALIDDATA;

    pixel_size = (is_u16 ? sizeof(uint16_t) : sizeof(uint8_t));

    if (is_single_comp && !is_u16) {

        av_log(s->avctx, AV_LOG_ERROR, "DNGs with bpp <= 8 and 1 component are unsupported\n");

        av_frame_unref(s->jpgframe);

        return AVERROR_PATCHWELCOME;

    }

    dst_offset = dst_x + frame->linesize[0] * dst_y / pixel_size;

    dst_data = frame->data[0] + dst_offset * pixel_size;

    src_data = s->jpgframe->data[0];

    dng_blit(s,

             dst_data,

             frame->linesize[0] / pixel_size,

             src_data,

             s->jpgframe->linesize[0] / pixel_size,

             w,

             h,

             is_single_comp,

             is_u16, 0);

    av_frame_unref(s->jpgframe);

    return 0;

}

static int tiff_unpack_strip(TiffContext *s, AVFrame *p, uint8_t *dst, int stride,

                             const uint8_t *src, int size, int strip_start, int lines)

{

    PutByteContext pb;

    int c, line, pixels, code, ret;

    const uint8_t *ssrc = src;

    int width = ((s->width * s->bpp) + 7) >> 3;

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(p->format);

    int is_yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) &&

                 (desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&

                 desc->nb_components >= 3;

    int is_dng;

    if (s->planar)

        width /= s->bppcount;

    if (size <= 0)

        return AVERROR_INVALIDDATA;

    if (is_yuv) {

        int bytes_per_row = (((s->width - 1) / s->subsampling[0] + 1) * s->bpp *

                            s->subsampling[0] * s->subsampling[1] + 7) >> 3;

        av_fast_padded_malloc(&s->yuv_line, &s->yuv_line_size, bytes_per_row);

        if (s->yuv_line == NULL) {

            av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");

            return AVERROR(ENOMEM);

        }

        dst = s->yuv_line;

        stride = 0;

        width = (s->width - 1) / s->subsampling[0] + 1;

        width = width * s->subsampling[0] * s->subsampling[1] + 2*width;

        av_assert0(width <= bytes_per_row);

        av_assert0(s->bpp == 24);

    }

    if (s->is_bayer) {

        av_assert0(width == (s->bpp * s->width + 7) >> 3);

    }

    av_assert0(!(s->is_bayer && is_yuv));

    if (p->format == AV_PIX_FMT_GRAY12) {

        av_fast_padded_malloc(&s->yuv_line, &s->yuv_line_size, width);

        if (s->yuv_line == NULL) {

            av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");

            return AVERROR(ENOMEM);

        }

        dst = s->yuv_line;

        stride = 0;

    }

    if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {

#if CONFIG_ZLIB

        return tiff_unpack_zlib(s, p, dst, stride, src, size, width, lines,

                                strip_start, is_yuv);

#else

        av_log(s->avctx, AV_LOG_ERROR,

               "zlib support not enabled, "

               "deflate compression not supported\n");

        return AVERROR(ENOSYS);

#endif

    }

    if (s->compr == TIFF_LZMA) {

#if CONFIG_LZMA

        return tiff_unpack_lzma(s, p, dst, stride, src, size, width, lines,

                                strip_start, is_yuv);

#else

        av_log(s->avctx, AV_LOG_ERROR,

               "LZMA support not enabled\n");

        return AVERROR(ENOSYS);

#endif

    }

    if (s->compr == TIFF_LZW) {

        if (s->fill_order) {

            if ((ret = deinvert_buffer(s, src, size)) < 0)

                return ret;

            ssrc = src = s->deinvert_buf;

        }

        if (size > 1 && !src[0] && (src[1]&1)) {

            av_log(s->avctx, AV_LOG_ERROR, "Old style LZW is unsupported\n");

        }

        if ((ret = ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF)) < 0) {

            av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");

            return ret;

        }

        for (line = 0; line < lines; line++) {

            pixels = ff_lzw_decode(s->lzw, dst, width);

            if (pixels < width) {

                av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",

                       pixels, width);

                return AVERROR_INVALIDDATA;

            }

            if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8)

                horizontal_fill(s, s->bpp, dst, 1, dst, 0, width, 0);

            if (is_yuv) {

                unpack_yuv(s, p, dst, strip_start + line);

                line += s->subsampling[1] - 1;

            } else if (p->format == AV_PIX_FMT_GRAY12) {

                unpack_gray(s, p, dst, strip_start + line, width, s->bpp);

            }

            dst += stride;

        }

        return 0;

    }

    if (s->compr == TIFF_CCITT_RLE ||

        s->compr == TIFF_G3        ||

        s->compr == TIFF_G4) {

        if (is_yuv || p->format == AV_PIX_FMT_GRAY12)

            return AVERROR_INVALIDDATA;

        return tiff_unpack_fax(s, dst, stride, src, size, width, lines);

    }

    bytestream2_init(&s->gb, src, size);

    bytestream2_init_writer(&pb, dst, is_yuv ? s->yuv_line_size : (stride * lines));

    is_dng = (s->tiff_type == TIFF_TYPE_DNG || s->tiff_type == TIFF_TYPE_CINEMADNG);

    /* Decode JPEG-encoded DNGs with strips */

    if (s->compr == TIFF_NEWJPEG && is_dng) {

        if (s->strips > 1) {

            av_log(s->avctx, AV_LOG_ERROR, "More than one DNG JPEG strips unsupported\n");

            return AVERROR_PATCHWELCOME;

        }

        if (!s->is_bayer)

            return AVERROR_PATCHWELCOME;

        if ((ret = dng_decode_jpeg(s->avctx, p, s->stripsize, 0, 0, s->width, s->height)) < 0)

            return ret;

        return 0;

    }

    if (is_dng && stride == 0)

        return AVERROR_INVALIDDATA;

    for (line = 0; line < lines; line++) {

        if (src - ssrc > size) {

            av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");

            return AVERROR_INVALIDDATA;

        }

        if (bytestream2_get_bytes_left(&s->gb) == 0 || bytestream2_get_eof(&pb))

            break;

        bytestream2_seek_p(&pb, stride * line, SEEK_SET);

        switch (s->compr) {

        case TIFF_RAW:

            if (ssrc + size - src < width)

                return AVERROR_INVALIDDATA;

            if (!s->fill_order) {

                horizontal_fill(s, s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 || s->is_bayer),

                                dst, 1, src, 0, width, 0);

            } else {

                int i;

                for (i = 0; i < width; i++)

                    dst[i] = ff_reverse[src[i]];

            }

            /* Color processing for DNG images with uncompressed strips (non-tiled) */

            if (is_dng) {

                int is_u16, pixel_size_bytes, pixel_size_bits, elements;

                is_u16 = (s->bpp / s->bppcount > 8);

                pixel_size_bits = (is_u16 ? 16 : 8);

                pixel_size_bytes = (is_u16 ? sizeof(uint16_t) : sizeof(uint8_t));

                elements = width / pixel_size_bytes * pixel_size_bits / s->bpp * s->bppcount; // need to account for [1, 16] bpp

                av_assert0 (elements * pixel_size_bytes <= FFABS(stride));

                dng_blit(s,

                         dst,

                         0, // no stride, only 1 line

                         dst,

                         0, // no stride, only 1 line

                         elements,

                         1,

                         0, // single-component variation is only preset in JPEG-encoded DNGs

                         is_u16,

                         (line + strip_start)&1);

            }

            src += width;

            break;

        case TIFF_PACKBITS:

            for (pixels = 0; pixels < width;) {

                if (ssrc + size - src < 2) {

                    av_log(s->avctx, AV_LOG_ERROR, "Read went out of bounds\n");

                    return AVERROR_INVALIDDATA;

                }

                code = s->fill_order ? (int8_t) ff_reverse[*src++]: (int8_t) *src++;

                if (code >= 0) {

                    code++;

                    if (pixels + code > width ||

                        ssrc + size - src < code) {

                        av_log(s->avctx, AV_LOG_ERROR,

                               "Copy went out of bounds\n");

                        return AVERROR_INVALIDDATA;

                    }

                    horizontal_fill(s, s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),

                                    dst, 1, src, 0, code, pixels);

                    src    += code;

                    pixels += code;

                } else if (code != -128) { // -127..-1

                    code = (-code) + 1;

                    if (pixels + code > width) {

                        av_log(s->avctx, AV_LOG_ERROR,

                               "Run went out of bounds\n");

                        return AVERROR_INVALIDDATA;

                    }

                    c = *src++;

                    horizontal_fill(s, s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),

                                    dst, 0, NULL, c, code, pixels);

                    pixels += code;

                }

            }

            if (s->fill_order) {

                int i;

                for (i = 0; i < width; i++)

                    dst[i] = ff_reverse[dst[i]];

            }

            break;

        }

        if (is_yuv) {

            unpack_yuv(s, p, dst, strip_start + line);

            line += s->subsampling[1] - 1;

        } else if (p->format == AV_PIX_FMT_GRAY12) {

            unpack_gray(s, p, dst, strip_start + line, width, s->bpp);

        }

        dst += stride;

    }

    return 0;

}

static int dng_decode_tiles(AVCodecContext *avctx, AVFrame *frame,

                            const AVPacket *avpkt)

{

    TiffContext *s = avctx->priv_data;

    int tile_idx;

    int tile_offset_offset, tile_offset;

    int tile_byte_count_offset, tile_byte_count;

    int tile_count_x, tile_count_y;

    int tile_width, tile_length;

    int has_width_leftover, has_height_leftover;

    int tile_x = 0, tile_y = 0;

    int pos_x = 0, pos_y = 0;

    int ret;

    if (s->tile_width <= 0 || s->tile_length <= 0)

        return AVERROR_INVALIDDATA;

    has_width_leftover = (s->width % s->tile_width != 0);

    has_height_leftover = (s->height % s->tile_length != 0);

    /* Calculate tile counts (round up) */

    tile_count_x = (s->width - 1) / s->tile_width + 1;

    tile_count_y = (s->height - 1) / s->tile_length + 1;

    /* Iterate over the number of tiles */

    for (tile_idx = 0; tile_idx < tile_count_x * tile_count_y; tile_idx++) {

        tile_x = tile_idx % tile_count_x;

        tile_y = tile_idx / tile_count_x;

        if (has_width_leftover && tile_x == tile_count_x - 1) // If on the right-most tile

            tile_width = s->width % s->tile_width;

        else

            tile_width = s->tile_width;

        if (has_height_leftover && tile_y == tile_count_y - 1) // If on the bottom-most tile

            tile_length = s->height % s->tile_length;

        else

            tile_length = s->tile_length;

        /* Read tile offset */

        tile_offset_offset = s->tile_offsets_offset + tile_idx * sizeof(int);

        bytestream2_seek(&s->gb, tile_offset_offset, SEEK_SET);

        tile_offset = ff_tget_long(&s->gb, s->le);

        /* Read tile byte size */

        tile_byte_count_offset = s->tile_byte_counts_offset + tile_idx * sizeof(int);

        bytestream2_seek(&s->gb, tile_byte_count_offset, SEEK_SET);