tiffenc.c 16.6 KB
Newer Older
1 2 3 4
/*
 * TIFF image encoder
 * Copyright (c) 2007 Bartlomiej Wolowiec
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9 10 11
 * 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.
 *
12
 * Libav is distributed in the hope that it will be useful,
13 14 15 16 17
 * 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
18
 * License along with Libav; if not, write to the Free Software
19 20 21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22
/**
23
 * @file
24
 * TIFF image encoder
25 26
 * @author Bartlomiej Wolowiec
 */
27

28 29
#include "libavutil/log.h"
#include "libavutil/opt.h"
30
#include "libavutil/pixdesc.h"
31

32
#include "avcodec.h"
33
#include "config.h"
34
#if CONFIG_ZLIB
35 36 37 38 39
#include <zlib.h>
#endif
#include "bytestream.h"
#include "tiff.h"
#include "rle.h"
40
#include "lzw.h"
41
#include "put_bits.h"
42 43 44 45 46 47 48 49 50

#define TIFF_MAX_ENTRY 32

/** sizes of various TIFF field types (string size = 1)*/
static const uint8_t type_sizes2[6] = {
    0, 1, 1, 2, 4, 8
};

typedef struct TiffEncoderContext {
51
    AVClass *class;                     ///< for private options
52 53 54 55 56 57 58 59
    AVCodecContext *avctx;
    AVFrame picture;

    int width;                          ///< picture width
    int height;                         ///< picture height
    unsigned int bpp;                   ///< bits per pixel
    int compr;                          ///< compression level
    int bpp_tab_size;                   ///< bpp_tab size
60
    int photometric_interpretation;     ///< photometric interpretation
61 62 63 64 65 66 67
    int strips;                         ///< number of strips
    int rps;                            ///< row per strip
    uint8_t entries[TIFF_MAX_ENTRY*12]; ///< entires in header
    int num_entries;                    ///< number of entires
    uint8_t **buf;                      ///< actual position in buffer
    uint8_t *buf_start;                 ///< pointer to first byte in buffer
    int buf_size;                       ///< buffer size
68
    uint16_t subsampling[2];            ///< YUV subsampling factors
69
    struct LZWEncodeState *lzws;        ///< LZW Encode state
70 71 72 73 74 75 76 77 78
} TiffEncoderContext;


/**
 * Check free space in buffer
 * @param s Tiff context
 * @param need Needed bytes
 * @return 0 - ok, 1 - no free space
 */
79
static inline int check_size(TiffEncoderContext * s, uint64_t need)
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
{
    if (s->buf_size < *s->buf - s->buf_start + need) {
        *s->buf = s->buf_start + s->buf_size + 1;
        av_log(s->avctx, AV_LOG_ERROR, "Buffer is too small\n");
        return 1;
    }
    return 0;
}

/**
 * Put n values to buffer
 *
 * @param p Pointer to pointer to output buffer
 * @param n Number of values
 * @param val Pointer to values
 * @param type Type of values
 * @param flip =0 - normal copy, >0 - flip
 */
static void tnput(uint8_t ** p, int n, const uint8_t * val, enum TiffTypes type,
                  int flip)
{
    int i;
102
#if HAVE_BIGENDIAN
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
    flip ^= ((int[]) {0, 0, 0, 1, 3, 3})[type];
#endif
    for (i = 0; i < n * type_sizes2[type]; i++)
        *(*p)++ = val[i ^ flip];
}

/**
 * Add entry to directory in tiff header.
 * @param s Tiff context
 * @param tag Tag that identifies the entry
 * @param type Entry type
 * @param count The number of values
 * @param ptr_val Pointer to values
 */
