FFmpeg: libavcodec/get_bits.h Source File

FFmpeg

[フレーム]

libavcodec

get_bits.h

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

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

19 */

21 /**

22 * @file

23 * bitstream reader API header.

24 */

26 #ifndef AVCODEC_GET_BITS_H

27 #define AVCODEC_GET_BITS_H

29 #include <stdint.h>

31 #include "libavutil/common.h"

32 #include "libavutil/intreadwrite.h"

33 #include "libavutil/log.h"

34 #include "libavutil/avassert.h"

35 #include "mathops.h"

37 /*

38 * Safe bitstream reading:

39 * optionally, the get_bits API can check to ensure that we

40 * don't read past input buffer boundaries. This is protected

41 * with CONFIG_SAFE_BITSTREAM_READER at the global level, and

42 * then below that with UNCHECKED_BITSTREAM_READER at the per-

43 * decoder level. This means that decoders that check internally

44 * can "#define UNCHECKED_BITSTREAM_READER 1" to disable

45 * overread checks.

46 * Boundary checking causes a minor performance penalty so for

47 * applications that won't want/need this, it can be disabled

48 * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".

49 */

50 #ifndef UNCHECKED_BITSTREAM_READER

51 #define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER

52 #endif

54 typedef struct GetBitContext {

55 const uint8_t *buffer, *buffer_end;

56 int index;

57 int size_in_bits;

58 int size_in_bits_plus8;

59 } GetBitContext;

61 #define VLC_TYPE int16_t

63 typedef struct VLC {

64 int bits;

65 VLC_TYPE (*table)[2]; ///< code, bits

66 int table_size, table_allocated;

67 } VLC;

69 typedef struct RL_VLC_ELEM {

70 int16_t level;

71 int8_t len;

72 uint8_t run;

73 } RL_VLC_ELEM;

75 /* Bitstream reader API docs:

76 * name

77 * arbitrary name which is used as prefix for the internal variables

78 *

79 * gb

80 * getbitcontext

81 *

82 * OPEN_READER(name, gb)

83 * load gb into local variables

84 *

85 * CLOSE_READER(name, gb)

86 * store local vars in gb

87 *

88 * UPDATE_CACHE(name, gb)

89 * Refill the internal cache from the bitstream.

90 * After this call at least MIN_CACHE_BITS will be available.

91 *

92 * GET_CACHE(name, gb)

93 * Will output the contents of the internal cache,

94 * next bit is MSB of 32 or 64 bit (FIXME 64bit).

95 *

96 * SHOW_UBITS(name, gb, num)

97 * Will return the next num bits.

98 *

99 * SHOW_SBITS(name, gb, num)

100 * Will return the next num bits and do sign extension.

101 *

102 * SKIP_BITS(name, gb, num)

103 * Will skip over the next num bits.

104 * Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.

105 *

106 * SKIP_CACHE(name, gb, num)

107 * Will remove the next num bits from the cache (note SKIP_COUNTER

108 * MUST be called before UPDATE_CACHE / CLOSE_READER).

109 *

110 * SKIP_COUNTER(name, gb, num)

111 * Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).

112 *

113 * LAST_SKIP_BITS(name, gb, num)

114 * Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.

115 *

116 * BITS_LEFT(name, gb)

117 * Return the number of bits left

118 *

119 * For examples see get_bits, show_bits, skip_bits, get_vlc.

120 */

121

122 #ifdef LONG_BITSTREAM_READER

123 # define MIN_CACHE_BITS 32

124 #else

125 # define MIN_CACHE_BITS 25

126 #endif

127

128 #define OPEN_READER_NOSIZE(name, gb) \

129 unsigned int name ## _index = (gb)->index; \

130 unsigned int av_unused name ## _cache

131

132 #if UNCHECKED_BITSTREAM_READER

133 #define OPEN_READER(name, gb) OPEN_READER_NOSIZE(name, gb)

134

135 #define BITS_AVAILABLE(name, gb) 1

136 #else

137 #define OPEN_READER(name, gb) \

138 OPEN_READER_NOSIZE(name, gb); \

139 unsigned int name ## _size_plus8 = (gb)->size_in_bits_plus8

140

141 #define BITS_AVAILABLE(name, gb) name ## _index < name ## _size_plus8

142 #endif

