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 /**

273 * Read 0-25 bits.

274 */

275 static av_always_inline int get_bitsz(GetBitContext *s, int n)

276 {

277 return n ? get_bits(s, n) : 0;

278 }

279

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

281 {

282 register int tmp;

283 OPEN_READER(re, s);

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

285 UPDATE_CACHE_LE(re, s);

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

287 LAST_SKIP_BITS(re, s, n);

288 CLOSE_READER(re, s);

289 return tmp;

290 }

291

292 /**

293 * Show 1-25 bits.

294 */

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

296 {

297 register int tmp;

298 OPEN_READER_NOSIZE(re, s);

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

300 UPDATE_CACHE(re, s);

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

302 return tmp;

303 }

304

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

306 {

307 OPEN_READER(re, s);

308 LAST_SKIP_BITS(re, s, n);

309 CLOSE_READER(re, s);

310 }

311

312 static inline unsigned int get_bits1(GetBitContext *s)

313 {

314 unsigned int index = s->index;

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

316 #ifdef BITSTREAM_READER_LE

317 result >>= index & 7;

318 result &= 1;

319 #else

320 result <<= index & 7;

321 result >>= 8 - 1;

322 #endif

323 #if !UNCHECKED_BITSTREAM_READER

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

325 #endif

326 index++;

327 s->index = index;

328

329 return result;

330 }

331

332 static inline unsigned int show_bits1(GetBitContext *s)

333 {

334 return show_bits(s, 1);

335 }

336

337 static inline void skip_bits1(GetBitContext *s)

338 {

339 skip_bits(s, 1);

340 }

341

342 /**

343 * Read 0-32 bits.

344 */

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

346 {

347 if (!n) {

348 return 0;

349 } else if (n <= MIN_CACHE_BITS) {

350 return get_bits(s, n);

351 } else {

352 #ifdef BITSTREAM_READER_LE

353 unsigned ret = get_bits(s, 16);

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

355 #else

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

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

358 #endif

359 }

360 }

361

362 /**

363 * Read 0-64 bits.

364 */

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

366 {

367 if (n <= 32) {

368 return get_bits_long(s, n);

369 } else {

370 #ifdef BITSTREAM_READER_LE

371 uint64_t ret = get_bits_long(s, 32);

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

373 #else

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

375 return ret | get_bits_long(s, 32);

376 #endif

377 }

378 }

379

380 /**

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

382 */

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

384 {

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

386 }

387

388 /**

389 * Show 0-32 bits.

390 */

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

392 {

393 if (n <= MIN_CACHE_BITS) {

394 return show_bits(s, n);

395 } else {

396 GetBitContext gb = *s;

397 return get_bits_long(&gb, n);

398 }

399 }

400

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

402 {

403 int bit = get_bits1(s);

404 if (!bit)

405 av_log(NULL, AV_LOG_INFO, "Marker bit missing at %d of %d %s\n", get_bits_count(s) - 1, s->size_in_bits, msg);

406

407 return bit;

408 }

409

410 /**

411 * Initialize GetBitContext.

412 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes

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

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

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

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

417 */

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

419 int bit_size)

420 {

421 int buffer_size;

422 int ret = 0;

423

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

425 bit_size = 0;

426 buffer = NULL;

427 ret = AVERROR_INVALIDDATA;

428 }

429

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

431

432 s->buffer = buffer;

433 s->size_in_bits = bit_size;

434 s->size_in_bits_plus8 = bit_size + 8;

435 s->buffer_end = buffer + buffer_size;

436 s->index = 0;

437

438 return ret;

439 }

440

441 /**

442 * Initialize GetBitContext.

443 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes

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

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

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

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

448 */

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

450 int byte_size)

451 {

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

453 byte_size = -1;

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

455 }

456

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

458 {

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

460 if (n)

461 skip_bits(s, n);

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

463 }

464

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

466 bits, bits_wrap, bits_size, \

467 codes, codes_wrap, codes_size, \

468 flags) \

469 ff_init_vlc_sparse(vlc, nb_bits, nb_codes, \

470 bits, bits_wrap, bits_size, \

471 codes, codes_wrap, codes_size, \

472 NULL, 0, 0, flags)

473

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

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

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

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

478 int flags);

479 void ff_free_vlc(VLC *vlc);

480

481 #define INIT_VLC_LE 2

482 #define INIT_VLC_USE_NEW_STATIC 4

483

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

485 do { \

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

487 (vlc)->table = table; \

488 (vlc)->table_allocated = static_size; \

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

490 } while (0)

