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"

36 #include "vlc.h"

38 /*

39 * Safe bitstream reading:

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

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

42 * with CONFIG_SAFE_BITSTREAM_READER at the global level, and

43 * then below that with UNCHECKED_BITSTREAM_READER at the per-

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

45 * can "#define UNCHECKED_BITSTREAM_READER 1" to disable

46 * overread checks.

47 * Boundary checking causes a minor performance penalty so for

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

49 * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".

50 */

51 #ifndef UNCHECKED_BITSTREAM_READER

52 #define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER

53 #endif

55 typedef struct GetBitContext {

56 const uint8_t *buffer, *buffer_end;

57 int index;

58 int size_in_bits;

59 int size_in_bits_plus8;

60 } GetBitContext;

62 /* Bitstream reader API docs:

63 * name

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

65 *

66 * gb

67 * getbitcontext

68 *

69 * OPEN_READER(name, gb)

70 * load gb into local variables

71 *

72 * CLOSE_READER(name, gb)

73 * store local vars in gb

74 *

75 * UPDATE_CACHE(name, gb)

76 * Refill the internal cache from the bitstream.

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

78 *

79 * GET_CACHE(name, gb)

80 * Will output the contents of the internal cache,

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

82 *

83 * SHOW_UBITS(name, gb, num)

84 * Will return the next num bits.

85 *

86 * SHOW_SBITS(name, gb, num)

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

88 *

89 * SKIP_BITS(name, gb, num)

90 * Will skip over the next num bits.

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

92 *

93 * SKIP_CACHE(name, gb, num)

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

95 * MUST be called before UPDATE_CACHE / CLOSE_READER).

96 *

97 * SKIP_COUNTER(name, gb, num)

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

99 *

100 * LAST_SKIP_BITS(name, gb, num)

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

102 *

103 * BITS_LEFT(name, gb)

104 * Return the number of bits left

105 *

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

107 */

108

109 #ifdef LONG_BITSTREAM_READER

110 # define MIN_CACHE_BITS 32

111 #else

112 # define MIN_CACHE_BITS 25

113 #endif

114

115 #define OPEN_READER_NOSIZE(name, gb) \

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

117 unsigned int av_unused name ## _cache

118

119 #if UNCHECKED_BITSTREAM_READER

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

121

122 #define BITS_AVAILABLE(name, gb) 1

123 #else

124 #define OPEN_READER(name, gb) \

125 OPEN_READER_NOSIZE(name, gb); \

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

127

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

129 #endif

130

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

132

133 # ifdef LONG_BITSTREAM_READER

134

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

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

137

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

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

140

141 #else

142

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

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

145

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

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

148

149 #endif

150

151

152 #ifdef BITSTREAM_READER_LE

153

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

155

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

157

158 #else

159

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

161

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

163

164 #endif

165

166 #if UNCHECKED_BITSTREAM_READER

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

168 #else

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

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

171 #endif

172

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

174

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

176 do { \

177 SKIP_CACHE(name, gb, num); \

178 SKIP_COUNTER(name, gb, num); \

179 } while (0)

180

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

182

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

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

185

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

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

188

189 #ifdef BITSTREAM_READER_LE

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

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

192 #else

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

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

195 #endif

196

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

198

199 static inline int get_bits_count(const GetBitContext *s)

200 {

201 return s->index;

202 }

203

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

205 {

206 #if UNCHECKED_BITSTREAM_READER

207 s->index += n;

208 #else

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

210 #endif

211 }

212

213 /**

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

215 * if MSB not set it is negative

216 * @param n length in bits

217 */

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

219 {

220 register int sign;

221 register int32_t cache;

222 OPEN_READER(re, s);

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

224 UPDATE_CACHE(re, s);

225 cache = GET_CACHE(re, s);

226 sign = ~cache >> 31;

227 LAST_SKIP_BITS(re, s, n);

228 CLOSE_READER(re, s);

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

230 }

231

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

233 {

234 register int tmp;

235 OPEN_READER(re, s);

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

237 UPDATE_CACHE(re, s);

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

239 LAST_SKIP_BITS(re, s, n);

240 CLOSE_READER(re, s);

241 return tmp;

242 }

243

244 /**

245 * Read 1-25 bits.

246 */

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

248 {

249 register int tmp;

250 OPEN_READER(re, s);

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

252 UPDATE_CACHE(re, s);

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

254 LAST_SKIP_BITS(re, s, n);

255 CLOSE_READER(re, s);

256 return tmp;

257 }