static void add_entry(TiffEncoderContext * s,
                      enum TiffTags tag, enum TiffTypes type, int count,
                      const void *ptr_val)
{
    uint8_t *entries_ptr = s->entries + 12 * s->num_entries;

    assert(s->num_entries < TIFF_MAX_ENTRY);

    bytestream_put_le16(&entries_ptr, tag);
    bytestream_put_le16(&entries_ptr, type);
    bytestream_put_le32(&entries_ptr, count);

    if (type_sizes[type] * count <= 4) {
        tnput(&entries_ptr, count, ptr_val, type, 0);
    } else {
        bytestream_put_le32(&entries_ptr, *s->buf - s->buf_start);
        check_size(s, count * type_sizes2[type]);
        tnput(s->buf, count, ptr_val, type, 0);
    }

    s->num_entries++;
}

140 141 142 143
static void add_entry1(TiffEncoderContext * s,
                       enum TiffTags tag, enum TiffTypes type, int val){
    uint16_t w = val;
    uint32_t dw= val;
Reimar Döffinger's avatar
Reimar Döffinger committed
144
    add_entry(s, tag, type, 1, type == TIFF_SHORT ? (void *)&w : (void *)&dw);
145 146
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
/**
 * Encode one strip in tiff file
 *
 * @param s Tiff context
 * @param src Input buffer
 * @param dst Output buffer
 * @param n Size of input buffer
 * @param compr Compression method
 * @return Number of output bytes. If an output error is encountered, -1 returned
 */
static int encode_strip(TiffEncoderContext * s, const int8_t * src,
                        uint8_t * dst, int n, int compr)
{

    switch (compr) {
162
#if CONFIG_ZLIB
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
    case TIFF_DEFLATE:
    case TIFF_ADOBE_DEFLATE:
        {
            unsigned long zlen = s->buf_size - (*s->buf - s->buf_start);
            if (compress(dst, &zlen, src, n) != Z_OK) {
                av_log(s->avctx, AV_LOG_ERROR, "Compressing failed\n");
                return -1;
            }
            return zlen;
        }
#endif
    case TIFF_RAW:
        if (check_size(s, n))
            return -1;
        memcpy(dst, src, n);
        return n;
    case TIFF_PACKBITS:
        return ff_rle_encode(dst, s->buf_size - (*s->buf - s->buf_start), src, 1, n, 2, 0xff, -1, 0);
181 182
    case TIFF_LZW:
        return ff_lzw_encode(s->lzws, src, n);
183 184 185 186 187
    default:
        return -1;
    }
}

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
static void pack_yuv(TiffEncoderContext * s, uint8_t * dst, int lnum)
{
    AVFrame *p = &s->picture;
    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]];
    for (i = 0; i < w; i++){
        for (j = 0; j < s->subsampling[1]; j++)
            for (k = 0; k < s->subsampling[0]; k++)
                *dst++ = p->data[0][(lnum + j) * p->linesize[0] +
                                    i * s->subsampling[0] + k];
        *dst++ = *pu++;
        *dst++ = *pv++;
    }
}

Anton Khirnov's avatar
Anton Khirnov committed
205 206
static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
                        const AVFrame *pict, int *got_packet)
