FFmpeg: libavcodec/faxcompr.c Source File

FFmpeg

[フレーム]

libavcodec

faxcompr.c

Go to the documentation of this file.

1 /*

2 * CCITT Fax Group 3 and 4 decompression

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 * CCITT Fax Group 3 and 4 decompression

25 * @author Konstantin Shishkov

26 */

27 #include "libavutil/thread.h"

28 #include "avcodec.h"

29 #include "get_bits.h"

30 #include "put_bits.h"

31 #include "faxcompr.h"

33 #define CCITT_SYMS 104

35 static const uint16_t ccitt_syms[CCITT_SYMS] = {

36 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

37 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,

38 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,

39 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,

40 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,

41 128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896,

42 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728,

43 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560

44 };

46 static const uint8_t ccitt_codes_bits[2][CCITT_SYMS] =

47 {

48 {

49 0x35, 0x07, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, 0x13, 0x14, 0x07, 0x08, 0x08,

50 0x03, 0x34, 0x35, 0x2A, 0x2B, 0x27, 0x0C, 0x08, 0x17, 0x03, 0x04, 0x28, 0x2B,

51 0x13, 0x24, 0x18, 0x02, 0x03, 0x1A, 0x1B, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

52 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x04, 0x05, 0x0A, 0x0B, 0x52, 0x53, 0x54,

53 0x55, 0x24, 0x25, 0x58, 0x59, 0x5A, 0x5B, 0x4A, 0x4B, 0x32, 0x33, 0x34, 0x1B,

54 0x12, 0x17, 0x37, 0x36, 0x37, 0x64, 0x65, 0x68, 0x67, 0xCC, 0xCD, 0xD2, 0xD3,

55 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0x98, 0x99, 0x9A, 0x18, 0x9B,

56 0x08, 0x0C, 0x0D, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F

57 },

58 {

59 0x37, 0x02, 0x03, 0x02, 0x03, 0x03, 0x02, 0x03, 0x05, 0x04, 0x04, 0x05, 0x07,

60 0x04, 0x07, 0x18, 0x17, 0x18, 0x08, 0x67, 0x68, 0x6C, 0x37, 0x28, 0x17, 0x18,

61 0xCA, 0xCB, 0xCC, 0xCD, 0x68, 0x69, 0x6A, 0x6B, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,

62 0xD7, 0x6C, 0x6D, 0xDA, 0xDB, 0x54, 0x55, 0x56, 0x57, 0x64, 0x65, 0x52, 0x53,

63 0x24, 0x37, 0x38, 0x27, 0x28, 0x58, 0x59, 0x2B, 0x2C, 0x5A, 0x66, 0x67, 0x0F,

64 0xC8, 0xC9, 0x5B, 0x33, 0x34, 0x35, 0x6C, 0x6D, 0x4A, 0x4B, 0x4C, 0x4D, 0x72,

65 0x73, 0x74, 0x75, 0x76, 0x77, 0x52, 0x53, 0x54, 0x55, 0x5A, 0x5B, 0x64, 0x65,

66 0x08, 0x0C, 0x0D, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F

67 }

68 };

70 static const uint8_t ccitt_codes_lens[2][CCITT_SYMS] =

71 {

72 {

73 8, 6, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7,

74 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,

75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,

76 8, 8, 8, 8, 5, 5, 6, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,

77 9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 9, 11, 11, 11, 12, 12, 12, 12, 12, 12,

78 12, 12, 12, 12

79 },

80 {

81 10, 3, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 7, 8, 8, 9, 10, 10, 10, 11,

82 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

83 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

84 12, 12, 12, 12, 10, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13,

85 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 12, 12, 12, 12, 12, 12,

86 12, 12, 12, 12

87 }

88 };

90 static const uint8_t ccitt_group3_2d_bits[11] = {

91 1, 1, 2, 2, 2, 1, 3, 3, 3, 1, 1

92 };

94 static const uint8_t ccitt_group3_2d_lens[11] = {

95 4, 3, 7, 6, 3, 1, 3, 6, 7, 7, 9

96 };

98 static VLC ccitt_vlc[2], ccitt_group3_2d_vlc;

100 static av_cold void ccitt_unpack_init(void)

101 {

102 static VLC_TYPE code_table1[528][2];

103 static VLC_TYPE code_table2[648][2];

104 int i;

105

106 ccitt_vlc[0].table = code_table1;

107 ccitt_vlc[0].table_allocated = 528;

108 ccitt_vlc[1].table = code_table2;

109 ccitt_vlc[1].table_allocated = 648;

110 for (i = 0; i < 2; i++) {

111 ff_init_vlc_sparse(&ccitt_vlc[i], 9, CCITT_SYMS,

112 ccitt_codes_lens[i], 1, 1,

113 ccitt_codes_bits[i], 1, 1,

114 ccitt_syms, 2, 2,

115 INIT_VLC_USE_NEW_STATIC);

116 }

117 INIT_VLC_STATIC(&ccitt_group3_2d_vlc, 9, 11,

118 ccitt_group3_2d_lens, 1, 1,

119 ccitt_group3_2d_bits, 1, 1, 512);

120 }