258

259 /**

260 * Read 0-25 bits.

261 */

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

263 {

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

265 }

266

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

268 {

269 register int tmp;

270 OPEN_READER(re, s);

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

272 UPDATE_CACHE_LE(re, s);

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

274 LAST_SKIP_BITS(re, s, n);

275 CLOSE_READER(re, s);

276 return tmp;

277 }

278

279 /**

280 * Show 1-25 bits.

281 */

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

283 {

284 register int tmp;

285 OPEN_READER_NOSIZE(re, s);

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

287 UPDATE_CACHE(re, s);

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

289 return tmp;

290 }

291

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

293 {

294 OPEN_READER(re, s);

295 LAST_SKIP_BITS(re, s, n);

296 CLOSE_READER(re, s);

297 }

298

299 static inline unsigned int get_bits1(GetBitContext *s)

300 {

301 unsigned int index = s->index;

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

303 #ifdef BITSTREAM_READER_LE

304 result >>= index & 7;

305 result &= 1;

306 #else

307 result <<= index & 7;

308 result >>= 8 - 1;

309 #endif

310 #if !UNCHECKED_BITSTREAM_READER

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

312 #endif

313 index++;

314 s->index = index;

315

316 return result;

317 }

318

319 static inline unsigned int show_bits1(GetBitContext *s)

320 {

321 return show_bits(s, 1);

322 }

323

324 static inline void skip_bits1(GetBitContext *s)

325 {

326 skip_bits(s, 1);

327 }

328

329 /**

330 * Read 0-32 bits.

331 */

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

333 {

334 if (!n) {

335 return 0;

336 } else if (n <= MIN_CACHE_BITS) {

337 return get_bits(s, n);

338 } else {

339 #ifdef BITSTREAM_READER_LE

340 unsigned ret = get_bits(s, 16);

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

342 #else

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

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

345 #endif

346 }

347 }

348

349 /**

350 * Read 0-64 bits.

351 */

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

353 {

354 if (n <= 32) {

355 return get_bits_long(s, n);

356 } else {

357 #ifdef BITSTREAM_READER_LE

358 uint64_t ret = get_bits_long(s, 32);

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

360 #else

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

362 return ret | get_bits_long(s, 32);

363 #endif

364 }

365 }

366

367 /**

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

369 */

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

371 {

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

373 }

374

375 /**

376 * Show 0-32 bits.

377 */

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

379 {

380 if (n <= MIN_CACHE_BITS) {

381 return show_bits(s, n);

382 } else {

383 GetBitContext gb = *s;

384 return get_bits_long(&gb, n);

385 }

386 }

387

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

389 {

390 int bit = get_bits1(s);

391 if (!bit)

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

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

394

395 return bit;

396 }

397

398 /**

399 * Initialize GetBitContext.

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

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

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

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

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

405 */

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

407 int bit_size)

408 {

409 int buffer_size;

410 int ret = 0;

411

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

413 bit_size = 0;

414 buffer = NULL;

415 ret = AVERROR_INVALIDDATA;

416 }

417

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

419

420 s->buffer = buffer;

421 s->size_in_bits = bit_size;

422 s->size_in_bits_plus8 = bit_size + 8;

423 s->buffer_end = buffer + buffer_size;

424 s->index = 0;

425

426 return ret;

427 }

428

429 /**

430 * Initialize GetBitContext.

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

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

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

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

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

436 */

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

438 int byte_size)

439 {

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

441 byte_size = -1;

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

443 }

444

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

446 {

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

448 if (n)

449 skip_bits(s, n);

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

451 }

452

453 /**

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

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

456 * is undefined.

457 */

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

459 do { \

460 int n, nb_bits; \

461 unsigned int index; \

462 \

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

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

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

466 \

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

468 LAST_SKIP_BITS(name, gb, bits); \

469 UPDATE_CACHE(name, gb); \

470 \

471 nb_bits = -n; \

472 \

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

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

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

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

477 LAST_SKIP_BITS(name, gb, nb_bits); \

478 UPDATE_CACHE(name, gb); \

479 \

480 nb_bits = -n; \

481 \

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

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

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

485 } \

486 } \

487 SKIP_BITS(name, gb, n); \

488 } while (0)

489

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

491 max_depth, need_update) \