207 208
{
    TiffEncoderContext *s = avctx->priv_data;
209
    AVFrame *const p = &s->picture;
210
    int i;
Anton Khirnov's avatar
Anton Khirnov committed
211
    uint8_t *ptr;
212 213 214 215 216 217
    uint8_t *offset;
    uint32_t strips;
    uint32_t *strip_sizes = NULL;
    uint32_t *strip_offsets = NULL;
    int bytes_per_row;
    uint32_t res[2] = { 72, 1 };        // image resolution (72/1)
218
    uint16_t bpp_tab[] = { 8, 8, 8, 8 };
219
    int ret;
220 221 222
    int is_yuv = 0;
    uint8_t *yuv_line = NULL;
    int shift_h, shift_v;
223
    const AVPixFmtDescriptor* pfd;
224

225
    s->avctx = avctx;
226 227

    *p = *pict;
228
    p->pict_type = AV_PICTURE_TYPE_I;
229
    p->key_frame = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
230
    avctx->coded_frame= &s->picture;
231 232 233

    s->width = avctx->width;
    s->height = avctx->height;
234 235
    s->subsampling[0] = 1;
    s->subsampling[1] = 1;
236 237

    switch (avctx->pix_fmt) {
238 239 240 241 242
    case AV_PIX_FMT_RGB48LE:
    case AV_PIX_FMT_GRAY16LE:
    case AV_PIX_FMT_RGB24:
    case AV_PIX_FMT_GRAY8:
    case AV_PIX_FMT_PAL8:
243
        pfd = av_pix_fmt_desc_get(avctx->pix_fmt);
244 245 246 247 248 249 250 251 252 253 254 255
        s->bpp = av_get_bits_per_pixel(pfd);
        if (pfd->flags & PIX_FMT_PAL) {
            s->photometric_interpretation = 3;
        } else if (pfd->flags & PIX_FMT_RGB) {
            s->photometric_interpretation = 2;
        } else {
            s->photometric_interpretation = 1;
        }
        s->bpp_tab_size = pfd->nb_components;
        for (i = 0; i < s->bpp_tab_size; i++) {
            bpp_tab[i] = s->bpp / s->bpp_tab_size;
        }
256
        break;
257
    case AV_PIX_FMT_MONOBLACK:
258
        s->bpp = 1;
259
        s->photometric_interpretation = 1;
260
        s->bpp_tab_size = 0;
261
        break;
262
    case AV_PIX_FMT_MONOWHITE:
263
        s->bpp = 1;
264
        s->photometric_interpretation = 0;
265
        s->bpp_tab_size = 0;
266
        break;
267 268 269 270 271
    case AV_PIX_FMT_YUV420P:
    case AV_PIX_FMT_YUV422P:
    case AV_PIX_FMT_YUV444P:
    case AV_PIX_FMT_YUV410P:
    case AV_PIX_FMT_YUV411P:
272 273 274 275 276 277 278 279 280
        s->photometric_interpretation = 6;
        avcodec_get_chroma_sub_sample(avctx->pix_fmt,
                &shift_h, &shift_v);
        s->bpp = 8 + (16 >> (shift_h + shift_v));
        s->subsampling[0] = 1 << shift_h;
        s->subsampling[1] = 1 << shift_v;
        s->bpp_tab_size = 3;
        is_yuv = 1;
        break;
281 282 283 284 285 286
    default:
        av_log(s->avctx, AV_LOG_ERROR,
               "This colors format is not supported\n");
        return -1;
    }

287
    if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE || s->compr == TIFF_LZW)
288 289 290 291
        //best choose for DEFLATE
        s->rps = s->height;
    else
        s->rps = FFMAX(8192 / (((s->width * s->bpp) >> 3) + 1), 1);     // suggest size of strip
292
    s->rps = ((s->rps - 1) / s->subsampling[1] + 1) * s->subsampling[1]; // round rps up
293 294 295

    strips = (s->height - 1) / s->rps + 1;

Anton Khirnov's avatar
Anton Khirnov committed
296 297 298 299 300 301 302 303 304 305 306
    if (!pkt->data &&
        (ret = av_new_packet(pkt, avctx->width * avctx->height * s->bpp * 2 +
                                  avctx->height * 4 + FF_MIN_BUFFER_SIZE)) < 0) {
        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
        return ret;
    }
    ptr          = pkt->data;
    s->buf_start = pkt->data;
    s->buf       = &ptr;
    s->buf_size  = pkt->size;

307 308 309 310 311 312 313 314 315 316 317 318
    if (check_size(s, 8))
        goto fail;

    // write header
    bytestream_put_le16(&ptr, 0x4949);
    bytestream_put_le16(&ptr, 42);

    offset = ptr;
    bytestream_put_le32(&ptr, 0);

    strip_sizes = av_mallocz(sizeof(*strip_sizes) * strips);
    strip_offsets = av_mallocz(sizeof(*strip_offsets) * strips);
319 320 321 322
    if (!strip_sizes || !strip_offsets) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }
323

324 325 326 327 328 329
    bytes_per_row = (((s->width - 1)/s->subsampling[0] + 1) * s->bpp
                    * s->subsampling[0] * s->subsampling[1] + 7) >> 3;
    if (is_yuv){
        yuv_line = av_malloc(bytes_per_row);
        if (yuv_line == NULL){
            av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");
330
            ret = AVERROR(ENOMEM);
331 332 333
            goto fail;
        }
    }