121

122 av_cold void ff_ccitt_unpack_init(void)

123 {

124 static AVOnce init_static_once = AV_ONCE_INIT;

125 ff_thread_once(&init_static_once, ccitt_unpack_init);

126 }

127

128 static int decode_uncompressed(AVCodecContext *avctx, GetBitContext *gb,

129 unsigned int *pix_left, int **runs,

130 const int *runend, int *mode)

131 {

132 int eob = 0;

133 int newmode;

134 int saved_run = 0;

135

136 do {

137 int cwi, k;

138 int cw = 0;

139 int codes[2];

140 do {

141 cwi = show_bits(gb, 11);

142 if (!cwi) {

143 av_log(avctx, AV_LOG_ERROR, "Invalid uncompressed codeword\n");

144 return AVERROR_INVALIDDATA;

145 }

146 cwi = 10 - av_log2(cwi);

147 if (get_bits_left(gb) < cwi + 1)

148 return AVERROR_INVALIDDATA;

149 skip_bits(gb, cwi + 1);

150 if (cwi > 5) {

151 newmode = get_bits1(gb);

152 eob = 1;

153 cwi -= 6;

154 }

155 cw += cwi;

156 } while(cwi == 5);

157

158 codes[0] = cw;

159 codes[1] = !eob;

160

161 for (k = 0; k < 2; k++) {

162 if (codes[k]) {

163 if (*mode == !k) {

164 *(*runs)++ = saved_run;

165 if (*runs >= runend) {

166 av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");

167 return AVERROR_INVALIDDATA;

168 }

169 if (*pix_left <= saved_run) {

170 av_log(avctx, AV_LOG_ERROR, "uncompressed run went out of bounds\n");

171 return AVERROR_INVALIDDATA;

172 }

173 *pix_left -= saved_run;

174 saved_run = 0;

175 *mode = !*mode;

176 }

177 saved_run += codes[k];

178 }

179 }

180 } while (!eob);

181 *(*runs)++ = saved_run;

182 if (*runs >= runend) {

183 av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");

184 return AVERROR_INVALIDDATA;

185 }

186 if (*pix_left <= saved_run) {

187 if (*pix_left == saved_run)

188 return 1;

189 av_log(avctx, AV_LOG_ERROR, "uncompressed run went out of boundsE\n");

190 return AVERROR_INVALIDDATA;

191 }

192 *pix_left -= saved_run;

193 saved_run = 0;

194 *mode = !*mode;

195 if (newmode != *mode) { //FIXME CHECK

196 *(*runs)++ = 0;

197 if (*runs >= runend) {

198 av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");

199 return AVERROR_INVALIDDATA;

200 }

201 *mode = newmode;

202 }

203 return 0;

204 }

205

206 static int decode_group3_1d_line(AVCodecContext *avctx, GetBitContext *gb,

207 unsigned int pix_left, int *runs,

208 const int *runend)

209 {

210 int mode = 0;

211 unsigned int run = 0;

212 unsigned int t;

213 for (;;) {

214 if (get_bits_left(gb) <= 0)

215 return AVERROR_INVALIDDATA;

216 t = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2);

217 run += t;

218 if (t < 64) {

219 *runs++ = run;

220 if (runs >= runend) {

221 av_log(avctx, AV_LOG_ERROR, "Run overrun\n");

222 return AVERROR_INVALIDDATA;

223 }

224 if (pix_left <= run) {

225 if (pix_left == run)

226 break;

227 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");

228 return AVERROR_INVALIDDATA;

229 }

230 pix_left -= run;

231 run = 0;

232 mode = !mode;

233 } else if ((int)t == -1) {

234 if (get_bits_left(gb) > 12 && show_bits(gb, 12) == 15) {

235 int ret;

236 skip_bits(gb, 12);

237 ret = decode_uncompressed(avctx, gb, &pix_left, &runs, runend, &mode);

238 if (ret < 0) {

239 return ret;

240 } else if (ret)

241 break;

242 } else {

243 av_log(avctx, AV_LOG_ERROR, "Incorrect code\n");

244 return AVERROR_INVALIDDATA;

245 }

246 }

247 }

248 *runs++ = 0;

249 return 0;

250 }

251

252 static int decode_group3_2d_line(AVCodecContext *avctx, GetBitContext *gb,

253 unsigned int width, int *runs,

254 const int *runend, const int *ref)