492 do { \

493 int n, nb_bits; \

494 unsigned int index; \

495 \

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

497 level = table[index].level; \

498 n = table[index].len; \

499 \

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

501 SKIP_BITS(name, gb, bits); \

502 if (need_update) { \

503 UPDATE_CACHE(name, gb); \

504 } \

505 \

506 nb_bits = -n; \

507 \

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

509 level = table[index].level; \

510 n = table[index].len; \

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

512 LAST_SKIP_BITS(name, gb, nb_bits); \

513 if (need_update) { \

514 UPDATE_CACHE(name, gb); \

515 } \

516 nb_bits = -n; \

517 \

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

519 level = table[index].level; \

520 n = table[index].len; \

521 } \

522 } \

523 run = table[index].run; \

524 SKIP_BITS(name, gb, n); \

525 } while (0)

526

527 /**

528 * Parse a vlc code.

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

530 * identical to nb_bits in init_vlc()

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

532 * read the longest vlc code

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

534 */

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

536 int bits, int max_depth)

537 {

538 int code;

539

540 OPEN_READER(re, s);

541 UPDATE_CACHE(re, s);

542

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

544

545 CLOSE_READER(re, s);

546

547 return code;

548 }

549

550 static inline int decode012(GetBitContext *gb)

551 {

552 int n;

553 n = get_bits1(gb);

554 if (n == 0)

555 return 0;

556 else

557 return get_bits1(gb) + 1;

558 }

559

560 static inline int decode210(GetBitContext *gb)

561 {

562 if (get_bits1(gb))

563 return 0;

564 else

565 return 2 - get_bits1(gb);

566 }

567

568 static inline int get_bits_left(GetBitContext *gb)

569 {

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

571 }

572

573 static inline int skip_1stop_8data_bits(GetBitContext *gb)

574 {

575 if (get_bits_left(gb) <= 0)

576 return AVERROR_INVALIDDATA;

577

578 while (get_bits1(gb)) {

579 skip_bits(gb, 8);

580 if (get_bits_left(gb) <= 0)

581 return AVERROR_INVALIDDATA;

582 }

583

584 return 0;

585 }

586

587 #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:378

show_bits1

static unsigned int show_bits1(GetBitContext *s)

Definition: get_bits.h:319

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

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Definition: get_bits.h:204

check_marker

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

Definition: get_bits.h:388

vlc.h

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:56

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:232

get_sbits_long

static int get_sbits_long(GetBitContext *s, int n)

Read 0-32 bits as a signed integer.

Definition: get_bits.h:370

bits

uint8_t bits

Definition: crc.c:296

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

SHOW_UBITS_LE

#define SHOW_UBITS_LE(name, gb, num)

Definition: get_bits.h:183

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

get_bits64

static uint64_t get_bits64(GetBitContext *s, int n)

Read 0-64 bits.

Definition: get_bits.h:352

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:160

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

intreadwrite.h

NEG_USR32

#define NEG_USR32(a, s)

Definition: mathops.h:175

mathops.h

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:58

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

LAST_SKIP_BITS

#define LAST_SKIP_BITS(name, gb, num)

Definition: get_bits.h:181

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

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

SHOW_UBITS

#define SHOW_UBITS(name, gb, num)

Definition: get_bits.h:193

decode210

static int decode210(GetBitContext *gb)

Definition: get_bits.h:560

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

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:437

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

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:120

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:299

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:324

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:292

index

int index

Definition: gxfenc.c:89

UPDATE_CACHE_LE

#define UPDATE_CACHE_LE(name, gb)

Definition: get_bits.h:143

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:406

GET_CACHE

#define GET_CACHE(name, gb)

Definition: get_bits.h:197

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:332

MIN_CACHE_BITS

#define MIN_CACHE_BITS

Definition: get_bits.h:112

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:139

get_bits_le

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

Definition: get_bits.h:267

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:194

OPEN_READER_NOSIZE

#define OPEN_READER_NOSIZE(name, gb)

Definition: get_bits.h:115

GetBitContext

Definition: get_bits.h:55

common.h

common internal and external API header

GetBitContext::buffer_end

const uint8_t * buffer_end

Definition: get_bits.h:56

tmp

static uint8_t tmp[8]

Definition: des.c:38

decode012

static int decode012(GetBitContext *gb)

Definition: get_bits.h:550

log.h

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:445

GetBitContext::index

int index

Definition: get_bits.h:57

skip_1stop_8data_bits

static int skip_1stop_8data_bits(GetBitContext *gb)

Definition: get_bits.h:573

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

buffer

GLuint buffer

Definition: opengl_enc.c:102

Generated on Thu Oct 27 2016 19:33:24 for FFmpeg by doxygen 1.8.6