Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

tiff: K&R formatting cosmetics

Browse Source
pull/23/merge
Diego Biurrun 12 years ago
parent f849a77e67
commit 46ce9ded96
3 changed files with 237 additions and 233 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 114
      libavcodec/tiff.c
  2. 48
      libavcodec/tiff.h
  3. 308
      libavcodec/tiffenc.c

114
libavcodec/tiff.c
Unescape View File

@ -25,19 +25,20 @@
* @author Konstantin Shishkov * @author Konstantin Shishkov
*/ */
#include "avcodec.h"
#include "config.h" #include "config.h"
#if CONFIG_ZLIB #if CONFIG_ZLIB
#include <zlib.h> #include <zlib.h>
#endif #endif
#include "lzw.h"
#include "tiff.h"
#include "faxcompr.h"
#include "internal.h"
#include "mathops.h"
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "libavutil/imgutils.h" #include "libavutil/imgutils.h"
#include "avcodec.h"
#include "faxcompr.h"
#include "internal.h"
#include "lzw.h"
#include "mathops.h"
#include "tiff.h"
typedef struct TiffContext { typedef struct TiffContext {
AVCodecContext *avctx; AVCodecContext *avctx;
@ -78,10 +79,14 @@ static unsigned tget_long(const uint8_t **p, int le)
static unsigned tget(const uint8_t **p, int type, int le) static unsigned tget(const uint8_t **p, int type, int le)
{ {
switch (type) { switch (type) {
case TIFF_BYTE : return *(*p)++; case TIFF_BYTE:
case TIFF_SHORT: return tget_short(p, le); return *(*p)++;
case TIFF_LONG : return tget_long(p, le); case TIFF_SHORT:
default : return UINT_MAX; return tget_short(p, le);
case TIFF_LONG:
return tget_long(p, le);
default:
return UINT_MAX;
} }
} }
@ -92,11 +97,11 @@ static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
z_stream zstream = { 0 }; z_stream zstream = { 0 };
int zret; int zret;
zstream.next_in = src; zstream.next_in = src;
zstream.avail_in = size; zstream.avail_in = size;
zstream.next_out = dst; zstream.next_out = dst;
zstream.avail_out = *len; zstream.avail_out = *len;
zret = inflateInit(&zstream); zret = inflateInit(&zstream);
if (zret != Z_OK) { if (zret != Z_OK) {
av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret); av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
return zret; return zret;
@ -113,7 +118,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
{ {
int c, line, pixels, code, ret; int c, line, pixels, code, ret;
const uint8_t *ssrc = src; const uint8_t *ssrc = src;
int width = ((s->width * s->bpp) + 7) >> 3; int width = ((s->width * s->bpp) + 7) >> 3;
if (size <= 0) if (size <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -124,7 +129,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
unsigned long outlen; unsigned long outlen;
int ret; int ret;
outlen = width * lines; outlen = width * lines;
zbuf = av_malloc(outlen); zbuf = av_malloc(outlen);
if (!zbuf) if (!zbuf)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = tiff_uncompress(zbuf, &outlen, src, size); ret = tiff_uncompress(zbuf, &outlen, src, size);
@ -151,8 +156,9 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
return ret; return ret;
} }
} }
if (s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 if (s->compr == TIFF_CCITT_RLE ||
|| s->compr == TIFF_G4) { s->compr == TIFF_G3 ||
s->compr == TIFF_G4) {
int i, ret = 0; int i, ret = 0;
uint8_t *src2 = av_malloc((unsigned)size + uint8_t *src2 = av_malloc((unsigned)size +
FF_INPUT_BUFFER_PADDING_SIZE); FF_INPUT_BUFFER_PADDING_SIZE);
@ -206,7 +212,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
break; break;
case TIFF_PACKBITS: case TIFF_PACKBITS:
for (pixels = 0; pixels < width;) { for (pixels = 0; pixels < width;) {
code = (int8_t) * src++; code = (int8_t) *src++;
if (code >= 0) { if (code >= 0) {
code++; code++;
if (pixels + code > width) { if (pixels + code > width) {
@ -215,7 +221,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
memcpy(dst + pixels, src, code); memcpy(dst + pixels, src, code);
src += code; src += code;
pixels += code; pixels += code;
} else if (code != -128) { // -127..-1 } else if (code != -128) { // -127..-1
code = (-code) + 1; code = (-code) + 1;
@ -306,10 +312,10 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
if (end_buf - buf < 12) if (end_buf - buf < 12)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
tag = tget_short(&buf, s->le); tag = tget_short(&buf, s->le);
type = tget_short(&buf, s->le); type = tget_short(&buf, s->le);
count = tget_long(&buf, s->le); count = tget_long(&buf, s->le);
off = tget_long(&buf, s->le); off = tget_long(&buf, s->le);
if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) { if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n", av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n",
@ -321,13 +327,13 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
switch (type) { switch (type) {
case TIFF_BYTE: case TIFF_BYTE:
case TIFF_SHORT: case TIFF_SHORT:
buf -= 4; buf -= 4;
value = tget(&buf, type, s->le); value = tget(&buf, type, s->le);
buf = NULL; buf = NULL;
break; break;
case TIFF_LONG: case TIFF_LONG:
value = off; value = off;
buf = NULL; buf = NULL;
break; break;
case TIFF_STRING: case TIFF_STRING:
if (count <= 4) { if (count <= 4) {
@ -336,14 +342,13 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
} }
default: default:
value = UINT_MAX; value = UINT_MAX;
buf = start + off; buf = start + off;
} }
} else { } else {
if (count <= 4 && type_sizes[type] * count <= 4) { if (count <= 4 && type_sizes[type] * count <= 4)
buf -= 4; buf -= 4;
} else { else
buf = start + off; buf = start + off;
}
} }
if (buf && (buf < start || buf > end_buf)) { if (buf && (buf < start || buf > end_buf)) {
@ -397,7 +402,7 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
s->bppcount = value; s->bppcount = value;
break; break;
case TIFF_COMPR: case TIFF_COMPR:
s->compr = value; s->compr = value;
s->predictor = 0; s->predictor = 0;
switch (s->compr) { switch (s->compr) {
case TIFF_RAW: case TIFF_RAW:
@ -441,7 +446,7 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
case TIFF_STRIP_OFFS: case TIFF_STRIP_OFFS:
if (count == 1) { if (count == 1) {
s->stripdata = NULL; s->stripdata = NULL;
s->stripoff = value; s->stripoff = value;
} else } else
s->stripdata = start + off; s->stripdata = start + off;
s->strips = count; s->strips = count;
@ -457,8 +462,8 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
case TIFF_STRIP_SIZE: case TIFF_STRIP_SIZE:
if (count == 1) { if (count == 1) {
s->stripsizes = NULL; s->stripsizes = NULL;
s->stripsize = value; s->stripsize = value;
s->strips = 1; s->strips = 1;
} else { } else {
s->stripsizes = start + off; s->stripsizes = start + off;
} }
@ -503,14 +508,14 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
off = type_sizes[type]; off = type_sizes[type];
if (count / 3 > 256 || end_buf - buf < count / 3 * off * 3) if (count / 3 > 256 || end_buf - buf < count / 3 * off * 3)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
rp = buf; rp = buf;
gp = buf + count / 3 * off; gp = buf + count / 3 * off;
bp = buf + count / 3 * off * 2; bp = buf + count / 3 * off * 2;
off = (type_sizes[type] - 1) << 3; off = (type_sizes[type] - 1) << 3;
for (i = 0; i < count / 3; i++) { for (i = 0; i < count / 3; i++) {
j = (tget(&rp, type, s->le) >> off) << 16; j = (tget(&rp, type, s->le) >> off) << 16;
j |= (tget(&gp, type, s->le) >> off) << 8; j |= (tget(&gp, type, s->le) >> off) << 8;
j |= tget(&bp, type, s->le) >> off; j |= tget(&bp, type, s->le) >> off;
pal[i] = j; pal[i] = j;
} }
s->palette_is_set = 1; s->palette_is_set = 1;
@ -540,21 +545,20 @@ static int decode_frame(AVCodecContext *avctx,
void *data, int *got_frame, AVPacket *avpkt) void *data, int *got_frame, AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
TiffContext *const s = avctx->priv_data; TiffContext *const s = avctx->priv_data;
AVFrame *const p = data; AVFrame *const p = data;
const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
unsigned off; unsigned off;
int id, le, ret; int id, le, ret;
int i, j, entries; int i, j, entries, stride;
int stride;
unsigned soff, ssize; unsigned soff, ssize;
uint8_t *dst; uint8_t *dst;
//parse image header // parse image header
if (end_buf - buf < 8) if (end_buf - buf < 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
id = AV_RL16(buf); id = AV_RL16(buf);
buf += 2; buf += 2;
if (id == 0x4949) if (id == 0x4949)
le = 1; le = 1;
@ -564,9 +568,9 @@ static int decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n"); av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
s->le = le; s->le = le;
s->invert = 0; s->invert = 0;
s->compr = TIFF_RAW; s->compr = TIFF_RAW;
s->fill_order = 0; s->fill_order = 0;
// As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
// that further identifies the file as a TIFF file" // that further identifies the file as a TIFF file"
@ -583,7 +587,7 @@ static int decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n"); av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
buf = orig_buf + off; buf = orig_buf + off;
entries = tget_short(&buf, le); entries = tget_short(&buf, le);
for (i = 0; i < entries; i++) { for (i = 0; i < entries; i++) {
if ((ret = tiff_decode_tag(s, orig_buf, buf, end_buf)) < 0) if ((ret = tiff_decode_tag(s, orig_buf, buf, end_buf)) < 0)
@ -603,7 +607,7 @@ static int decode_frame(AVCodecContext *avctx,
s->stripsize = buf_size - s->stripoff; s->stripsize = buf_size - s->stripoff;
} }
stride = p->linesize[0]; stride = p->linesize[0];
dst = p->data[0]; dst = p->data[0];
for (i = 0; i < s->height; i += s->rps) { for (i = 0; i < s->height; i += s->rps) {
if (s->stripsizes) { if (s->stripsizes) {
if (s->stripsizes >= end_buf) if (s->stripsizes >= end_buf)
@ -629,8 +633,8 @@ static int decode_frame(AVCodecContext *avctx,
dst += s->rps * stride; dst += s->rps * stride;
} }
if (s->predictor == 2) { if (s->predictor == 2) {
dst = p->data[0]; dst = p->data[0];
soff = s->bpp >> 3; soff = s->bpp >> 3;
ssize = s->width * soff; ssize = s->width * soff;
for (i = 0; i < s->height; i++) { for (i = 0; i < s->height; i++) {
for (j = soff; j < ssize; j++) for (j = soff; j < ssize; j++)
@ -659,9 +663,9 @@ static av_cold int tiff_init(AVCodecContext *avctx)
{ {
TiffContext *s = avctx->priv_data; TiffContext *s = avctx->priv_data;
s->width = 0; s->width = 0;
s->height = 0; s->height = 0;
s->avctx = avctx; s->avctx = avctx;
ff_lzw_decode_open(&s->lzw); ff_lzw_decode_open(&s->lzw);
ff_ccitt_unpack_init(); ff_ccitt_unpack_init();
@ -678,6 +682,7 @@ static av_cold int tiff_end(AVCodecContext *avctx)
AVCodec ff_tiff_decoder = { AVCodec ff_tiff_decoder = {
.name = "tiff", .name = "tiff",
.long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_TIFF, .id = AV_CODEC_ID_TIFF,
.priv_data_size = sizeof(TiffContext), .priv_data_size = sizeof(TiffContext),
@ -685,5 +690,4 @@ AVCodec ff_tiff_decoder = {
.close = tiff_end, .close = tiff_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
}; };

48
libavcodec/tiff.h
Unescape View File

@ -31,37 +31,37 @@
#include <stdint.h> #include <stdint.h>
/** abridged list of TIFF tags */ /** abridged list of TIFF tags */
enum TiffTags{ enum TiffTags {
TIFF_SUBFILE = 0xfe, TIFF_SUBFILE = 0xfe,
TIFF_WIDTH = 0x100, TIFF_WIDTH = 0x100,
TIFF_HEIGHT, TIFF_HEIGHT,
TIFF_BPP, TIFF_BPP,
TIFF_COMPR, TIFF_COMPR,
TIFF_INVERT = 0x106, TIFF_INVERT = 0x106,
TIFF_FILL_ORDER = 0x10A, TIFF_FILL_ORDER = 0x10A,
TIFF_STRIP_OFFS = 0x111, TIFF_STRIP_OFFS = 0x111,
TIFF_SAMPLES_PER_PIXEL = 0x115, TIFF_SAMPLES_PER_PIXEL = 0x115,
TIFF_ROWSPERSTRIP = 0x116, TIFF_ROWSPERSTRIP = 0x116,
TIFF_STRIP_SIZE, TIFF_STRIP_SIZE,
TIFF_XRES = 0x11A, TIFF_XRES = 0x11A,
TIFF_YRES = 0x11B, TIFF_YRES = 0x11B,
TIFF_PLANAR = 0x11C, TIFF_PLANAR = 0x11C,
TIFF_XPOS = 0x11E, TIFF_XPOS = 0x11E,
TIFF_YPOS = 0x11F, TIFF_YPOS = 0x11F,
TIFF_T4OPTIONS = 0x124, TIFF_T4OPTIONS = 0x124,
TIFF_T6OPTIONS, TIFF_T6OPTIONS,
TIFF_RES_UNIT = 0x128, TIFF_RES_UNIT = 0x128,
TIFF_SOFTWARE_NAME = 0x131, TIFF_SOFTWARE_NAME = 0x131,
TIFF_PREDICTOR = 0x13D, TIFF_PREDICTOR = 0x13D,
TIFF_PAL = 0x140, TIFF_PAL = 0x140,
TIFF_YCBCR_COEFFICIENTS = 0x211, TIFF_YCBCR_COEFFICIENTS = 0x211,
TIFF_YCBCR_SUBSAMPLING = 0x212, TIFF_YCBCR_SUBSAMPLING = 0x212,
TIFF_YCBCR_POSITIONING = 0x213, TIFF_YCBCR_POSITIONING = 0x213,
TIFF_REFERENCE_BW = 0x214, TIFF_REFERENCE_BW = 0x214,
}; };
/** list of TIFF compression types */ /** list of TIFF compression types */
enum TiffCompr{ enum TiffCompr {
TIFF_RAW = 1, TIFF_RAW = 1,
TIFF_CCITT_RLE, TIFF_CCITT_RLE,
TIFF_G3, TIFF_G3,
@ -71,10 +71,10 @@ enum TiffCompr{
TIFF_NEWJPEG, TIFF_NEWJPEG,
TIFF_ADOBE_DEFLATE, TIFF_ADOBE_DEFLATE,
TIFF_PACKBITS = 0x8005, TIFF_PACKBITS = 0x8005,
TIFF_DEFLATE = 0x80B2 TIFF_DEFLATE = 0x80B2
}; };
enum TiffTypes{ enum TiffTypes {
TIFF_BYTE = 1, TIFF_BYTE = 1,
TIFF_STRING, TIFF_STRING,
TIFF_SHORT, TIFF_SHORT,

308
libavcodec/tiffenc.c
Unescape View File

@ -25,20 +25,20 @@
* @author Bartlomiej Wolowiec * @author Bartlomiej Wolowiec
*/ */
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "avcodec.h"
#include "config.h" #include "config.h"
#if CONFIG_ZLIB #if CONFIG_ZLIB
#include <zlib.h> #include <zlib.h>
#endif #endif
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "avcodec.h"
#include "bytestream.h" #include "bytestream.h"
#include "tiff.h"
#include "rle.h"
#include "lzw.h" #include "lzw.h"
#include "put_bits.h" #include "put_bits.h"
#include "rle.h"
#include "tiff.h"
#define TIFF_MAX_ENTRY 32 #define TIFF_MAX_ENTRY 32
@ -48,35 +48,34 @@ static const uint8_t type_sizes2[6] = {
}; };
typedef struct TiffEncoderContext { typedef struct TiffEncoderContext {
AVClass *class; ///< for private options AVClass *class; ///< for private options
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame picture; AVFrame picture;
int width; ///< picture width int width; ///< picture width
int height; ///< picture height int height; ///< picture height
unsigned int bpp; ///< bits per pixel unsigned int bpp; ///< bits per pixel
int compr; ///< compression level int compr; ///< compression level
int bpp_tab_size; ///< bpp_tab size int bpp_tab_size; ///< bpp_tab size
int photometric_interpretation; ///< photometric interpretation int photometric_interpretation; ///< photometric interpretation
int strips; ///< number of strips int strips; ///< number of strips
int rps; ///< row per strip int rps; ///< row per strip
uint8_t entries[TIFF_MAX_ENTRY*12]; ///< entires in header uint8_t entries[TIFF_MAX_ENTRY * 12]; ///< entries in header
int num_entries; ///< number of entires int num_entries; ///< number of entries
uint8_t **buf; ///< actual position in buffer uint8_t **buf; ///< actual position in buffer
uint8_t *buf_start; ///< pointer to first byte in buffer uint8_t *buf_start; ///< pointer to first byte in buffer
int buf_size; ///< buffer size int buf_size; ///< buffer size
uint16_t subsampling[2]; ///< YUV subsampling factors uint16_t subsampling[2]; ///< YUV subsampling factors
struct LZWEncodeState *lzws; ///< LZW Encode state struct LZWEncodeState *lzws; ///< LZW encode state
} TiffEncoderContext; } TiffEncoderContext;
/** /**
* Check free space in buffer * Check free space in buffer
* @param s Tiff context * @param s Tiff context
* @param need Needed bytes * @param need Needed bytes
* @return 0 - ok, 1 - no free space * @return 0 - ok, 1 - no free space
*/ */
static inline int check_size(TiffEncoderContext * s, uint64_t need) static inline int check_size(TiffEncoderContext *s, uint64_t need)
{ {
if (s->buf_size < *s->buf - s->buf_start + need) { if (s->buf_size < *s->buf - s->buf_start + need) {
*s->buf = s->buf_start + s->buf_size + 1; *s->buf = s->buf_start + s->buf_size + 1;
@ -95,12 +94,12 @@ static inline int check_size(TiffEncoderContext * s, uint64_t need)
* @param type Type of values * @param type Type of values
* @param flip =0 - normal copy, >0 - flip * @param flip =0 - normal copy, >0 - flip
*/ */
static void tnput(uint8_t ** p, int n, const uint8_t * val, enum TiffTypes type, static void tnput(uint8_t **p, int n, const uint8_t *val, enum TiffTypes type,
int flip) int flip)
{ {
int i; int i;
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
flip ^= ((int[]) {0, 0, 0, 1, 3, 3})[type]; flip ^= ((int[]) { 0, 0, 0, 1, 3, 3 })[type];
#endif #endif
for (i = 0; i < n * type_sizes2[type]; i++) for (i = 0; i < n * type_sizes2[type]; i++)
*(*p)++ = val[i ^ flip]; *(*p)++ = val[i ^ flip];
@ -114,9 +113,8 @@ static void tnput(uint8_t ** p, int n, const uint8_t * val, enum TiffTypes type,
* @param count The number of values * @param count The number of values
* @param ptr_val Pointer to values * @param ptr_val Pointer to values
*/ */
static void add_entry(TiffEncoderContext * s, static void add_entry(TiffEncoderContext *s, enum TiffTags tag,
enum TiffTags tag, enum TiffTypes type, int count, enum TiffTypes type, int count, const void *ptr_val)
const void *ptr_val)
{ {
uint8_t *entries_ptr = s->entries + 12 * s->num_entries; uint8_t *entries_ptr = s->entries + 12 * s->num_entries;
@ -137,10 +135,11 @@ static void add_entry(TiffEncoderContext * s,
s->num_entries++; s->num_entries++;
} }
static void add_entry1(TiffEncoderContext * s, static void add_entry1(TiffEncoderContext *s,
enum TiffTags tag, enum TiffTypes type, int val){ enum TiffTags tag, enum TiffTypes type, int val)
uint16_t w = val; {
uint32_t dw= val; uint16_t w = val;
uint32_t dw = val;
add_entry(s, tag, type, 1, type == TIFF_SHORT ? (void *)&w : (void *)&dw); add_entry(s, tag, type, 1, type == TIFF_SHORT ? (void *)&w : (void *)&dw);
} }
@ -154,22 +153,21 @@ static void add_entry1(TiffEncoderContext * s,
* @param compr Compression method * @param compr Compression method
* @return Number of output bytes. If an output error is encountered, -1 returned * @return Number of output bytes. If an output error is encountered, -1 returned
*/ */
static int encode_strip(TiffEncoderContext * s, const int8_t * src, static int encode_strip(TiffEncoderContext *s, const int8_t *src,
uint8_t * dst, int n, int compr) uint8_t *dst, int n, int compr)
{ {
switch (compr) { switch (compr) {
#if CONFIG_ZLIB #if CONFIG_ZLIB
case TIFF_DEFLATE: case TIFF_DEFLATE:
case TIFF_ADOBE_DEFLATE: case TIFF_ADOBE_DEFLATE:
{ {
unsigned long zlen = s->buf_size - (*s->buf - s->buf_start); unsigned long zlen = s->buf_size - (*s->buf - s->buf_start);
if (compress(dst, &zlen, src, n) != Z_OK) { if (compress(dst, &zlen, src, n) != Z_OK) {
av_log(s->avctx, AV_LOG_ERROR, "Compressing failed\n"); av_log(s->avctx, AV_LOG_ERROR, "Compressing failed\n");
return -1; return -1;
}
return zlen;
} }
return zlen;
}
#endif #endif
case TIFF_RAW: case TIFF_RAW:
if (check_size(s, n)) if (check_size(s, n))
@ -177,7 +175,8 @@ static int encode_strip(TiffEncoderContext * s, const int8_t * src,
memcpy(dst, src, n); memcpy(dst, src, n);
return n; return n;
case TIFF_PACKBITS: case TIFF_PACKBITS:
return ff_rle_encode(dst, s->buf_size - (*s->buf - s->buf_start), src, 1, n, 2, 0xff, -1, 0); return ff_rle_encode(dst, s->buf_size - (*s->buf - s->buf_start),
src, 1, n, 2, 0xff, -1, 0);
case TIFF_LZW: case TIFF_LZW:
return ff_lzw_encode(s->lzws, src, n); return ff_lzw_encode(s->lzws, src, n);
default: default:
@ -185,14 +184,14 @@ static int encode_strip(TiffEncoderContext * s, const int8_t * src,
} }
} }
static void pack_yuv(TiffEncoderContext * s, uint8_t * dst, int lnum) static void pack_yuv(TiffEncoderContext *s, uint8_t *dst, int lnum)
{ {
AVFrame *p = &s->picture; AVFrame *p = &s->picture;
int i, j, k; int i, j, k;
int w = (s->width - 1) / s->subsampling[0] + 1; int w = (s->width - 1) / s->subsampling[0] + 1;
uint8_t *pu = &p->data[1][lnum / s->subsampling[1] * p->linesize[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]]; uint8_t *pv = &p->data[2][lnum / s->subsampling[1] * p->linesize[2]];
for (i = 0; i < w; i++){ for (i = 0; i < w; i++) {
for (j = 0; j < s->subsampling[1]; j++) for (j = 0; j < s->subsampling[1]; j++)
for (k = 0; k < s->subsampling[0]; k++) for (k = 0; k < s->subsampling[0]; k++)
*dst++ = p->data[0][(lnum + j) * p->linesize[0] + *dst++ = p->data[0][(lnum + j) * p->linesize[0] +
@ -202,7 +201,7 @@ static void pack_yuv(TiffEncoderContext * s, uint8_t * dst, int lnum)
} }
} }
static int encode_frame(AVCodecContext * avctx, AVPacket *pkt, static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet) const AVFrame *pict, int *got_packet)
{ {
TiffEncoderContext *s = avctx->priv_data; TiffEncoderContext *s = avctx->priv_data;
@ -211,26 +210,26 @@ static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
uint8_t *ptr; uint8_t *ptr;
uint8_t *offset; uint8_t *offset;
uint32_t strips; uint32_t strips;
uint32_t *strip_sizes = NULL; uint32_t *strip_sizes = NULL;
uint32_t *strip_offsets = NULL; uint32_t *strip_offsets = NULL;
int bytes_per_row; int bytes_per_row;
uint32_t res[2] = { 72, 1 }; // image resolution (72/1) uint32_t res[2] = { 72, 1 }; // image resolution (72/1)
uint16_t bpp_tab[] = { 8, 8, 8, 8 }; uint16_t bpp_tab[] = { 8, 8, 8, 8 };
int ret; int ret;
int is_yuv = 0; int is_yuv = 0;
uint8_t *yuv_line = NULL; uint8_t *yuv_line = NULL;
int shift_h, shift_v; int shift_h, shift_v;
const AVPixFmtDescriptor* pfd; const AVPixFmtDescriptor *pfd;
s->avctx = avctx; s->avctx = avctx;
*p = *pict; *p = *pict;
p->pict_type = AV_PICTURE_TYPE_I; p->pict_type = AV_PICTURE_TYPE_I;
p->key_frame = 1; p->key_frame = 1;
avctx->coded_frame= &s->picture; avctx->coded_frame = &s->picture;
s->width = avctx->width; s->width = avctx->width;
s->height = avctx->height; s->height = avctx->height;
s->subsampling[0] = 1; s->subsampling[0] = 1;
s->subsampling[1] = 1; s->subsampling[1] = 1;
@ -240,43 +239,40 @@ static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
case AV_PIX_FMT_RGB24: case AV_PIX_FMT_RGB24:
case AV_PIX_FMT_GRAY8: case AV_PIX_FMT_GRAY8:
case AV_PIX_FMT_PAL8: case AV_PIX_FMT_PAL8:
pfd = av_pix_fmt_desc_get(avctx->pix_fmt); pfd = av_pix_fmt_desc_get(avctx->pix_fmt);
s->bpp = av_get_bits_per_pixel(pfd); s->bpp = av_get_bits_per_pixel(pfd);
if (pfd->flags & AV_PIX_FMT_FLAG_PAL) { if (pfd->flags & AV_PIX_FMT_FLAG_PAL)
s->photometric_interpretation = 3; s->photometric_interpretation = 3;
} else if (pfd->flags & AV_PIX_FMT_FLAG_RGB) { else if (pfd->flags & AV_PIX_FMT_FLAG_RGB)
s->photometric_interpretation = 2; s->photometric_interpretation = 2;
} else { else
s->photometric_interpretation = 1; s->photometric_interpretation = 1;
}
s->bpp_tab_size = pfd->nb_components; s->bpp_tab_size = pfd->nb_components;
for (i = 0; i < s->bpp_tab_size; i++) { for (i = 0; i < s->bpp_tab_size; i++)
bpp_tab[i] = s->bpp / s->bpp_tab_size; bpp_tab[i] = s->bpp / s->bpp_tab_size;
}
break; break;
case AV_PIX_FMT_MONOBLACK: case AV_PIX_FMT_MONOBLACK:
s->bpp = 1; s->bpp = 1;
s->photometric_interpretation = 1; s->photometric_interpretation = 1;
s->bpp_tab_size = 0; s->bpp_tab_size = 0;
break; break;
case AV_PIX_FMT_MONOWHITE: case AV_PIX_FMT_MONOWHITE:
s->bpp = 1; s->bpp = 1;
s->photometric_interpretation = 0; s->photometric_interpretation = 0;
s->bpp_tab_size = 0; s->bpp_tab_size = 0;
break; break;
case AV_PIX_FMT_YUV420P: case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUV422P: case AV_PIX_FMT_YUV422P:
case AV_PIX_FMT_YUV444P: case AV_PIX_FMT_YUV444P:
case AV_PIX_FMT_YUV410P: case AV_PIX_FMT_YUV410P:
case AV_PIX_FMT_YUV411P: case AV_PIX_FMT_YUV411P:
av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &shift_h, &shift_v);
s->photometric_interpretation = 6; s->photometric_interpretation = 6;
av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, s->bpp = 8 + (16 >> (shift_h + shift_v));
&shift_h, &shift_v); s->subsampling[0] = 1 << shift_h;
s->bpp = 8 + (16 >> (shift_h + shift_v)); s->subsampling[1] = 1 << shift_v;
s->subsampling[0] = 1 << shift_h; s->bpp_tab_size = 3;
s->subsampling[1] = 1 << shift_v; is_yuv = 1;
s->bpp_tab_size = 3;
is_yuv = 1;
break; break;
default: default:
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
@ -284,18 +280,23 @@ static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
return -1; return -1;
} }
if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE || s->compr == TIFF_LZW) if (s->compr == TIFF_DEFLATE ||
//best choose for DEFLATE s->compr == TIFF_ADOBE_DEFLATE ||
s->compr == TIFF_LZW)
// best choice for DEFLATE
s->rps = s->height; s->rps = s->height;
else else
s->rps = FFMAX(8192 / (((s->width * s->bpp) >> 3) + 1), 1); // suggest size of strip // suggest size of strip
s->rps = ((s->rps - 1) / s->subsampling[1] + 1) * s->subsampling[1]; // round rps up s->rps = FFMAX(8192 / (((s->width * s->bpp) >> 3) + 1), 1);
// round rps up
s->rps = ((s->rps - 1) / s->subsampling[1] + 1) * s->subsampling[1];
strips = (s->height - 1) / s->rps + 1; strips = (s->height - 1) / s->rps + 1;
if (!pkt->data && if (!pkt->data &&
(ret = av_new_packet(pkt, avctx->width * avctx->height * s->bpp * 2 + (ret = av_new_packet(pkt,
avctx->height * 4 + FF_MIN_BUFFER_SIZE)) < 0) { 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"); av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
return ret; return ret;
} }
@ -314,18 +315,18 @@ static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
offset = ptr; offset = ptr;
bytestream_put_le32(&ptr, 0); bytestream_put_le32(&ptr, 0);
strip_sizes = av_mallocz(sizeof(*strip_sizes) * strips); strip_sizes = av_mallocz(sizeof(*strip_sizes) * strips);
strip_offsets = av_mallocz(sizeof(*strip_offsets) * strips); strip_offsets = av_mallocz(sizeof(*strip_offsets) * strips);
if (!strip_sizes || !strip_offsets) { if (!strip_sizes || !strip_offsets) {
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
} }
bytes_per_row = (((s->width - 1)/s->subsampling[0] + 1) * s->bpp bytes_per_row = (((s->width - 1) / s->subsampling[0] + 1) * s->bpp *
* s->subsampling[0] * s->subsampling[1] + 7) >> 3; s->subsampling[0] * s->subsampling[1] + 7) >> 3;
if (is_yuv){ if (is_yuv) {
yuv_line = av_malloc(bytes_per_row); yuv_line = av_malloc(bytes_per_row);
if (yuv_line == NULL){ if (yuv_line == NULL) {
av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n"); av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
@ -345,14 +346,13 @@ static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
goto fail; goto fail;
} }
strip_offsets[0] = ptr - pkt->data; strip_offsets[0] = ptr - pkt->data;
zn = 0; zn = 0;
for (j = 0; j < s->rps; j++) { for (j = 0; j < s->rps; j++) {
if (is_yuv){ if (is_yuv) {
pack_yuv(s, yuv_line, j); pack_yuv(s, yuv_line, j);
memcpy(zbuf + zn, yuv_line, bytes_per_row); memcpy(zbuf + zn, yuv_line, bytes_per_row);
j += s->subsampling[1] - 1; j += s->subsampling[1] - 1;
} } else
else
memcpy(zbuf + j * bytes_per_row, memcpy(zbuf + j * bytes_per_row,
p->data[0] + j * p->linesize[0], bytes_per_row); p->data[0] + j * p->linesize[0], bytes_per_row);
zn += bytes_per_row; zn += bytes_per_row;
@ -363,93 +363,93 @@ static int encode_frame(AVCodecContext * avctx, AVPacket *pkt,
av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n"); av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
goto fail; goto fail;
} }
ptr += ret; ptr += ret;
strip_sizes[0] = ptr - pkt->data - strip_offsets[0]; strip_sizes[0] = ptr - pkt->data - strip_offsets[0];
} else } else
#endif #endif
{ if (s->compr == TIFF_LZW) {
if (s->compr == TIFF_LZW) { s->lzws = av_malloc(ff_lzw_encode_state_size);
s->lzws = av_malloc(ff_lzw_encode_state_size); if (!s->lzws) {
if (!s->lzws) { ret = AVERROR(ENOMEM);
ret = AVERROR(ENOMEM); goto fail;
goto fail;
}
} }
for (i = 0; i < s->height; i++) { }
if (strip_sizes[i / s->rps] == 0) { for (i = 0; i < s->height; i++) {
if(s->compr == TIFF_LZW){ if (strip_sizes[i / s->rps] == 0) {
ff_lzw_encode_init(s->lzws, ptr, s->buf_size - (*s->buf - s->buf_start), if (s->compr == TIFF_LZW) {
12, FF_LZW_TIFF, put_bits); ff_lzw_encode_init(s->lzws, ptr,
} s->buf_size - (*s->buf - s->buf_start),
strip_offsets[i / s->rps] = ptr - pkt->data; 12, FF_LZW_TIFF, put_bits);
}
if (is_yuv){
pack_yuv(s, yuv_line, i);
ret = encode_strip(s, yuv_line, ptr, bytes_per_row, s->compr);
i += s->subsampling[1] - 1;
}
else
ret = encode_strip(s, p->data[0] + i * p->linesize[0],
ptr, bytes_per_row, s->compr);
if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
goto fail;
}
strip_sizes[i / s->rps] += ret;
ptr += ret;
if(s->compr == TIFF_LZW && (i==s->height-1 || i%s->rps == s->rps-1)){
ret = ff_lzw_encode_flush(s->lzws, flush_put_bits);
strip_sizes[(i / s->rps )] += ret ;
ptr += ret;
} }
strip_offsets[i / s->rps] = ptr - pkt->data;
}
if (is_yuv) {
pack_yuv(s, yuv_line, i);
ret = encode_strip(s, yuv_line, ptr, bytes_per_row, s->compr);
i += s->subsampling[1] - 1;
} else
ret = encode_strip(s, p->data[0] + i * p->linesize[0],
ptr, bytes_per_row, s->compr);
if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
goto fail;
}
strip_sizes[i / s->rps] += ret;
ptr += ret;
if (s->compr == TIFF_LZW &&
(i == s->height - 1 || i % s->rps == s->rps - 1)) {
ret = ff_lzw_encode_flush(s->lzws, flush_put_bits);
strip_sizes[(i / s->rps)] += ret;
ptr += ret;
} }
if(s->compr == TIFF_LZW)
av_free(s->lzws);
} }
if (s->compr == TIFF_LZW)
av_free(s->lzws);
s->num_entries = 0; s->num_entries = 0;
add_entry1(s,TIFF_SUBFILE, TIFF_LONG, 0); add_entry1(s, TIFF_SUBFILE, TIFF_LONG, 0);
add_entry1(s,TIFF_WIDTH, TIFF_LONG, s->width); add_entry1(s, TIFF_WIDTH, TIFF_LONG, s->width);
add_entry1(s,TIFF_HEIGHT, TIFF_LONG, s->height); add_entry1(s, TIFF_HEIGHT, TIFF_LONG, s->height);
if (s->bpp_tab_size) if (s->bpp_tab_size)
add_entry(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab); add_entry(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab);
add_entry1(s,TIFF_COMPR, TIFF_SHORT, s->compr); add_entry1(s, TIFF_COMPR, TIFF_SHORT, s->compr);
add_entry1(s,TIFF_INVERT, TIFF_SHORT, s->photometric_interpretation); add_entry1(s, TIFF_INVERT, TIFF_SHORT, s->photometric_interpretation);
add_entry(s, TIFF_STRIP_OFFS, TIFF_LONG, strips, strip_offsets); add_entry(s, TIFF_STRIP_OFFS, TIFF_LONG, strips, strip_offsets);
if (s->bpp_tab_size) if (s->bpp_tab_size)
add_entry1(s,TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size); add_entry1(s, TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size);
add_entry1(s,TIFF_ROWSPERSTRIP, TIFF_LONG, s->rps); add_entry1(s, TIFF_ROWSPERSTRIP, TIFF_LONG, s->rps);
add_entry(s, TIFF_STRIP_SIZE, TIFF_LONG, strips, strip_sizes); add_entry(s, TIFF_STRIP_SIZE, TIFF_LONG, strips, strip_sizes);
add_entry(s, TIFF_XRES, TIFF_RATIONAL, 1, res); add_entry(s, TIFF_XRES, TIFF_RATIONAL, 1, res);
add_entry(s, TIFF_YRES, TIFF_RATIONAL, 1, res); add_entry(s, TIFF_YRES, TIFF_RATIONAL, 1, res);
add_entry1(s,TIFF_RES_UNIT, TIFF_SHORT, 2); add_entry1(s, TIFF_RES_UNIT, TIFF_SHORT, 2);
if(!(avctx->flags & CODEC_FLAG_BITEXACT)) if (!(avctx->flags & CODEC_FLAG_BITEXACT))
add_entry(s, TIFF_SOFTWARE_NAME, TIFF_STRING, add_entry(s, TIFF_SOFTWARE_NAME, TIFF_STRING,
strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT); strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT);
if (avctx->pix_fmt == AV_PIX_FMT_PAL8) { if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
uint16_t pal[256 * 3]; uint16_t pal[256 * 3];
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
uint32_t rgb = *(uint32_t *) (p->data[1] + i * 4); uint32_t rgb = *(uint32_t *) (p->data[1] + i * 4);
pal[i] = ((rgb >> 16) & 0xff) * 257; pal[i] = ((rgb >> 16) & 0xff) * 257;
pal[i + 256] = ((rgb >> 8 ) & 0xff) * 257; pal[i + 256] = ((rgb >> 8) & 0xff) * 257;
pal[i + 512] = ( rgb & 0xff) * 257; pal[i + 512] = (rgb & 0xff) * 257;
} }
add_entry(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal); add_entry(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);
} }
if (is_yuv){ if (is_yuv) {
/** according to CCIR Recommendation 601.1 */ /** according to CCIR Recommendation 601.1 */
uint32_t refbw[12] = {15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 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_YCBCR_SUBSAMPLING, TIFF_SHORT, 2, s->subsampling);
add_entry(s, TIFF_REFERENCE_BW, TIFF_RATIONAL, 6, refbw); add_entry(s, TIFF_REFERENCE_BW, TIFF_RATIONAL, 6, refbw);
} }
bytestream_put_le32(&offset, ptr - pkt->data); // write offset to dir // write offset to dir
bytestream_put_le32(&offset, ptr - pkt->data);
if (check_size(s, 6 + s->num_entries * 12)) { if (check_size(s, 6 + s->num_entries * 12)) {
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
@ -473,12 +473,12 @@ fail:
#define OFFSET(x) offsetof(TiffEncoderContext, x) #define OFFSET(x) offsetof(TiffEncoderContext, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = { static const AVOption options[] = {
{ "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, {.i64 = TIFF_PACKBITS}, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" }, { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, { .i64 = TIFF_PACKBITS }, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },
{ "packbits", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_PACKBITS}, 0, 0, VE, "compression_algo" }, { "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" }, { "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" }, { "lzw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_LZW }, 0, 0, VE, "compression_algo" },
#if CONFIG_ZLIB #if CONFIG_ZLIB
{ "deflate", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_DEFLATE}, 0, 0, VE, "compression_algo" }, { "deflate", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_DEFLATE }, 0, 0, VE, "compression_algo" },
#endif #endif
{ NULL }, { NULL },
}; };
@ -492,6 +492,7 @@ static const AVClass tiffenc_class = {
AVCodec ff_tiff_encoder = { AVCodec ff_tiff_encoder = {
.name = "tiff", .name = "tiff",
.long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_TIFF, .id = AV_CODEC_ID_TIFF,
.priv_data_size = sizeof(TiffEncoderContext), .priv_data_size = sizeof(TiffEncoderContext),
@ -504,6 +505,5 @@ AVCodec ff_tiff_encoder = {
AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
AV_PIX_FMT_NONE AV_PIX_FMT_NONE
}, },
.long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
.priv_class = &tiffenc_class, .priv_class = &tiffenc_class,
}; };

Write Preview
Loading…
Cancel
Save