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 "avcodec.h"

36 #include "mathops.h"

37 #include "vlc.h"

39 /*

40 * Safe bitstream reading:

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

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

43 * with CONFIG_SAFE_BITSTREAM_READER at the global level, and

44 * then below that with UNCHECKED_BITSTREAM_READER at the per-

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

46 * can "#define UNCHECKED_BITSTREAM_READER 1" to disable

47 * overread checks.

48 * Boundary checking causes a minor performance penalty so for

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

50 * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".

51 */

52 #ifndef UNCHECKED_BITSTREAM_READER

53 #define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER

54 #endif

56 typedef struct GetBitContext {

57 const uint8_t *buffer, *buffer_end;

58 int index;

59 int size_in_bits;

60 int size_in_bits_plus8;

61 } GetBitContext;

63 /* Bitstream reader API docs:

64 * name

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

66 *

67 * gb

68 * getbitcontext

69 *

70 * OPEN_READER(name, gb)

71 * load gb into local variables

72 *

73 * CLOSE_READER(name, gb)

74 * store local vars in gb

75 *

76 * UPDATE_CACHE(name, gb)

77 * Refill the internal cache from the bitstream.

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

79 *

80 * GET_CACHE(name, gb)

81 * Will output the contents of the internal cache,

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

83 *

84 * SHOW_UBITS(name, gb, num)

85 * Will return the next num bits.

86 *

87 * SHOW_SBITS(name, gb, num)

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

89 *

90 * SKIP_BITS(name, gb, num)

91 * Will skip over the next num bits.

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

93 *

94 * SKIP_CACHE(name, gb, num)

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

96 * MUST be called before UPDATE_CACHE / CLOSE_READER).

97 *

98 * SKIP_COUNTER(name, gb, num)

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

100 *

101 * LAST_SKIP_BITS(name, gb, num)

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

103 *

104 * BITS_LEFT(name, gb)

105 * Return the number of bits left

106 *

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

108 */

109

110 #ifdef LONG_BITSTREAM_READER

111 # define MIN_CACHE_BITS 32

112 #else

113 # define MIN_CACHE_BITS 25

114 #endif

115

116 #define OPEN_READER_NOSIZE(name, gb) \

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

118 unsigned int av_unused name ## _cache

119

120 #if UNCHECKED_BITSTREAM_READER

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

122

123 #define BITS_AVAILABLE(name, gb) 1

124 #else

125 #define OPEN_READER(name, gb) \

126 OPEN_READER_NOSIZE(name, gb); \

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

128

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

130 #endif

131

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

133

134 # ifdef LONG_BITSTREAM_READER

135

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

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

138

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

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

141

142 #else

143

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

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

146

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

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

149

150 #endif

151

152

153 #ifdef BITSTREAM_READER_LE

154

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

156

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

158

159 #else

160

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

162

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

164

165 #endif

166

167 #if UNCHECKED_BITSTREAM_READER

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

169 #else

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

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

172 #endif

173

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

175

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

177 do { \

178 SKIP_CACHE(name, gb, num); \

179 SKIP_COUNTER(name, gb, num); \

180 } while (0)

181

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

183

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

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

186

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

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

189

190 #ifdef BITSTREAM_READER_LE

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

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

193 #else

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

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

196 #endif

197

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

199

200 static inline int get_bits_count(const GetBitContext *s)

201 {

202 return s->index;

203 }

204

205 /**

206 * Skips the specified number of bits.

207 * @param n the number of bits to skip,

208 * For the UNCHECKED_BITSTREAM_READER this must not cause the distance

209 * from the start to overflow int32_t. Staying within the bitstream + padding

210 * is sufficient, too.

211 */

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

213 {

214 #if UNCHECKED_BITSTREAM_READER

215 s->index += n;

216 #else

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

218 #endif

219 }

220

221 /**

222 * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).

223 * if MSB not set it is negative

224 * @param n length in bits

225 */

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

