FFmpeg: libavcodec/tiffenc.c Source File

FFmpeg

[フレーム]

libavcodec

tiffenc.c

Go to the documentation of this file.

1 /*

2 * TIFF image encoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software

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

20 */

22 /**

23 * @file

24 * TIFF image encoder

25 * @author Bartlomiej Wolowiec

26 */

28 #include "config.h"

29 #if CONFIG_ZLIB

30 #include <zlib.h>

31 #endif

33 #include "libavutil/imgutils.h"

34 #include "libavutil/log.h"

35 #include "libavutil/opt.h"

36 #include "libavutil/pixdesc.h"

37 #include "avcodec.h"

38 #include "bytestream.h"

39 #include "internal.h"

40 #include "lzw.h"

41 #include "put_bits.h"

42 #include "rle.h"

43 #include "tiff.h"

45 #define TIFF_MAX_ENTRY 32

47 /** sizes of various TIFF field types (string size = 1)*/

48 static const uint8_t type_sizes2[14] = {

49 0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4

50 };

52 typedef struct TiffEncoderContext {

53 AVClass *class; ///< for private options

54 AVCodecContext *avctx;

56 int width; ///< picture width

57 int height; ///< picture height

58 unsigned int bpp; ///< bits per pixel

59 int compr; ///< compression level

60 int bpp_tab_size; ///< bpp_tab size

61 enum TiffPhotometric photometric_interpretation; ///< photometric interpretation

62 int strips; ///< number of strips

63 uint32_t *strip_sizes;

64 unsigned int strip_sizes_size;

65 uint32_t *strip_offsets;

66 unsigned int strip_offsets_size;

67 uint8_t *yuv_line;

68 unsigned int yuv_line_size;

69 int rps; ///< row per strip

70 uint8_t entries[TIFF_MAX_ENTRY * 12]; ///< entries in header

71 int num_entries; ///< number of entries

72 uint8_t **buf; ///< actual position in buffer

73 uint8_t *buf_start; ///< pointer to first byte in buffer

74 int buf_size; ///< buffer size

75 uint16_t subsampling[2]; ///< YUV subsampling factors

76 struct LZWEncodeState *lzws; ///< LZW encode state

77 uint32_t dpi; ///< image resolution in DPI

78 } TiffEncoderContext;

80 /**

81 * Check free space in buffer.

82 *

83 * @param s Tiff context

84 * @param need Needed bytes

85 * @return 0 - ok, 1 - no free space

86 */

87 static inline int check_size(TiffEncoderContext *s, uint64_t need)

88 {

89 if (s->buf_size < *s->buf - s->buf_start + need) {

90 *s->buf = s->buf_start + s->buf_size + 1;

91 av_log(s->avctx, AV_LOG_ERROR, "Buffer is too small\n");

92 return 1;

93 }

94 return 0;

95 }

97 /**

98 * Put n values to buffer.

99 *

100 * @param p pointer to pointer to output buffer

101 * @param n number of values

102 * @param val pointer to values

103 * @param type type of values

104 * @param flip = 0 - normal copy, >0 - flip

105 */

106 static void tnput(uint8_t **p, int n, const uint8_t *val, enum TiffTypes type,

107 int flip)

108 {

109 int i;

110 #if HAVE_BIGENDIAN

111 flip ^= ((int[]) { 0, 0, 0, 1, 3, 3 })[type];

112 #endif

113 for (i = 0; i < n * type_sizes2[type]; i++)

114 *(*p)++ = val[i ^ flip];

115 }

116

117 /**

118 * Add entry to directory in tiff header.

119 *

120 * @param s Tiff context

121 * @param tag tag that identifies the entry

122 * @param type entry type

123 * @param count the number of values

124 * @param ptr_val pointer to values

125 */

126 static int add_entry(TiffEncoderContext *s, enum TiffTags tag,

127 enum TiffTypes type, int count, const void *ptr_val)

128 {

129 uint8_t *entries_ptr = s->entries + 12 * s->num_entries;

130

131 av_assert0(s->num_entries < TIFF_MAX_ENTRY);

132

133 bytestream_put_le16(&entries_ptr, tag);

134 bytestream_put_le16(&entries_ptr, type);

135 bytestream_put_le32(&entries_ptr, count);

136

137 if (type_sizes[type] * (int64_t)count <= 4) {

138 tnput(&entries_ptr, count, ptr_val, type, 0);

139 } else {

140 bytestream_put_le32(&entries_ptr, *s->buf - s->buf_start);

141 if (check_size(s, count * (int64_t)type_sizes2[type]))

142 return AVERROR_INVALIDDATA;

143 tnput(s->buf, count, ptr_val, type, 0);

144 }

145

146 s->num_entries++;

147 return 0;

148 }

