tiffenc.c
Go to the documentation of this file.
1 /*
2  * TIFF image encoder
3  * Copyright (c) 2007 Bartlomiej Wolowiec
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * 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  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "libavutil/log.h"
29 #include "libavutil/opt.h"
30 
31 #include "avcodec.h"
32 #if CONFIG_ZLIB
33 #include <zlib.h>
34 #endif
35 #include "bytestream.h"
36 #include "tiff.h"
37 #include "rle.h"
38 #include "lzw.h"
39 #include "put_bits.h"
40 
41 #define TIFF_MAX_ENTRY 32
42 
44 static const uint8_t type_sizes2[6] = {
45  0, 1, 1, 2, 4, 8
46 };
47 
48 typedef struct TiffEncoderContext {
49  AVClass *class;
52 
53  int width;
54  int height;
55  unsigned int bpp;
56  int compr;
59  int strips;
60  int rps;
61  uint8_t entries[TIFF_MAX_ENTRY*12];
63  uint8_t **buf;
64  uint8_t *buf_start;
65  int buf_size;
66  uint16_t subsampling[2];
67  struct LZWEncodeState *lzws;
69 
70 
77 inline static int check_size(TiffEncoderContext * s, uint64_t need)
78 {
79  if (s->buf_size < *s->buf - s->buf_start + need) {
80  *s->buf = s->buf_start + s->buf_size + 1;
81  av_log(s->avctx, AV_LOG_ERROR, "Buffer is too small\n");
82  return 1;
83  }
84  return 0;
85 }
86 
96 static void tnput(uint8_t ** p, int n, const uint8_t * val, enum TiffTypes type,
97  int flip)
98 {
99  int i;
100 #if HAVE_BIGENDIAN
101  flip ^= ((int[]) {0, 0, 0, 1, 3, 3})[type];
102 #endif
103  for (i = 0; i < n * type_sizes2[type]; i++)
104  *(*p)++ = val[i ^ flip];
105 }
106 
116  enum TiffTags tag, enum TiffTypes type, int count,
117  const void *ptr_val)
118 {
119  uint8_t *entries_ptr = s->entries + 12 * s->num_entries;
120 
121  assert(s->num_entries < TIFF_MAX_ENTRY);
122 
123  bytestream_put_le16(&entries_ptr, tag);
124  bytestream_put_le16(&entries_ptr, type);
125  bytestream_put_le32(&entries_ptr, count);
126 
127  if (type_sizes[type] * count <= 4) {
128  tnput(&entries_ptr, count, ptr_val, type, 0);
129  } else {
130  bytestream_put_le32(&entries_ptr, *s->buf - s->buf_start);
131  check_size(s, count * type_sizes2[type]);
132  tnput(s->buf, count, ptr_val, type, 0);
133  }
134 
135  s->num_entries++;
136 }
137 
139  enum TiffTags tag, enum TiffTypes type, int val){
140  uint16_t w = val;
141  uint32_t dw= val;
142  add_entry(s, tag, type, 1, type == TIFF_SHORT ? (void *)&w : (void *)&dw);
143 }
144 
155 static int encode_strip(TiffEncoderContext * s, const int8_t * src,
156  uint8_t * dst, int n, int compr)
157 {
158 
159  switch (compr) {
160 #if CONFIG_ZLIB
161  case TIFF_DEFLATE:
162  case TIFF_ADOBE_DEFLATE:
163  {
164  unsigned long zlen = s->buf_size - (*s->buf - s->buf_start);
165  if (compress(dst, &zlen, src, n) != Z_OK) {
166  av_log(s->avctx, AV_LOG_ERROR, "Compressing failed\n");
167  return -1;
168  }
169  return zlen;
170  }
171 #endif
172  case TIFF_RAW:
173  if (check_size(s, n))
174  return -1;
175  memcpy(dst, src, n);
176  return n;
177  case TIFF_PACKBITS:
178  return ff_rle_encode(dst, s->buf_size - (*s->buf - s->buf_start), src, 1, n, 2, 0xff, -1, 0);
179  case TIFF_LZW:
180  return ff_lzw_encode(s->lzws, src, n);
181  default:
182  return -1;
183  }
184 }
185 
186 static void pack_yuv(TiffEncoderContext * s, uint8_t * dst, int lnum)
187 {
188  AVFrame *p = &s->picture;
189  int i, j, k;
190  int w = (s->width - 1) / s->subsampling[0] + 1;
191  uint8_t *pu = &p->data[1][lnum / s->subsampling[1] * p->linesize[1]];
192  uint8_t *pv = &p->data[2][lnum / s->subsampling[1] * p->linesize[2]];
193  for (i = 0; i < w; i++){
194  for (j = 0; j < s->subsampling[1]; j++)
195  for (k = 0; k < s->subsampling[0]; k++)
196  *dst++ = p->data[0][(lnum + j) * p->linesize[0] +
197  i * s->subsampling[0] + k];
198  *dst++ = *pu++;
199  *dst++ = *pv++;
200  }
201 }
202 
203 static int encode_frame(AVCodecContext * avctx, unsigned char *buf,
204  int buf_size, void *data)
205 {
206  TiffEncoderContext *s = avctx->priv_data;
207  AVFrame *pict = data;
208  AVFrame *const p = (AVFrame *) & s->picture;
209  int i;
210  int n;
211  uint8_t *ptr = buf;
212  uint8_t *offset;
213  uint32_t strips;
214  uint32_t *strip_sizes = NULL;
215  uint32_t *strip_offsets = NULL;
216  int bytes_per_row;
217  uint32_t res[2] = { 72, 1 }; // image resolution (72/1)
218  static const uint16_t bpp_tab[] = { 8, 8, 8, 8 };
219  int ret = -1;
220  int is_yuv = 0;
221  uint8_t *yuv_line = NULL;
222  int shift_h, shift_v;
223 
224  s->avctx = avctx;
225  s->buf_start = buf;
226  s->buf = &ptr;
227  s->buf_size = buf_size;
228 
229  *p = *pict;
230  p->pict_type = AV_PICTURE_TYPE_I;
231  p->key_frame = 1;
232  avctx->coded_frame= &s->picture;
233 
234 #if FF_API_TIFFENC_COMPLEVEL
235  if (avctx->compression_level != FF_COMPRESSION_DEFAULT)
236  av_log(avctx, AV_LOG_WARNING, "Using compression_level to set compression "
237  "algorithm is deprecated. Please use the compression_algo private "
238  "option instead.\n");
239  if (avctx->compression_level == 0) {
240  s->compr = TIFF_RAW;
241  } else if(avctx->compression_level == 2) {
242  s->compr = TIFF_LZW;
243 #if CONFIG_ZLIB
244  } else if ((avctx->compression_level >= 3)) {
245  s->compr = TIFF_DEFLATE;
246 #endif
247  }
248 #endif
249 
250  s->width = avctx->width;
251  s->height = avctx->height;
252  s->subsampling[0] = 1;
253  s->subsampling[1] = 1;
254 
255  switch (avctx->pix_fmt) {
256  case PIX_FMT_RGB24:
257  s->bpp = 24;
258  s->photometric_interpretation = 2;
259  break;
260  case PIX_FMT_GRAY8:
261  s->bpp = 8;
262  s->photometric_interpretation = 1;
263  break;
264  case PIX_FMT_PAL8:
265  s->bpp = 8;
266  s->photometric_interpretation = 3;
267  break;
268  case PIX_FMT_MONOBLACK:
269  s->bpp = 1;
270  s->photometric_interpretation = 1;
271  break;
272  case PIX_FMT_MONOWHITE:
273  s->bpp = 1;
274  s->photometric_interpretation = 0;
275  break;
276  case PIX_FMT_YUV420P:
277  case PIX_FMT_YUV422P:
278  case PIX_FMT_YUV444P:
279  case PIX_FMT_YUV410P:
280  case PIX_FMT_YUV411P:
281  s->photometric_interpretation = 6;
282  avcodec_get_chroma_sub_sample(avctx->pix_fmt,
283  &shift_h, &shift_v);
284  s->bpp = 8 + (16 >> (shift_h + shift_v));
285  s->subsampling[0] = 1 << shift_h;
286  s->subsampling[1] = 1 << shift_v;
287  s->bpp_tab_size = 3;
288  is_yuv = 1;
289  break;
290  default:
291  av_log(s->avctx, AV_LOG_ERROR,
292  "This colors format is not supported\n");
293  return -1;
294  }
295  if (!is_yuv)
296  s->bpp_tab_size = (s->bpp >> 3);
297 
298  if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE || s->compr == TIFF_LZW)
299  //best choose for DEFLATE
300  s->rps = s->height;
301  else
302  s->rps = FFMAX(8192 / (((s->width * s->bpp) >> 3) + 1), 1); // suggest size of strip
303  s->rps = ((s->rps - 1) / s->subsampling[1] + 1) * s->subsampling[1]; // round rps up
304 
305  strips = (s->height - 1) / s->rps + 1;
306 
307  if (check_size(s, 8))
308  goto fail;
309 
310  // write header
311  bytestream_put_le16(&ptr, 0x4949);
312  bytestream_put_le16(&ptr, 42);
313 
314  offset = ptr;
315  bytestream_put_le32(&ptr, 0);
316 
317  strip_sizes = av_mallocz(sizeof(*strip_sizes) * strips);
318  strip_offsets = av_mallocz(sizeof(*strip_offsets) * strips);
319  if (!strip_sizes || !strip_offsets) {
320  ret = AVERROR(ENOMEM);
321  goto fail;
322  }
323 
324  bytes_per_row = (((s->width - 1)/s->subsampling[0] + 1) * s->bpp
325  * s->subsampling[0] * s->subsampling[1] + 7) >> 3;
326  if (is_yuv){
327  yuv_line = av_malloc(bytes_per_row);
328  if (yuv_line == NULL){
329  av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");
330  ret = AVERROR(ENOMEM);
331  goto fail;
332  }
333  }
334 
335 #if CONFIG_ZLIB
336  if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
337  uint8_t *zbuf;
338  int zlen, zn;
339  int j;
340 
341  zlen = bytes_per_row * s->rps;
342  zbuf = av_malloc(zlen);
343  if (!zbuf) {
344  ret = AVERROR(ENOMEM);
345  goto fail;
346  }
347  strip_offsets[0] = ptr - buf;
348  zn = 0;
349  for (j = 0; j < s->rps; j++) {
350  if (is_yuv){
351  pack_yuv(s, yuv_line, j);
352  memcpy(zbuf + zn, yuv_line, bytes_per_row);
353  j += s->subsampling[1] - 1;
354  }
355  else
356  memcpy(zbuf + j * bytes_per_row,
357  p->data[0] + j * p->linesize[0], bytes_per_row);
358  zn += bytes_per_row;
359  }
360  n = encode_strip(s, zbuf, ptr, zn, s->compr);
361  av_free(zbuf);
362  if (n<0) {
363  av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
364  goto fail;
365  }
366  ptr += n;
367  strip_sizes[0] = ptr - buf - strip_offsets[0];
368  } else
369 #endif
370  {
371  if (s->compr == TIFF_LZW) {
373  if (!s->lzws) {
374  ret = AVERROR(ENOMEM);
375  goto fail;
376  }
377  }
378  for (i = 0; i < s->height; i++) {
379  if (strip_sizes[i / s->rps] == 0) {
380  if(s->compr == TIFF_LZW){
381  ff_lzw_encode_init(s->lzws, ptr, s->buf_size - (*s->buf - s->buf_start),
382  12, FF_LZW_TIFF, put_bits);
383  }
384  strip_offsets[i / s->rps] = ptr - buf;
385  }
386  if (is_yuv){
387  pack_yuv(s, yuv_line, i);
388  n = encode_strip(s, yuv_line, ptr, bytes_per_row, s->compr);
389  i += s->subsampling[1] - 1;
390  }
391  else
392  n = encode_strip(s, p->data[0] + i * p->linesize[0],
393  ptr, bytes_per_row, s->compr);
394  if (n < 0) {
395  av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
396  goto fail;
397  }
398  strip_sizes[i / s->rps] += n;
399  ptr += n;
400  if(s->compr == TIFF_LZW && (i==s->height-1 || i%s->rps == s->rps-1)){
401  int ret;
402  ret = ff_lzw_encode_flush(s->lzws, flush_put_bits);
403  strip_sizes[(i / s->rps )] += ret ;
404  ptr += ret;
405  }
406  }
407  if(s->compr == TIFF_LZW)
408  av_free(s->lzws);
409  }
410 
411  s->num_entries = 0;
412 
414  add_entry1(s,TIFF_WIDTH, TIFF_LONG, s->width);
415  add_entry1(s,TIFF_HEIGHT, TIFF_LONG, s->height);
416 
417  if (s->bpp_tab_size)
418  add_entry(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab);
419 
420  add_entry1(s,TIFF_COMPR, TIFF_SHORT, s->compr);
421  add_entry1(s,TIFF_INVERT, TIFF_SHORT, s->photometric_interpretation);
422  add_entry(s, TIFF_STRIP_OFFS, TIFF_LONG, strips, strip_offsets);
423 
424  if (s->bpp_tab_size)
425  add_entry1(s,TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size);
426 
428  add_entry(s, TIFF_STRIP_SIZE, TIFF_LONG, strips, strip_sizes);
429  add_entry(s, TIFF_XRES, TIFF_RATIONAL, 1, res);
430  add_entry(s, TIFF_YRES, TIFF_RATIONAL, 1, res);
432 
433  if(!(avctx->flags & CODEC_FLAG_BITEXACT))
435  strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT);
436 
437  if (avctx->pix_fmt == PIX_FMT_PAL8) {
438  uint16_t pal[256 * 3];
439  for (i = 0; i < 256; i++) {
440  uint32_t rgb = *(uint32_t *) (p->data[1] + i * 4);
441  pal[i] = ((rgb >> 16) & 0xff) * 257;
442  pal[i + 256] = ((rgb >> 8 ) & 0xff) * 257;
443  pal[i + 512] = ( rgb & 0xff) * 257;
444  }
445  add_entry(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);
446  }
447  if (is_yuv){
449  uint32_t refbw[12] = {15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 1};
450  add_entry(s, TIFF_YCBCR_SUBSAMPLING, TIFF_SHORT, 2, s->subsampling);
452  }
453  bytestream_put_le32(&offset, ptr - buf); // write offset to dir
454 
455  if (check_size(s, 6 + s->num_entries * 12))
456  goto fail;
457  bytestream_put_le16(&ptr, s->num_entries); // write tag count
458  bytestream_put_buffer(&ptr, s->entries, s->num_entries * 12);
459  bytestream_put_le32(&ptr, 0);
460 
461  ret = ptr - buf;
462 
463 fail:
464  av_free(strip_sizes);
465  av_free(strip_offsets);
466  av_free(yuv_line);
467  return ret;
468 }
469 
470 #define OFFSET(x) offsetof(TiffEncoderContext, x)
471 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
472 static const AVOption options[] = {
473  { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, {TIFF_PACKBITS}, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },
474  { "packbits", NULL, 0, AV_OPT_TYPE_CONST, {TIFF_PACKBITS}, 0, 0, VE, "compression_algo" },
475  { "raw", NULL, 0, AV_OPT_TYPE_CONST, {TIFF_RAW}, 0, 0, VE, "compression_algo" },
476  { "lzw", NULL, 0, AV_OPT_TYPE_CONST, {TIFF_LZW}, 0, 0, VE, "compression_algo" },
477 #if CONFIG_ZLIB
478  { "deflate", NULL, 0, AV_OPT_TYPE_CONST, {TIFF_DEFLATE}, 0, 0, VE, "compression_algo" },
479 #endif
480  { NULL },
481 };
482 
483 static const AVClass tiffenc_class = {
484  .class_name = "TIFF encoder",
485  .item_name = av_default_item_name,
486  .option = options,
487  .version = LIBAVUTIL_VERSION_INT,
488 };
489 
491  .name = "tiff",
492  .type = AVMEDIA_TYPE_VIDEO,
493  .id = CODEC_ID_TIFF,
494  .priv_data_size = sizeof(TiffEncoderContext),
495  .encode = encode_frame,
496  .pix_fmts =
502  PIX_FMT_NONE},
503  .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
504  .priv_class = &tiffenc_class,
505 };