334

335
#if CONFIG_ZLIB
336 337 338 339 340 341 342
    if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
        uint8_t *zbuf;
        int zlen, zn;
        int j;

        zlen = bytes_per_row * s->rps;
        zbuf = av_malloc(zlen);
343 344 345 346
        if (!zbuf) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
Anton Khirnov's avatar
Anton Khirnov committed
347
        strip_offsets[0] = ptr - pkt->data;
348 349
        zn = 0;
        for (j = 0; j < s->rps; j++) {
350 351 352 353 354 355
            if (is_yuv){
                pack_yuv(s, yuv_line, j);
                memcpy(zbuf + zn, yuv_line, bytes_per_row);
                j += s->subsampling[1] - 1;
            }
            else
Diego Biurrun's avatar
Diego Biurrun committed
356 357
                memcpy(zbuf + j * bytes_per_row,
                       p->data[0] + j * p->linesize[0], bytes_per_row);
358 359
            zn += bytes_per_row;
        }
360
        ret = encode_strip(s, zbuf, ptr, zn, s->compr);
361
        av_free(zbuf);
362
        if (ret < 0) {
363 364 365
            av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
            goto fail;
        }
366
        ptr += ret;
Anton Khirnov's avatar
Anton Khirnov committed
367
        strip_sizes[0] = ptr - pkt->data - strip_offsets[0];
368 369 370
    } else
#endif
    {
371
        if (s->compr == TIFF_LZW) {
372
            s->lzws = av_malloc(ff_lzw_encode_state_size);
373 374 375 376 377
            if (!s->lzws) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
        }
378 379
        for (i = 0; i < s->height; i++) {
            if (strip_sizes[i / s->rps] == 0) {
380
                if(s->compr == TIFF_LZW){
381 382
                    ff_lzw_encode_init(s->lzws, ptr, s->buf_size - (*s->buf - s->buf_start),
                                       12, FF_LZW_TIFF, put_bits);
383
                }
Anton Khirnov's avatar
Anton Khirnov committed
384
                strip_offsets[i / s->rps] = ptr - pkt->data;
385
            }
386 387
            if (is_yuv){
                 pack_yuv(s, yuv_line, i);
388
                 ret = encode_strip(s, yuv_line, ptr, bytes_per_row, s->compr);
389 390 391
                 i += s->subsampling[1] - 1;
            }
            else
392
                ret = encode_strip(s, p->data[0] + i * p->linesize[0],
393
                        ptr, bytes_per_row, s->compr);
394
            if (ret < 0) {
395 396 397
                av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
                goto fail;
            }
398 399
            strip_sizes[i / s->rps] += ret;
            ptr += ret;
400
            if(s->compr == TIFF_LZW && (i==s->height-1 || i%s->rps == s->rps-1)){
401
                ret = ff_lzw_encode_flush(s->lzws, flush_put_bits);
402 403 404
                strip_sizes[(i / s->rps )] += ret ;
                ptr += ret;
            }
405
        }
406 407
        if(s->compr == TIFF_LZW)
            av_free(s->lzws);
408 409 410 411
    }

    s->num_entries = 0;

412 413 414
    add_entry1(s,TIFF_SUBFILE,           TIFF_LONG,             0);
    add_entry1(s,TIFF_WIDTH,             TIFF_LONG,             s->width);
    add_entry1(s,TIFF_HEIGHT,            TIFF_LONG,             s->height);
415 416 417 418

    if (s->bpp_tab_size)
    add_entry(s, TIFF_BPP,               TIFF_SHORT,    s->bpp_tab_size, bpp_tab);

419
    add_entry1(s,TIFF_COMPR,             TIFF_SHORT,            s->compr);
420
    add_entry1(s,TIFF_INVERT,            TIFF_SHORT,            s->photometric_interpretation);
421 422 423
    add_entry(s, TIFF_STRIP_OFFS,        TIFF_LONG,     strips, strip_offsets);

    if (s->bpp_tab_size)