149

150 static int add_entry1(TiffEncoderContext *s,

151 enum TiffTags tag, enum TiffTypes type, int val)

152 {

153 uint16_t w = val;

154 uint32_t dw = val;

155 return add_entry(s, tag, type, 1,

156 type == TIFF_SHORT ? (void *)&w : (void *)&dw);

157 }

158

159 /**

160 * Encode one strip in tiff file.

161 *

162 * @param s Tiff context

163 * @param src input buffer

164 * @param dst output buffer

165 * @param n size of input buffer

166 * @param compr compression method

167 * @return number of output bytes. If an output error is encountered, -1 is returned

168 */

169 static int encode_strip(TiffEncoderContext *s, const int8_t *src,

170 uint8_t *dst, int n, int compr)

171 {

172 switch (compr) {

173 #if CONFIG_ZLIB

174 case TIFF_DEFLATE:

175 case TIFF_ADOBE_DEFLATE:

176 {

177 unsigned long zlen = s->buf_size - (*s->buf - s->buf_start);

178 if (compress(dst, &zlen, src, n) != Z_OK) {

179 av_log(s->avctx, AV_LOG_ERROR, "Compressing failed\n");

180 return -1;

181 }

182 return zlen;

183 }

184 #endif

185 case TIFF_RAW:

186 if (check_size(s, n))

187 return -1;

188 memcpy(dst, src, n);

189 return n;

190 case TIFF_PACKBITS:

191 return ff_rle_encode(dst, s->buf_size - (*s->buf - s->buf_start),

192 src, 1, n, 2, 0xff, -1, 0);

193 case TIFF_LZW:

194 return ff_lzw_encode(s->lzws, src, n);

195 default:

196 return -1;

197 }

198 }

199

200 static void pack_yuv(TiffEncoderContext *s, const AVFrame *p,

201 uint8_t *dst, int lnum)

202 {

203 int i, j, k;

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

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

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

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

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

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

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

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

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

213 *dst++ = *pu++;

214 *dst++ = *pv++;

215 }

216 }else{

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

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

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

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

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

222 *dst++ = *pu++;

223 *dst++ = *pv++;

224 }

225 }

226 }

227

228 #define ADD_ENTRY(s, tag, type, count, ptr_val) \

229 do { \

230 ret = add_entry(s, tag, type, count, ptr_val); \

231 if (ret < 0) \

232 goto fail; \

233 } while (0)

234

235 #define ADD_ENTRY1(s, tag, type, val) \

236 do { \

237 ret = add_entry1(s, tag, type, val); \

238 if (ret < 0) \

239 goto fail; \

240 } while (0)

241

242 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

243 const AVFrame *pict, int *got_packet)