143

144 #define CLOSE_READER(name, gb) (gb)->index = name ## _index

145

146 # ifdef LONG_BITSTREAM_READER

147

148 # define UPDATE_CACHE_LE(name, gb) name ## _cache = \

149 AV_RL64((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)

150

151 # define UPDATE_CACHE_BE(name, gb) name ## _cache = \

152 AV_RB64((gb)->buffer + (name ## _index >> 3)) >> (32 - (name ## _index & 7))

153

154 #else

155

156 # define UPDATE_CACHE_LE(name, gb) name ## _cache = \

157 AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)

158

159 # define UPDATE_CACHE_BE(name, gb) name ## _cache = \

160 AV_RB32((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7)

161

162 #endif

163

164

165 #ifdef BITSTREAM_READER_LE

166

167 # define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)

168

169 # define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)

170

171 #else

172

173 # define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)

174

175 # define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)

176

177 #endif

178

179 #if UNCHECKED_BITSTREAM_READER

180 # define SKIP_COUNTER(name, gb, num) name ## _index += (num)

181 #else

182 # define SKIP_COUNTER(name, gb, num) \

183 name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))

184 #endif

185

186 #define BITS_LEFT(name, gb) ((int)((gb)->size_in_bits - name ## _index))

187

188 #define SKIP_BITS(name, gb, num) \

189 do { \

190 SKIP_CACHE(name, gb, num); \

191 SKIP_COUNTER(name, gb, num); \

192 } while (0)

193

194 #define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)

195

196 #define SHOW_UBITS_LE(name, gb, num) zero_extend(name ## _cache, num)

197 #define SHOW_SBITS_LE(name, gb, num) sign_extend(name ## _cache, num)

198

199 #define SHOW_UBITS_BE(name, gb, num) NEG_USR32(name ## _cache, num)

200 #define SHOW_SBITS_BE(name, gb, num) NEG_SSR32(name ## _cache, num)

201

202 #ifdef BITSTREAM_READER_LE

203 # define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)

204 # define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)

205 #else

206 # define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)

207 # define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)

208 #endif

209

210 #define GET_CACHE(name, gb) ((uint32_t) name ## _cache)

211

212 static inline int get_bits_count(const GetBitContext *s)

213 {

214 return s->index;

215 }

216

217 static inline void skip_bits_long(GetBitContext *s, int n)

218 {

219 #if UNCHECKED_BITSTREAM_READER

220 s->index += n;

221 #else

222 s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);

223 #endif

224 }

225

226 /**

227 * read mpeg1 dc style vlc (sign bit + mantissa with no MSB).

228 * if MSB not set it is negative

229 * @param n length in bits

230 */

231 static inline int get_xbits(GetBitContext *s, int n)

232 {

233 register int sign;

234 register int32_t cache;

235 OPEN_READER(re, s);

236 av_assert2(n>0 && n<=25);

237 UPDATE_CACHE(re, s);

238 cache = GET_CACHE(re, s);

239 sign = ~cache >> 31;

240 LAST_SKIP_BITS(re, s, n);

241 CLOSE_READER(re, s);

242 return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;

243 }

244

245 static inline int get_sbits(GetBitContext *s, int n)

246 {

247 register int tmp;

248 OPEN_READER(re, s);

249 av_assert2(n>0 && n<=25);

250 UPDATE_CACHE(re, s);

251 tmp = SHOW_SBITS(re, s, n);

252 LAST_SKIP_BITS(re, s, n);

253 CLOSE_READER(re, s);

254 return tmp;

255 }

256

257 /**

258 * Read 1-25 bits.

259 */

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

261 {

262 register int tmp;

263 OPEN_READER(re, s);

264 av_assert2(n>0 && n<=25);

265 UPDATE_CACHE(re, s);

266 tmp = SHOW_UBITS(re, s, n);

267 LAST_SKIP_BITS(re, s, n);

268 CLOSE_READER(re, s);

269 return tmp;

270 }

271

272 static inline unsigned int get_bits_le(GetBitContext *s, int n)

273 {

274 register int tmp;

275 OPEN_READER(re, s);

276 av_assert2(n>0 && n<=25);

277 UPDATE_CACHE_LE(re, s);

278 tmp = SHOW_UBITS_LE(re, s, n);

279 LAST_SKIP_BITS(re, s, n);

280 CLOSE_READER(re, s);

281 return tmp;

282 }