227 {

228 register int sign;

229 register int32_t cache;

230 OPEN_READER(re, s);

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

232 UPDATE_CACHE(re, s);

233 cache = GET_CACHE(re, s);

234 sign = ~cache >> 31;

235 LAST_SKIP_BITS(re, s, n);

236 CLOSE_READER(re, s);

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

238 }

239

240 static inline int get_xbits_le(GetBitContext *s, int n)

241 {

242 register int sign;

243 register int32_t cache;

244 OPEN_READER(re, s);

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

246 UPDATE_CACHE_LE(re, s);

247 cache = GET_CACHE(re, s);

248 sign = sign_extend(~cache, n) >> 31;

249 LAST_SKIP_BITS(re, s, n);

250 CLOSE_READER(re, s);

251 return (zero_extend(sign ^ cache, n) ^ sign) - sign;

252 }

253

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

255 {

256 register int tmp;

257 OPEN_READER(re, s);

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

259 UPDATE_CACHE(re, s);

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

261 LAST_SKIP_BITS(re, s, n);

262 CLOSE_READER(re, s);

263 return tmp;

264 }

265

266 /**

267 * Read 1-25 bits.

268 */

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

270 {

271 register int tmp;

272 OPEN_READER(re, s);

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

274 UPDATE_CACHE(re, s);

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

276 LAST_SKIP_BITS(re, s, n);

277 CLOSE_READER(re, s);

278 return tmp;

279 }

280

281 /**

282 * Read 0-25 bits.

283 */

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

285 {

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

287 }

288

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

290 {

291 register int tmp;

292 OPEN_READER(re, s);

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

294 UPDATE_CACHE_LE(re, s);

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

296 LAST_SKIP_BITS(re, s, n);

297 CLOSE_READER(re, s);

298 return tmp;

299 }

300

301 /**

302 * Show 1-25 bits.

303 */

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

305 {

306 register int tmp;

307 OPEN_READER_NOSIZE(re, s);

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

309 UPDATE_CACHE(re, s);

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

311 return tmp;

312 }

313

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

315 {

316 OPEN_READER(re, s);

317 LAST_SKIP_BITS(re, s, n);

318 CLOSE_READER(re, s);

319 }

320

321 static inline unsigned int get_bits1(GetBitContext *s)

322 {

323 unsigned int index = s->index;

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

325 #ifdef BITSTREAM_READER_LE

326 result >>= index & 7;

327 result &= 1;

328 #else

329 result <<= index & 7;

330 result >>= 8 - 1;

331 #endif

332 #if !UNCHECKED_BITSTREAM_READER

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

334 #endif

335 index++;

336 s->index = index;

337

338 return result;

339 }

340

341 static inline unsigned int show_bits1(GetBitContext *s)

342 {

343 return show_bits(s, 1);

344 }

345

346 static inline void skip_bits1(GetBitContext *s)

347 {

348 skip_bits(s, 1);

349 }

350

351 /**

352 * Read 0-32 bits.

353 */

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

355 {

356 av_assert2(n>=0 && n<=32);

357 if (!n) {

358 return 0;

359 } else if (n <= MIN_CACHE_BITS) {

360 return get_bits(s, n);

361 } else {

362 #ifdef BITSTREAM_READER_LE

363 unsigned ret = get_bits(s, 16);

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

365 #else

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

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

368 #endif

369 }

370 }

371

372 /**

373 * Read 0-64 bits.

374 */

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

376 {

377 if (n <= 32) {

378 return get_bits_long(s, n);

379 } else {

380 #ifdef BITSTREAM_READER_LE

381 uint64_t ret = get_bits_long(s, 32);

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

383 #else

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

385 return ret | get_bits_long(s, 32);

386 #endif

387 }

388 }

389

390 /**

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

392 */

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

394 {

395 // sign_extend(x, 0) is undefined

396 if (!n)

397 return 0;

398

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

400 }

401

402 /**

403 * Show 0-32 bits.

404 */

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