244 {

245 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

246 TiffEncoderContext *s = avctx->priv_data;

247 const AVFrame *const p = pict;

248 int i;

249 uint8_t *ptr;

250 uint8_t *offset;

251 uint32_t strips;

252 int bytes_per_row;

253 uint32_t res[2] = { s->dpi, 1 }; // image resolution (72/1)

254 uint16_t bpp_tab[4];

255 int ret = 0;

256 int is_yuv = 0, alpha = 0;

257 int shift_h, shift_v;

258 int packet_size;

259

260 s->width = avctx->width;

261 s->height = avctx->height;

262 s->subsampling[0] = 1;

263 s->subsampling[1] = 1;

264

265 avctx->bits_per_coded_sample =

266 s->bpp = av_get_bits_per_pixel(desc);

267 s->bpp_tab_size = desc->nb_components;

268

269 switch (avctx->pix_fmt) {

270 case AV_PIX_FMT_RGBA64LE:

271 case AV_PIX_FMT_RGBA:

272 alpha = 1;

273 case AV_PIX_FMT_RGB48LE:

274 case AV_PIX_FMT_RGB24:

275 s->photometric_interpretation = TIFF_PHOTOMETRIC_RGB;

276 break;

277 case AV_PIX_FMT_GRAY8:

278 avctx->bits_per_coded_sample = 0x28;

279 case AV_PIX_FMT_GRAY8A:

280 case AV_PIX_FMT_YA16LE:

281 alpha = avctx->pix_fmt == AV_PIX_FMT_GRAY8A || avctx->pix_fmt == AV_PIX_FMT_YA16LE;

282 case AV_PIX_FMT_GRAY16LE:

283 case AV_PIX_FMT_MONOBLACK:

284 s->photometric_interpretation = TIFF_PHOTOMETRIC_BLACK_IS_ZERO;

285 break;

286 case AV_PIX_FMT_PAL8:

287 s->photometric_interpretation = TIFF_PHOTOMETRIC_PALETTE;

288 break;

289 case AV_PIX_FMT_MONOWHITE:

290 s->photometric_interpretation = TIFF_PHOTOMETRIC_WHITE_IS_ZERO;

291 break;

292 case AV_PIX_FMT_YUV420P:

293 case AV_PIX_FMT_YUV422P:

294 case AV_PIX_FMT_YUV440P:

295 case AV_PIX_FMT_YUV444P:

296 case AV_PIX_FMT_YUV410P:

297 case AV_PIX_FMT_YUV411P:

298 av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &shift_h, &shift_v);

299 s->photometric_interpretation = TIFF_PHOTOMETRIC_YCBCR;

300 s->subsampling[0] = 1 << shift_h;

301 s->subsampling[1] = 1 << shift_v;

302 is_yuv = 1;

303 break;

304 default:

305 av_log(s->avctx, AV_LOG_ERROR,

306 "This colors format is not supported\n");

307 return -1;

308 }

309

310 for (i = 0; i < s->bpp_tab_size; i++)

311 bpp_tab[i] = desc->comp[i].depth_minus1 + 1;

312

313 if (s->compr == TIFF_DEFLATE ||

314 s->compr == TIFF_ADOBE_DEFLATE ||

315 s->compr == TIFF_LZW)

316 // best choice for DEFLATE

317 s->rps = s->height;

318 else

319 // suggest size of strip

320 s->rps = FFMAX(8192 / (((s->width * s->bpp) >> 3) + 1), 1);

321 // round rps up

322 s->rps = ((s->rps - 1) / s->subsampling[1] + 1) * s->subsampling[1];

323

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

325

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

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

328 packet_size = avctx->height * bytes_per_row * 2 +

329 avctx->height * 4 + FF_MIN_BUFFER_SIZE;

330

331 if ((ret = ff_alloc_packet2(avctx, pkt, packet_size)) < 0)

332 return ret;

333 ptr = pkt->data;

334 s->buf_start = pkt->data;

335 s->buf = &ptr;

336 s->buf_size = pkt->size;

337

338 if (check_size(s, 8)) {

339 ret = AVERROR(EINVAL);

340 goto fail;

341 }

342

343 // write header

344 bytestream_put_le16(&ptr, 0x4949);

345 bytestream_put_le16(&ptr, 42);

346

347 offset = ptr;

348 bytestream_put_le32(&ptr, 0);

349

350 if (strips > INT_MAX / FFMAX(sizeof(s->strip_sizes[0]), sizeof(s->strip_offsets[0]))) {

351 ret = AVERROR(ENOMEM);

352 goto fail;

353 }

354 av_fast_padded_mallocz(&s->strip_sizes , &s->strip_sizes_size , sizeof(s->strip_sizes [0]) * strips);

355 av_fast_padded_mallocz(&s->strip_offsets, &s->strip_offsets_size, sizeof(s->strip_offsets[0]) * strips);

356

357 if (!s->strip_sizes || !s->strip_offsets) {

358 ret = AVERROR(ENOMEM);

359 goto fail;

360 }

361

362 if (is_yuv) {

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

364 if (s->yuv_line == NULL) {

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

366 ret = AVERROR(ENOMEM);

367 goto fail;

368 }

369 }

370

371 #if CONFIG_ZLIB

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

373 uint8_t *zbuf;

374 int zlen, zn;

375 int j;

376

377 zlen = bytes_per_row * s->rps;

378 zbuf = av_malloc(zlen);

379 if (!zbuf) {

380 ret = AVERROR(ENOMEM);

381 goto fail;

382 }

383 s->strip_offsets[0] = ptr - pkt->data;

384 zn = 0;