283

284 /**

285 * Show 1-25 bits.

286 */

287 static inline unsigned int show_bits(GetBitContext *s, int n)

288 {

289 register int tmp;

290 OPEN_READER_NOSIZE(re, s);

291 av_assert2(n>0 && n<=25);

292 UPDATE_CACHE(re, s);

293 tmp = SHOW_UBITS(re, s, n);

294 return tmp;

295 }

296

297 static inline void skip_bits(GetBitContext *s, int n)

298 {

299 OPEN_READER(re, s);

300 LAST_SKIP_BITS(re, s, n);

301 CLOSE_READER(re, s);

302 }

303

304 static inline unsigned int get_bits1(GetBitContext *s)

305 {

306 unsigned int index = s->index;

307 uint8_t result = s->buffer[index >> 3];

308 #ifdef BITSTREAM_READER_LE

309 result >>= index & 7;

310 result &= 1;

311 #else

312 result <<= index & 7;

313 result >>= 8 - 1;

314 #endif

315 #if !UNCHECKED_BITSTREAM_READER

316 if (s->index < s->size_in_bits_plus8)

317 #endif

318 index++;

319 s->index = index;

320

321 return result;

322 }

323

324 static inline unsigned int show_bits1(GetBitContext *s)

325 {

326 return show_bits(s, 1);

327 }

328

329 static inline void skip_bits1(GetBitContext *s)

330 {

331 skip_bits(s, 1);

332 }

333

334 /**

335 * Read 0-32 bits.

336 */

337 static inline unsigned int get_bits_long(GetBitContext *s, int n)

338 {

339 if (!n) {

340 return 0;

341 } else if (n <= MIN_CACHE_BITS) {

342 return get_bits(s, n);

343 } else {

344 #ifdef BITSTREAM_READER_LE

345 unsigned ret = get_bits(s, 16);

346 return ret | (get_bits(s, n - 16) << 16);

347 #else

348 unsigned ret = get_bits(s, 16) << (n - 16);

349 return ret | get_bits(s, n - 16);

350 #endif

351 }

352 }

353

354 /**

355 * Read 0-64 bits.

356 */

357 static inline uint64_t get_bits64(GetBitContext *s, int n)

358 {

359 if (n <= 32) {

360 return get_bits_long(s, n);

361 } else {

362 #ifdef BITSTREAM_READER_LE

363 uint64_t ret = get_bits_long(s, 32);

364 return ret | (uint64_t) get_bits_long(s, n - 32) << 32;

365 #else

366 uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;

367 return ret | get_bits_long(s, 32);

368 #endif

369 }

370 }

371

372 /**

373 * Read 0-32 bits as a signed integer.

374 */

375 static inline int get_sbits_long(GetBitContext *s, int n)

376 {

377 return sign_extend(get_bits_long(s, n), n);

378 }

379

380 /**

381 * Show 0-32 bits.

382 */

383 static inline unsigned int show_bits_long(GetBitContext *s, int n)

384 {

385 if (n <= MIN_CACHE_BITS) {

386 return show_bits(s, n);

387 } else {

388 GetBitContext gb = *s;

389 return get_bits_long(&gb, n);

390 }

391 }

392

393 static inline int check_marker(GetBitContext *s, const char *msg)

394 {

395 int bit = get_bits1(s);

396 if (!bit)

397 av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);

398

399 return bit;

400 }

401

402 /**

403 * Initialize GetBitContext.

404 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes

405 * larger than the actual read bits because some optimized bitstream

406 * readers read 32 or 64 bit at once and could read over the end

407 * @param bit_size the size of the buffer in bits

408 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.

409 */

410 static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,

411 int bit_size)

412 {

413 int buffer_size;

414 int ret = 0;

415

416 if (bit_size >= INT_MAX - 7 || bit_size < 0 || !buffer) {

417 bit_size = 0;

418 buffer = NULL;

419 ret = AVERROR_INVALIDDATA;

420 }

421

422 buffer_size = (bit_size + 7) >> 3;

423

424 s->buffer = buffer;

425 s->size_in_bits = bit_size;

426 s->size_in_bits_plus8 = bit_size + 8;

427 s->buffer_end = buffer + buffer_size;

428 s->index = 0;

429

430 return ret;

431 }