491

492 /**

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

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

495 * is undefined.

496 */

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

498 do { \

499 int n, nb_bits; \

500 unsigned int index; \

501 \

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

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

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

505 \

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

507 LAST_SKIP_BITS(name, gb, bits); \

508 UPDATE_CACHE(name, gb); \

509 \

510 nb_bits = -n; \

511 \

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

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

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

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

516 LAST_SKIP_BITS(name, gb, nb_bits); \

517 UPDATE_CACHE(name, gb); \

518 \

519 nb_bits = -n; \

520 \

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

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

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

524 } \

525 } \

526 SKIP_BITS(name, gb, n); \

527 } while (0)

528

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

530 max_depth, need_update) \

531 do { \

532 int n, nb_bits; \

533 unsigned int index; \

534 \

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

536 level = table[index].level; \

537 n = table[index].len; \

538 \

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

540 SKIP_BITS(name, gb, bits); \

541 if (need_update) { \

542 UPDATE_CACHE(name, gb); \

543 } \

544 \

545 nb_bits = -n; \

546 \

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

548 level = table[index].level; \

549 n = table[index].len; \

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

551 LAST_SKIP_BITS(name, gb, nb_bits); \

552 if (need_update) { \

553 UPDATE_CACHE(name, gb); \

554 } \

555 nb_bits = -n; \

556 \

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

558 level = table[index].level; \

559 n = table[index].len; \

560 } \

561 } \

562 run = table[index].run; \

563 SKIP_BITS(name, gb, n); \

564 } while (0)

565

566 /**

567 * Parse a vlc code.

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

569 * identical to nb_bits in init_vlc()

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

571 * read the longest vlc code

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

573 */

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

575 int bits, int max_depth)

576 {

577 int code;

578

579 OPEN_READER(re, s);

580 UPDATE_CACHE(re, s);

581

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

583

584 CLOSE_READER(re, s);

585

586 return code;

587 }

588

589 static inline int decode012(GetBitContext *gb)

590 {

591 int n;

592 n = get_bits1(gb);

593 if (n == 0)

594 return 0;

595 else

596 return get_bits1(gb) + 1;

597 }

598

599 static inline int decode210(GetBitContext *gb)

600 {

601 if (get_bits1(gb))

602 return 0;

603 else

604 return 2 - get_bits1(gb);

605 }

606

607 static inline int get_bits_left(GetBitContext *gb)

608 {

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

610 }

611

612 static inline int skip_1stop_8data_bits(GetBitContext *gb)

613 {

614 if (get_bits_left(gb) <= 0)

615 return AVERROR_INVALIDDATA;

616

617 while (get_bits1(gb)) {

618 skip_bits(gb, 8);

619 if (get_bits_left(gb) <= 0)

620 return AVERROR_INVALIDDATA;

621 }

622

623 return 0;

624 }

625

626 //#define TRACE

627

628 #ifdef TRACE

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

630 {

631 int i;

632

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

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

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

636 av_log(NULL, AV_LOG_DEBUG, " ");

637 }

638

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

640 const char *func, int line)

641 {

642 int r = get_bits(s, n);

643

644 print_bin(r, n);

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

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

647

648 return r;

649 }

650

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

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

653 const char *func, int line)

654 {

655 int show = show_bits(s, 24);

656 int pos = get_bits_count(s);

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

658 int len = get_bits_count(s) - pos;

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

660

661 print_bin(bits2, len);

662

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

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

665

666 return r;

667 }

668

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

670 max_depth, need_update) \

671 do { \

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

673 int len; \

674 int pos = name ## _index; \

675 \

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

677 \

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

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

680 \

681 print_bin(show, len); \

682 \

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

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

685 } while (0) \

686

687

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

689 const char *func, int line)

690 {

691 int show = show_bits(s, n);

692 int r = get_xbits(s, n);

693

694 print_bin(show, n);

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

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

697

698 return r;

699 }

700

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

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

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

704

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

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

707 #else //TRACE

708 #define GET_RL_VLC GET_RL_VLC_INTERNAL

709 #endif

710

711 #endif /* AVCODEC_GET_BITS_H */

show_bits_long

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

Show 0-32 bits.

Definition: get_bits.h:391

show_bits1

static unsigned int show_bits1(GetBitContext *s)

Definition: get_bits.h:332

RL_VLC_ELEM

Definition: get_bits.h:69

NULL

#define NULL

Definition: coverity.c:32

VLC::table_size

int table_size