385 for (j = 0; j < s->rps; j++) {

386 if (is_yuv) {

387 pack_yuv(s, p, s->yuv_line, j);

388 memcpy(zbuf + zn, s->yuv_line, bytes_per_row);

389 j += s->subsampling[1] - 1;

390 } else

391 memcpy(zbuf + j * bytes_per_row,

392 p->data[0] + j * p->linesize[0], bytes_per_row);

393 zn += bytes_per_row;

394 }

395 ret = encode_strip(s, zbuf, ptr, zn, s->compr);

396 av_free(zbuf);

397 if (ret < 0) {

398 av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");

399 goto fail;

400 }

401 ptr += ret;

402 s->strip_sizes[0] = ptr - pkt->data - s->strip_offsets[0];

403 } else

404 #endif

405 {

406 if (s->compr == TIFF_LZW) {

407 s->lzws = av_malloc(ff_lzw_encode_state_size);

408 if (!s->lzws) {

409 ret = AVERROR(ENOMEM);

410 goto fail;

411 }

412 }

413 for (i = 0; i < s->height; i++) {

414 if (s->strip_sizes[i / s->rps] == 0) {

415 if (s->compr == TIFF_LZW) {

416 ff_lzw_encode_init(s->lzws, ptr,

417 s->buf_size - (*s->buf - s->buf_start),

418 12, FF_LZW_TIFF, put_bits);

419 }

420 s->strip_offsets[i / s->rps] = ptr - pkt->data;

421 }

422 if (is_yuv) {

423 pack_yuv(s, p, s->yuv_line, i);

424 ret = encode_strip(s, s->yuv_line, ptr, bytes_per_row, s->compr);

425 i += s->subsampling[1] - 1;

426 } else

427 ret = encode_strip(s, p->data[0] + i * p->linesize[0],

428 ptr, bytes_per_row, s->compr);

429 if (ret < 0) {

430 av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");

431 goto fail;

432 }

433 s->strip_sizes[i / s->rps] += ret;

434 ptr += ret;

435 if (s->compr == TIFF_LZW &&

436 (i == s->height - 1 || i % s->rps == s->rps - 1)) {

437 ret = ff_lzw_encode_flush(s->lzws, flush_put_bits);

438 s->strip_sizes[(i / s->rps)] += ret;

439 ptr += ret;

440 }

441 }

442 if (s->compr == TIFF_LZW)

443 av_freep(&s->lzws);

444 }

445

446 s->num_entries = 0;

447

448 ADD_ENTRY1(s, TIFF_SUBFILE, TIFF_LONG, 0);

449 ADD_ENTRY1(s, TIFF_WIDTH, TIFF_LONG, s->width);

450 ADD_ENTRY1(s, TIFF_HEIGHT, TIFF_LONG, s->height);

451

452 if (s->bpp_tab_size)

453 ADD_ENTRY(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab);

454

455 ADD_ENTRY1(s, TIFF_COMPR, TIFF_SHORT, s->compr);

456 ADD_ENTRY1(s, TIFF_PHOTOMETRIC, TIFF_SHORT, s->photometric_interpretation);

457 ADD_ENTRY(s, TIFF_STRIP_OFFS, TIFF_LONG, strips, s->strip_offsets);

458

459 if (s->bpp_tab_size)

460 ADD_ENTRY1(s, TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size);

461

462 ADD_ENTRY1(s, TIFF_ROWSPERSTRIP, TIFF_LONG, s->rps);

463 ADD_ENTRY(s, TIFF_STRIP_SIZE, TIFF_LONG, strips, s->strip_sizes);

464 ADD_ENTRY(s, TIFF_XRES, TIFF_RATIONAL, 1, res);

465 if (avctx->sample_aspect_ratio.num > 0 &&

466 avctx->sample_aspect_ratio.den > 0) {

467 AVRational y = av_mul_q(av_make_q(s->dpi, 1),

468 avctx->sample_aspect_ratio);

469 res[0] = y.num;

470 res[1] = y.den;

471 }

472 ADD_ENTRY(s, TIFF_YRES, TIFF_RATIONAL, 1, res);

473 ADD_ENTRY1(s, TIFF_RES_UNIT, TIFF_SHORT, 2);

474

475 if (!(avctx->flags & CODEC_FLAG_BITEXACT))

476 ADD_ENTRY(s, TIFF_SOFTWARE_NAME, TIFF_STRING,

477 strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT);

478

479 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

480 uint16_t pal[256 * 3];