432

433 /**

434 * Initialize GetBitContext.

435 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes

436 * larger than the actual read bits because some optimized bitstream

437 * readers read 32 or 64 bit at once and could read over the end

438 * @param byte_size the size of the buffer in bytes

439 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.

440 */

441 static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,

442 int byte_size)

443 {

444 if (byte_size > INT_MAX / 8 || byte_size < 0)

445 byte_size = -1;

446 return init_get_bits(s, buffer, byte_size * 8);

447 }

448

449 static inline const uint8_t *align_get_bits(GetBitContext *s)

450 {

451 int n = -get_bits_count(s) & 7;

452 if (n)

453 skip_bits(s, n);

454 return s->buffer + (s->index >> 3);

455 }

456

457 #define init_vlc(vlc, nb_bits, nb_codes, \

458 bits, bits_wrap, bits_size, \

459 codes, codes_wrap, codes_size, \

460 flags) \

461 ff_init_vlc_sparse(vlc, nb_bits, nb_codes, \

462 bits, bits_wrap, bits_size, \

463 codes, codes_wrap, codes_size, \

464 NULL, 0, 0, flags)

465

466 int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,

467 const void *bits, int bits_wrap, int bits_size,

468 const void *codes, int codes_wrap, int codes_size,

469 const void *symbols, int symbols_wrap, int symbols_size,

470 int flags);

471 void ff_free_vlc(VLC *vlc);

472

473 #define INIT_VLC_LE 2

474 #define INIT_VLC_USE_NEW_STATIC 4

475

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

477 do { \

478 static VLC_TYPE table[static_size][2]; \

479 (vlc)->table = table; \

480 (vlc)->table_allocated = static_size; \

481 init_vlc(vlc, bits, a, b, c, d, e, f, g, INIT_VLC_USE_NEW_STATIC); \

482 } while (0)

483

484 /**

485 * If the vlc code is invalid and max_depth=1, then no bits will be removed.

486 * If the vlc code is invalid and max_depth>1, then the number of bits removed

487 * is undefined.

488 */

489 #define GET_VLC(code, name, gb, table, bits, max_depth) \

490 do { \

491 int n, nb_bits; \

492 unsigned int index; \

493 \

494 index = SHOW_UBITS(name, gb, bits); \

495 code = table[index][0]; \

496 n = table[index][1]; \

497 \

498 if (max_depth > 1 && n < 0) { \

499 LAST_SKIP_BITS(name, gb, bits); \

500 UPDATE_CACHE(name, gb); \

501 \

502 nb_bits = -n; \

503 \

504 index = SHOW_UBITS(name, gb, nb_bits) + code; \

505 code = table[index][0]; \

506 n = table[index][1]; \

507 if (max_depth > 2 && n < 0) { \

508 LAST_SKIP_BITS(name, gb, nb_bits); \

509 UPDATE_CACHE(name, gb); \

510 \

511 nb_bits = -n; \

512 \

513 index = SHOW_UBITS(name, gb, nb_bits) + code; \

514 code = table[index][0]; \

515 n = table[index][1]; \

516 } \

517 } \

518 SKIP_BITS(name, gb, n); \

519 } while (0)

520

521 #define GET_RL_VLC_INTERNAL(level, run, name, gb, table, bits, \

522 max_depth, need_update) \

523 do { \

524 int n, nb_bits; \

525 unsigned int index; \

526 \

527 index = SHOW_UBITS(name, gb, bits); \

528 level = table[index].level; \

529 n = table[index].len; \

530 \

531 if (max_depth > 1 && n < 0) { \

532 SKIP_BITS(name, gb, bits); \

533 if (need_update) { \

534 UPDATE_CACHE(name, gb); \

535 } \

536 \

537 nb_bits = -n; \

538 \

539 index = SHOW_UBITS(name, gb, nb_bits) + level; \

540 level = table[index].level; \

541 n = table[index].len; \

542 } \

543 run = table[index].run; \

544 SKIP_BITS(name, gb, n); \

545 } while (0)

546