406 {

407 if (n <= MIN_CACHE_BITS) {

408 return show_bits(s, n);

409 } else {

410 GetBitContext gb = *s;

411 return get_bits_long(&gb, n);

412 }

413 }

414

415 static inline int check_marker(void *logctx, GetBitContext *s, const char *msg)

416 {

417 int bit = get_bits1(s);

418 if (!bit)

419 av_log(logctx, AV_LOG_INFO, "Marker bit missing at %d of %d %s\n",

420 get_bits_count(s) - 1, s->size_in_bits, msg);

421

422 return bit;

423 }

424

425 /**

426 * Initialize GetBitContext.

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

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

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

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

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

432 */

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

434 int bit_size)

435 {

436 int buffer_size;

437 int ret = 0;

438

439 if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) {

440 bit_size = 0;

441 buffer = NULL;

442 ret = AVERROR_INVALIDDATA;

443 }

444

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

446

447 s->buffer = buffer;

448 s->size_in_bits = bit_size;

449 s->size_in_bits_plus8 = bit_size + 8;

450 s->buffer_end = buffer + buffer_size;

451 s->index = 0;

452

453 return ret;

454 }

455

456 /**

457 * Initialize GetBitContext.

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

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

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

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

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

463 */

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

465 int byte_size)

466 {

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

468 byte_size = -1;

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

470 }

471

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

473 {

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

475 if (n)

476 skip_bits(s, n);

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

478 }

479

480 /**

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

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

483 * is undefined.

484 */

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

486 do { \

487 int n, nb_bits; \

488 unsigned int index; \

489 \

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

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

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

493 \

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

495 LAST_SKIP_BITS(name, gb, bits); \

496 UPDATE_CACHE(name, gb); \

497 \

498 nb_bits = -n; \

499 \

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

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

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

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

504 LAST_SKIP_BITS(name, gb, nb_bits); \

505 UPDATE_CACHE(name, gb); \

506 \

507 nb_bits = -n; \

508 \

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

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

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

512 } \

513 } \

514 SKIP_BITS(name, gb, n); \

515 } while (0)

516

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

518 max_depth, need_update) \

519 do { \

520 int n, nb_bits; \

521 unsigned int index; \

522 \

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

524 level = table[index].level; \

525 n = table[index].len; \

526 \

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

528 SKIP_BITS(name, gb, bits); \

529 if (need_update) { \

530 UPDATE_CACHE(name, gb); \

531 } \

532 \

533 nb_bits = -n; \

534 \

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

536 level = table[index].level; \

537 n = table[index].len; \

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

539 LAST_SKIP_BITS(name, gb, nb_bits); \

540 if (need_update) { \

541 UPDATE_CACHE(name, gb); \

542 } \

543 nb_bits = -n; \

544 \

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

546 level = table[index].level; \

547 n = table[index].len; \

548 } \

549 } \

550 run = table[index].run; \

551 SKIP_BITS(name, gb, n); \

552 } while (0)

553

554 /**

555 * Parse a vlc code.

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

557 * identical to nb_bits in init_vlc()

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

559 * read the longest vlc code

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

561 * @returns the code parsed or -1 if no vlc matches

562 */

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

564 int bits, int max_depth)

565 {

566 int code;

567

568 OPEN_READER(re, s);

569 UPDATE_CACHE(re, s);

570

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

572

573 CLOSE_READER(re, s);

574

575 return code;

576 }

577

578 static inline int decode012(GetBitContext *gb)

579 {

580 int n;

581 n = get_bits1(gb);

582 if (n == 0)

583 return 0;

584 else

585 return get_bits1(gb) + 1;

586 }

587

588 static inline int decode210(GetBitContext *gb)

589 {

590 if (get_bits1(gb))

591 return 0;

592 else

593 return 2 - get_bits1(gb);

594 }

595

596 static inline int get_bits_left(GetBitContext *gb)

597 {

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

599 }

600