255 {

256 int mode = 0, saved_run = 0, t;

257 int run_off = *ref++;

258 unsigned int offs = 0, run = 0;

259

260 while (offs < width) {

261 int cmode;

262 if (get_bits_left(gb) <= 0)

263 return AVERROR_INVALIDDATA;

264 cmode = get_vlc2(gb, ccitt_group3_2d_vlc.table, 9, 1);

265 if (cmode == -1) {

266 av_log(avctx, AV_LOG_ERROR, "Incorrect mode VLC\n");

267 return AVERROR_INVALIDDATA;

268 }

269 if (!cmode) { //pass mode

270 if (run_off < width)

271 run_off += *ref++;

272 run = run_off - offs;

273 offs = run_off;

274 if (run_off < width)

275 run_off += *ref++;

276 if (offs > width) {

277 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");

278 return AVERROR_INVALIDDATA;

279 }

280 saved_run += run;

281 } else if (cmode == 1) { //horizontal mode

282 int k;

283 for (k = 0; k < 2; k++) {

284 run = 0;

285 for (;;) {

286 if (get_bits_left(gb) <= 0)

287 return AVERROR_INVALIDDATA;

288 t = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2);

289 if (t == -1) {

290 av_log(avctx, AV_LOG_ERROR, "Incorrect code\n");

291 return AVERROR_INVALIDDATA;

292 }

293 run += t;

294 if (t < 64)

295 break;

296 }

297 *runs++ = run + saved_run;

298 if (runs >= runend) {

299 av_log(avctx, AV_LOG_ERROR, "Run overrun\n");

300 return AVERROR_INVALIDDATA;

301 }

302 saved_run = 0;

303 offs += run;

304 if (offs > width || run > width) {

305 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");

306 return AVERROR_INVALIDDATA;

307 }

308 mode = !mode;

309 }

310 } else if (cmode == 9 || cmode == 10) {

311 int xxx;

312 if (get_bits_left(gb) < 3)

313 return AVERROR_INVALIDDATA;

314 xxx = get_bits(gb, 3);

315 if (cmode == 9 && xxx == 7) {

316 int ret;

317 int pix_left = width - offs;

318

319 if (saved_run) {

320 av_log(avctx, AV_LOG_ERROR, "saved run %d on entering uncompressed mode\n", saved_run);

321 return AVERROR_INVALIDDATA;

322 }

323 ret = decode_uncompressed(avctx, gb, &pix_left, &runs, runend, &mode);

324 offs = width - pix_left;

325 if (ret < 0) {

326 return ret;

327 } else if (ret)

328 break;

329 } else {

330 avpriv_report_missing_feature(avctx, "Special mode %d xxx=%d support", cmode, xxx);

331 return AVERROR_PATCHWELCOME;

332 }

333 } else { //vertical mode

334 run = run_off - offs + (cmode - 5);

335 run_off -= *--ref;

336 offs += run;

337 if (offs > width || run > width) {

338 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");

339 return AVERROR_INVALIDDATA;

340 }

341 *runs++ = run + saved_run;

342 if (runs >= runend) {

343 av_log(avctx, AV_LOG_ERROR, "Run overrun\n");

344 return AVERROR_INVALIDDATA;

345 }

346 saved_run = 0;

347 mode = !mode;

348 }

349 //sync line pointers

350 while (offs < width && run_off <= offs) {

351 run_off += *ref++;

352 run_off += *ref++;

353 }

354 }

355 *runs++ = saved_run;

356 if (saved_run) {

357 if (runs >= runend) {

358 av_log(avctx, AV_LOG_ERROR, "Run overrun\n");

359 return -1;

360 }

361 *runs++ = 0;

362 }

363 return 0;

364 }

365

366 static void put_line(uint8_t *dst, int size, int width, const int *runs)

367 {

368 PutBitContext pb;

369 int run, mode = ~0, pix_left = width, run_idx = 0;

370

371 init_put_bits(&pb, dst, size);

372 while (pix_left > 0) {

373 run = runs[run_idx++];

374 mode = ~mode;

375 pix_left -= run;

376 for (; run > 16; run -= 16)

377 put_sbits(&pb, 16, mode);

378 if (run)

379 put_sbits(&pb, run, mode);

380 }

381 flush_put_bits(&pb);

382 }

383

384 static int find_group3_syncmarker(GetBitContext *gb, int srcsize)

385 {

386 unsigned int state = -1;

387 srcsize -= get_bits_count(gb);

388 while (srcsize-- > 0) {

389 state += state + get_bits1(gb);

390 if ((state & 0xFFF) == 1)

391 return 0;

392 }

393 return -1;

394 }

395

396 int ff_ccitt_unpack(AVCodecContext *avctx, const uint8_t *src, int srcsize,

397 uint8_t *dst, int height, int stride,

398 enum TiffCompr compr, int opts)