547 /**

548 * Parse a vlc code.

549 * @param bits is the number of bits which will be read at once, must be

550 * identical to nb_bits in init_vlc()

551 * @param max_depth is the number of times bits bits must be read to completely

552 * read the longest vlc code

553 * = (max_vlc_length + bits - 1) / bits

554 */

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

556 int bits, int max_depth)

557 {

558 int code;

559

560 OPEN_READER(re, s);

561 UPDATE_CACHE(re, s);

562

563 GET_VLC(code, re, s, table, bits, max_depth);

564

565 CLOSE_READER(re, s);

566

567 return code;

568 }

569

570 static inline int decode012(GetBitContext *gb)

571 {

572 int n;

573 n = get_bits1(gb);

574 if (n == 0)

575 return 0;

576 else

577 return get_bits1(gb) + 1;

578 }

579

580 static inline int decode210(GetBitContext *gb)

581 {

582 if (get_bits1(gb))

583 return 0;

584 else

585 return 2 - get_bits1(gb);

586 }

587

588 static inline int get_bits_left(GetBitContext *gb)

589 {

590 return gb->size_in_bits - get_bits_count(gb);

591 }

592

593 static inline int skip_1stop_8data_bits(GetBitContext *gb)

594 {

595 if (get_bits_left(gb) <= 0)

596 return AVERROR_INVALIDDATA;

597

598 while (get_bits1(gb)) {

599 skip_bits(gb, 8);

600 if (get_bits_left(gb) <= 0)

601 return AVERROR_INVALIDDATA;

602 }

603

604 return 0;

605 }

606

607 //#define TRACE

608

609 #ifdef TRACE

610 static inline void print_bin(int bits, int n)

611 {

612 int i;

613

614 for (i = n - 1; i >= 0; i--)

615 av_log(NULL, AV_LOG_DEBUG, "%d", (bits >> i) & 1);

616 for (i = n; i < 24; i++)

617 av_log(NULL, AV_LOG_DEBUG, " ");

618 }

619

620 static inline int get_bits_trace(GetBitContext *s, int n, const char *file,

621 const char *func, int line)

622 {

623 int r = get_bits(s, n);

624

625 print_bin(r, n);

626 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n",

627 r, n, r, get_bits_count(s) - n, file, func, line);

628

629 return r;

630 }

631

632 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2],

633 int bits, int max_depth, const char *file,

634 const char *func, int line)

635 {

636 int show = show_bits(s, 24);

637 int pos = get_bits_count(s);

638 int r = get_vlc2(s, table, bits, max_depth);

639 int len = get_bits_count(s) - pos;

640 int bits2 = show >> (24 - len);

641

642 print_bin(bits2, len);

643

644 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n",

645 bits2, len, r, pos, file, func, line);

646

647 return r;

648 }

649

650 #define GET_RL_VLC(level, run, name, gb, table, bits, \

651 max_depth, need_update) \

652 do { \

653 int show = SHOW_UBITS(name, gb, 24); \

654 int len; \

655 int pos = name ## _index; \

656 \

657 GET_RL_VLC_INTERNAL(level, run, name, gb, table, bits,max_depth, need_update); \

658 \

659 len = name ## _index - pos + 1; \

660 show = show >> (24 - len); \

661 \

662 print_bin(show, len); \

663 \

664 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d/%-3d rlv @%5d in %s %s:%d\n",\

665 show, len, run-1, level, pos, __FILE__, __PRETTY_FUNCTION__, __LINE__);\

666 } while (0) \

667

668

669 static inline int get_xbits_trace(GetBitContext *s, int n, const char *file,

670 const char *func, int line)

671 {

672 int show = show_bits(s, n);

673 int r = get_xbits(s, n);

674

675 print_bin(show, n);

676 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n",

677 show, n, r, get_bits_count(s) - n, file, func, line);

678

679 return r;

680 }

681

682 #define get_bits(s, n) get_bits_trace(s , n, __FILE__, __PRETTY_FUNCTION__, __LINE__)

683 #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)

684 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)

685

686 #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)

687 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)

688

689 #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)

690

691 #else //TRACE

692 #define tprintf(p, ...) { }

693 #define GET_RL_VLC GET_RL_VLC_INTERNAL

694 #endif

695

696 #endif /* AVCODEC_GET_BITS_H */

Generated on Sun Mar 8 2015 02:34:52 for FFmpeg by doxygen 1.8.2