601 static inline int skip_1stop_8data_bits(GetBitContext *gb)

602 {

603 if (get_bits_left(gb) <= 0)

604 return AVERROR_INVALIDDATA;

605

606 while (get_bits1(gb)) {

607 skip_bits(gb, 8);

608 if (get_bits_left(gb) <= 0)

609 return AVERROR_INVALIDDATA;

610 }

611

612 return 0;

613 }

614

615 #endif /* AVCODEC_GET_BITS_H */

get_xbits_le

static int get_xbits_le(GetBitContext *s, int n)

Definition: get_bits.h:240

show_bits_long

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

Show 0-32 bits.

Definition: get_bits.h:405

show_bits1

static unsigned int show_bits1(GetBitContext *s)

Definition: get_bits.h:341

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:768

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

float re

Definition: fft.c:82

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:269

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:212

check_marker

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

Definition: get_bits.h:415

vlc.h

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:57

zero_extend

static av_const unsigned zero_extend(unsigned val, unsigned bits)

Definition: mathops.h:139

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:254

get_sbits_long

static int get_sbits_long(GetBitContext *s, int n)

Read 0-32 bits as a signed integer.

Definition: get_bits.h:393

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

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:200

SHOW_UBITS_LE

#define SHOW_UBITS_LE(name, gb, num)

Definition: get_bits.h:184

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

get_bits64

static uint64_t get_bits64(GetBitContext *s, int n)

Read 0-64 bits.

Definition: get_bits.h:375

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:161

table

static const struct endianess table[]

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

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

intreadwrite.h

NEG_USR32

#define NEG_USR32(a, s)

Definition: mathops.h:166

mathops.h

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:59

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

LAST_SKIP_BITS

#define LAST_SKIP_BITS(name, gb, num)

Definition: get_bits.h:182

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

int n

Definition: avisynth_c.h:684

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

SHOW_UBITS

#define SHOW_UBITS(name, gb, num)

Definition: get_bits.h:194

decode210

static int decode210(GetBitContext *gb)

Definition: get_bits.h:588

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

avcodec.h

Libavcodec external API header.

GetBitContext::size_in_bits_plus8

int size_in_bits_plus8

Definition: get_bits.h:60

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:464

get_xbits

static int get_xbits(GetBitContext *s, int n)

Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).

Definition: get_bits.h:226

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:121

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:321

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:346

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:314

index

int index

Definition: gxfenc.c:89

UPDATE_CACHE_LE

#define UPDATE_CACHE_LE(name, gb)

Definition: get_bits.h:144

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:433

GET_CACHE

#define GET_CACHE(name, gb)

Definition: get_bits.h:198

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:354

MIN_CACHE_BITS

#define MIN_CACHE_BITS

Definition: get_bits.h:113

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:130

get_bits_le

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

Definition: get_bits.h:289

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:195

OPEN_READER_NOSIZE

#define OPEN_READER_NOSIZE(name, gb)

Definition: get_bits.h:116

GetBitContext

Definition: get_bits.h:56

common.h

common internal and external API header

GetBitContext::buffer_end

const uint8_t * buffer_end

Definition: get_bits.h:57

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Required number of additionally allocated bytes at the end of the input bitstream for decoding...

Definition: avcodec.h:773

decode012

static int decode012(GetBitContext *gb)

Definition: get_bits.h:578

log.h

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:472

GetBitContext::index

int index

Definition: get_bits.h:58

skip_1stop_8data_bits

static int skip_1stop_8data_bits(GetBitContext *gb)

Definition: get_bits.h:601

av_always_inline

#define av_always_inline

Definition: attributes.h:39

VLC_TYPE

#define VLC_TYPE

Definition: vlc.h:24

get_bitsz

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

Read 0-25 bits.

Definition: get_bits.h:284

buffer

GLuint buffer

Definition: opengl_enc.c:102

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

Generated on Sun May 13 2018 02:03:46 for FFmpeg by doxygen 1.8.6