Definition: get_bits.h:66

const char * s

Definition: avisynth_c.h:631

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:260

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Definition: get_bits.h:217

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:55

VLC_TYPE

#define VLC_TYPE

Definition: get_bits.h:61

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:245

get_sbits_long

static int get_sbits_long(GetBitContext *s, int n)

Read 0-32 bits as a signed integer.

Definition: get_bits.h:383

bits

uint8_t bits

Definition: crc.c:295

uint8_t

Definition: audio_convert.c:194

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:63

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:212

bits2

static const uint8_t bits2[81]

Definition: aactab.c:130

SHOW_UBITS_LE

#define SHOW_UBITS_LE(name, gb, num)

Definition: get_bits.h:196

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:607

get_bits64

static uint64_t get_bits64(GetBitContext *s, int n)

Read 0-64 bits.

Definition: get_bits.h:365

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:173

ff_free_vlc

void ff_free_vlc(VLC *vlc)

Definition: bitstream.c:360

table

static const struct endianess table[]

const char * r

Definition: vf_curves.c:107

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

line

Definition: graph2dot.c:48

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

CLOSE_READER

#define CLOSE_READER(name, gb)

Definition: get_bits.h:144

RL_VLC_ELEM::len

int8_t len

Definition: get_bits.h:71

check_marker

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

Definition: get_bits.h:401

VLC

Definition: get_bits.h:63

ff_init_vlc_sparse

int ff_init_vlc_sparse(VLC *vlc, 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:275

intreadwrite.h

NEG_USR32

#define NEG_USR32(a, s)

Definition: mathops.h:174

mathops.h

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:57

int32_t

Definition: audio_convert.c:194

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:295

LAST_SKIP_BITS

#define LAST_SKIP_BITS(name, gb, num)

Definition: get_bits.h:194

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:574

int n

Definition: avisynth_c.h:547

GET_VLC

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

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

Definition: get_bits.h:497

SHOW_UBITS

#define SHOW_UBITS(name, gb, num)

Definition: get_bits.h:206

decode210

static int decode210(GetBitContext *gb)

Definition: get_bits.h:599

VLC::bits

int bits

Definition: get_bits.h:64

VLC::table_allocated

int table_allocated

Definition: get_bits.h:66

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

GetBitContext::size_in_bits_plus8

int size_in_bits_plus8

Definition: get_bits.h:58

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:449

get_xbits

static int get_xbits(GetBitContext *s, int n)

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

Definition: get_bits.h:231

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:133

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:312

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:337

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:305

index

int index

Definition: gxfenc.c:89

UPDATE_CACHE_LE

#define UPDATE_CACHE_LE(name, gb)

Definition: get_bits.h:156

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:418

GET_CACHE

#define GET_CACHE(name, gb)

Definition: get_bits.h:210

func

int(* func)(AVBPrint *dst, const char *in, const char *arg)

Definition: jacosubdec.c:67

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:345

MIN_CACHE_BITS

#define MIN_CACHE_BITS

Definition: get_bits.h:125

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:138

get_bits_le

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

Definition: get_bits.h:280

flags

static int flags

Definition: cpu.c:47

RL_VLC_ELEM::run

uint8_t run

Definition: get_bits.h:72

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:207

OPEN_READER_NOSIZE

#define OPEN_READER_NOSIZE(name, gb)

Definition: get_bits.h:128

GetBitContext

Definition: get_bits.h:54

common.h

common internal and external API header

GetBitContext::buffer_end

const uint8_t * buffer_end

Definition: get_bits.h:55

float re

Definition: fft-test.c:73

len

int len

Definition: vorbis_enc_data.h:452

decode012

static int decode012(GetBitContext *gb)

Definition: get_bits.h:589

VLC::table

VLC_TYPE(* table)[2]

code, bits

Definition: get_bits.h:65

log.h

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:457

RL_VLC_ELEM::level

int16_t level

Definition: get_bits.h:70

GetBitContext::index

int index

Definition: get_bits.h:56

skip_1stop_8data_bits

static int skip_1stop_8data_bits(GetBitContext *gb)

Definition: get_bits.h:612

av_always_inline

#define av_always_inline

Definition: attributes.h:39

get_bitsz

static av_always_inline int get_bitsz(GetBitContext *s, int n)

Read 0-25 bits.

Definition: get_bits.h:275

buffer

GLuint buffer

Definition: opengl_enc.c:102

Generated on Mon Feb 15 2016 15:20:38 for FFmpeg by doxygen 1.8.6