399 {

400 int j;

401 GetBitContext gb;

402 int *runs, *ref = NULL, *runend;

403 int ret;

404 int runsize = avctx->width + 2;

405 int has_eol;

406

407 runs = av_malloc_array(runsize, sizeof(runs[0]));

408 ref = av_malloc_array(runsize, sizeof(ref[0]));

409 if (!runs || !ref) {

410 ret = AVERROR(ENOMEM);

411 goto fail;

412 }

413 ref[0] = avctx->width;

414 ref[1] = 0;

415 ref[2] = 0;

416 if ((ret = init_get_bits8(&gb, src, srcsize)) < 0)

417 goto fail;

418 has_eol = show_bits(&gb, 12) == 1 || show_bits(&gb, 16) == 1;

419

420 for (j = 0; j < height; j++) {

421 runend = runs + runsize;

422 if (compr == TIFF_G4) {

423 ret = decode_group3_2d_line(avctx, &gb, avctx->width, runs, runend,

424 ref);

425 if (ret < 0)

426 goto fail;

427 } else {

428 int g3d1 = (compr == TIFF_G3) && !(opts & 1);

429 if (compr != TIFF_CCITT_RLE &&

430 has_eol &&

431 find_group3_syncmarker(&gb, srcsize * 8) < 0)

432 break;

433 if (compr == TIFF_CCITT_RLE || g3d1 || get_bits1(&gb))

434 ret = decode_group3_1d_line(avctx, &gb, avctx->width, runs,

435 runend);

436 else

437 ret = decode_group3_2d_line(avctx, &gb, avctx->width, runs,

438 runend, ref);

439 if (compr == TIFF_CCITT_RLE)

440 align_get_bits(&gb);

441 }

442 if (avctx->err_recognition & AV_EF_EXPLODE && ret < 0)

443 goto fail;

444

445 if (ret < 0) {

446 put_line(dst, stride, avctx->width, ref);

447 } else {

448 put_line(dst, stride, avctx->width, runs);

449 FFSWAP(int *, runs, ref);

450 }

451 dst += stride;

452 }

453 ret = 0;

454 fail:

455 av_free(runs);

456 av_free(ref);

457 return ret;

458 }

ccitt_group3_2d_bits

static const uint8_t ccitt_group3_2d_bits[11]

Definition: faxcompr.c:90

ccitt_codes_lens

static const uint8_t ccitt_codes_lens[2][CCITT_SYMS]

Definition: faxcompr.c:70

stride

int stride

Definition: mace.c:144

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:850

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

thread.h

INIT_VLC_STATIC

#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)

Definition: vlc.h:120

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1324

put_sbits

static void put_sbits(PutBitContext *pb, int n, int32_t value)

Definition: put_bits.h:280

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:61

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:220

TIFF_CCITT_RLE

@ TIFF_CCITT_RLE

Definition: tiff.h:122

table

static const uint16_t table[]

Definition: prosumer.c:206

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:798

find_group3_syncmarker

static int find_group3_syncmarker(GetBitContext *gb, int srcsize)

Definition: faxcompr.c:384

ccitt_codes_bits

static const uint8_t ccitt_codes_bits[2][CCITT_SYMS]

Definition: faxcompr.c:46

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:468

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:380

ff_ccitt_unpack

int ff_ccitt_unpack(AVCodecContext *avctx, const uint8_t *src, int srcsize, uint8_t *dst, int height, int stride, enum TiffCompr compr, int opts)

unpack data compressed with CCITT Group 3 1/2-D or Group 4 method

Definition: faxcompr.c:396

VLC_TYPE

#define VLC_TYPE

Definition: vlc.h:24

fail

#define fail()

Definition: checkasm.h:127

GetBitContext

Definition: get_bits.h:62

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:175

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:678

width

#define width

TIFF_G4

@ TIFF_G4

Definition: tiff.h:124

get_bits.h

PutBitContext

Definition: put_bits.h:49

ff_ccitt_unpack_init

av_cold void ff_ccitt_unpack_init(void)

initialize unpacker code

Definition: faxcompr.c:122

opts

AVDictionary * opts

Definition: movenc.c:50

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:173

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

run

uint8_t run

Definition: svq3.c:203

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

src

#define src

Definition: vp8dsp.c:255

INIT_VLC_USE_NEW_STATIC

#define INIT_VLC_USE_NEW_STATIC

Definition: vlc.h:95

ff_init_vlc_sparse

int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)

Definition: bitstream.c:323

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: avcodec.h:1335

TIFF_G3

@ TIFF_G3

Definition: tiff.h:123

AVOnce

#define AVOnce

Definition: thread.h:172

ccitt_syms