424
    add_entry1(s,TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT,            s->bpp_tab_size);
425

426
    add_entry1(s,TIFF_ROWSPERSTRIP,      TIFF_LONG,             s->rps);
427 428 429
    add_entry(s, TIFF_STRIP_SIZE,        TIFF_LONG,     strips, strip_sizes);
    add_entry(s, TIFF_XRES,              TIFF_RATIONAL, 1,      res);
    add_entry(s, TIFF_YRES,              TIFF_RATIONAL, 1,      res);
430
    add_entry1(s,TIFF_RES_UNIT,          TIFF_SHORT,            2);
431 432

    if(!(avctx->flags & CODEC_FLAG_BITEXACT))
433 434 435
    add_entry(s, TIFF_SOFTWARE_NAME,     TIFF_STRING,
              strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT);

436
    if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
437 438 439 440 441 442 443 444 445
        uint16_t pal[256 * 3];
        for (i = 0; i < 256; i++) {
            uint32_t rgb = *(uint32_t *) (p->data[1] + i * 4);
            pal[i]       = ((rgb >> 16) & 0xff) * 257;
            pal[i + 256] = ((rgb >> 8 ) & 0xff) * 257;
            pal[i + 512] = ( rgb        & 0xff) * 257;
        }
        add_entry(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);
    }
446 447 448 449 450 451
    if (is_yuv){
        /** according to CCIR Recommendation 601.1 */
        uint32_t refbw[12] = {15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 1};
        add_entry(s, TIFF_YCBCR_SUBSAMPLING, TIFF_SHORT,    2, s->subsampling);
        add_entry(s, TIFF_REFERENCE_BW,      TIFF_RATIONAL, 6, refbw);
    }
Anton Khirnov's avatar
Anton Khirnov committed
452
    bytestream_put_le32(&offset, ptr - pkt->data);    // write offset to dir
453

454 455
    if (check_size(s, 6 + s->num_entries * 12)) {
        ret = AVERROR(EINVAL);
456
        goto fail;
457
    }
458 459 460 461
    bytestream_put_le16(&ptr, s->num_entries);  // write tag count
    bytestream_put_buffer(&ptr, s->entries, s->num_entries * 12);
    bytestream_put_le32(&ptr, 0);

Anton Khirnov's avatar
Anton Khirnov committed
462 463 464
    pkt->size   = ptr - pkt->data;
    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;
465 466 467 468

fail:
    av_free(strip_sizes);
    av_free(strip_offsets);
469
    av_free(yuv_line);
470 471 472
    return ret;
}

473 474 475
#define OFFSET(x) offsetof(TiffEncoderContext, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
476
    { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, {.i64 = TIFF_PACKBITS}, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },
477 478 479
    { "packbits", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_PACKBITS}, 0, 0, VE, "compression_algo" },
    { "raw",      NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_RAW},      0, 0, VE, "compression_algo" },
    { "lzw",      NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_LZW},      0, 0, VE, "compression_algo" },
480
#if CONFIG_ZLIB
481
    { "deflate",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_DEFLATE},  0, 0, VE, "compression_algo" },
482 483 484 485 486 487 488 489 490 491 492
#endif
    { NULL },
};

static const AVClass tiffenc_class = {
    .class_name = "TIFF encoder",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

493
AVCodec ff_tiff_encoder = {
494 495
    .name           = "tiff",
    .type           = AVMEDIA_TYPE_VIDEO,
496
    .id             = AV_CODEC_ID_TIFF,
497
    .priv_data_size = sizeof(TiffEncoderContext),
Anton Khirnov's avatar
Anton Khirnov committed
498
    .encode2        = encode_frame,
499 500 501 502 503 504 505
    .pix_fmts       = (const enum AVPixelFormat[]) {
        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48LE, AV_PIX_FMT_PAL8,
        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16LE,
        AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_MONOWHITE,
        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
        AV_PIX_FMT_NONE
506
    },
507
    .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
508
    .priv_class     = &tiffenc_class,
509
};