481 for (i = 0; i < 256; i++) {

482 uint32_t rgb = *(uint32_t *) (p->data[1] + i * 4);

483 pal[i] = ((rgb >> 16) & 0xff) * 257;

484 pal[i + 256] = ((rgb >> 8) & 0xff) * 257;

485 pal[i + 512] = (rgb & 0xff) * 257;

486 }

487 ADD_ENTRY(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);

488 }

489 if (alpha)

490 ADD_ENTRY1(s,TIFF_EXTRASAMPLES, TIFF_SHORT, 2);

491 if (is_yuv) {

492 /** according to CCIR Recommendation 601.1 */

493 uint32_t refbw[12] = { 15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 1 };

494 ADD_ENTRY(s, TIFF_YCBCR_SUBSAMPLING, TIFF_SHORT, 2, s->subsampling);

495 if (avctx->chroma_sample_location == AVCHROMA_LOC_TOPLEFT)

496 ADD_ENTRY1(s, TIFF_YCBCR_POSITIONING, TIFF_SHORT, 2);

497 ADD_ENTRY(s, TIFF_REFERENCE_BW, TIFF_RATIONAL, 6, refbw);

498 }

499 // write offset to dir

500 bytestream_put_le32(&offset, ptr - pkt->data);

501

502 if (check_size(s, 6 + s->num_entries * 12)) {

503 ret = AVERROR(EINVAL);

504 goto fail;

505 }

506 bytestream_put_le16(&ptr, s->num_entries); // write tag count

507 bytestream_put_buffer(&ptr, s->entries, s->num_entries * 12);

508 bytestream_put_le32(&ptr, 0);

509

510 pkt->size = ptr - pkt->data;

511 pkt->flags |= AV_PKT_FLAG_KEY;

512 *got_packet = 1;

513

514 fail:

515 return ret < 0 ? ret : 0;

516 }

517

518 static av_cold int encode_init(AVCodecContext *avctx)

519 {

520 TiffEncoderContext *s = avctx->priv_data;

521

522 avctx->coded_frame = av_frame_alloc();

523 if (!avctx->coded_frame)

524 return AVERROR(ENOMEM);

525

526 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

527 avctx->coded_frame->key_frame = 1;

528 s->avctx = avctx;

529

530 return 0;

531 }

532

533 static av_cold int encode_close(AVCodecContext *avctx)

534 {

535 TiffEncoderContext *s = avctx->priv_data;

536

537 av_frame_free(&avctx->coded_frame);

538 av_freep(&s->strip_sizes);

539 av_freep(&s->strip_offsets);

540 av_freep(&s->yuv_line);

541

542 return 0;

543 }

544

545 #define OFFSET(x) offsetof(TiffEncoderContext, x)

546 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

547 static const AVOption options[] = {

548 {"dpi", "set the image resolution (in dpi)", OFFSET(dpi), AV_OPT_TYPE_INT, {.i64 = 72}, 1, 0x10000, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_ENCODING_PARAM},

549 { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, { .i64 = TIFF_PACKBITS }, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },

550 { "packbits", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_PACKBITS }, 0, 0, VE, "compression_algo" },

551 { "raw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_RAW }, 0, 0, VE, "compression_algo" },

552 { "lzw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_LZW }, 0, 0, VE, "compression_algo" },

553 #if CONFIG_ZLIB

554 { "deflate", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_DEFLATE }, 0, 0, VE, "compression_algo" },

555 #endif

556 { NULL },

557 };

558

559 static const AVClass tiffenc_class = {

560 .class_name = "TIFF encoder",

561 .item_name = av_default_item_name,

562 .option = options,

563 .version = LIBAVUTIL_VERSION_INT,

564 };

565

566 AVCodec ff_tiff_encoder = {

567 .name = "tiff",

568 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),

569 .type = AVMEDIA_TYPE_VIDEO,

570 .id = AV_CODEC_ID_TIFF,

571 .priv_data_size = sizeof(TiffEncoderContext),

572 .init = encode_init,

573 .close = encode_close,

574 .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,

575 .encode2 = encode_frame,

576 .pix_fmts = (const enum AVPixelFormat[]) {

577 AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48LE, AV_PIX_FMT_PAL8,

578 AV_PIX_FMT_RGBA, AV_PIX_FMT_RGBA64LE,

579 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_YA16LE,

580 AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_MONOWHITE,

581 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,

582 AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,

583 AV_PIX_FMT_NONE

584 },

585 .priv_class = &tiffenc_class,

586 };

Generated on Sun Mar 8 2015 02:35:00 for FFmpeg by doxygen 1.8.2