Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

get_bits/put_bits: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/11/head
Diego Biurrun 12 years ago
parent 570a4a0189
commit 4af5310d29
2 changed files with 192 additions and 177 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 288
      libavcodec/get_bits.h
  2. 81
      libavcodec/put_bits.h

288
libavcodec/get_bits.h
Unescape View File

@ -27,6 +27,7 @@
#define AVCODEC_GET_BITS_H #define AVCODEC_GET_BITS_H
#include <stdint.h> #include <stdint.h>
#include "libavutil/common.h" #include "libavutil/common.h"
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "libavutil/log.h" #include "libavutil/log.h"
@ -73,46 +74,48 @@ typedef struct RL_VLC_ELEM {
} RL_VLC_ELEM; } RL_VLC_ELEM;
/* Bitstream reader API docs: /* Bitstream reader API docs:
name * name
arbitrary name which is used as prefix for the internal variables * arbitrary name which is used as prefix for the internal variables
*
gb * gb
getbitcontext * getbitcontext
*
OPEN_READER(name, gb) * OPEN_READER(name, gb)
load gb into local variables * load gb into local variables
*
CLOSE_READER(name, gb) * CLOSE_READER(name, gb)
store local vars in gb * store local vars in gb
*
UPDATE_CACHE(name, gb) * UPDATE_CACHE(name, gb)
refill the internal cache from the bitstream * Refill the internal cache from the bitstream.
after this call at least MIN_CACHE_BITS will be available, * After this call at least MIN_CACHE_BITS will be available.
*
GET_CACHE(name, gb) * GET_CACHE(name, gb)
will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit) * Will output the contents of the internal cache,
* next bit is MSB of 32 or 64 bit (FIXME 64bit).
SHOW_UBITS(name, gb, num) *
will return the next num bits * SHOW_UBITS(name, gb, num)
* Will return the next num bits.
SHOW_SBITS(name, gb, num) *
will return the next num bits and do sign extension * SHOW_SBITS(name, gb, num)
* Will return the next num bits and do sign extension.
SKIP_BITS(name, gb, num) *
will skip over the next num bits * SKIP_BITS(name, gb, num)
note, this is equivalent to SKIP_CACHE; SKIP_COUNTER * Will skip over the next num bits.
* Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.
SKIP_CACHE(name, gb, num) *
will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER) * SKIP_CACHE(name, gb, num)
* Will remove the next num bits from the cache (note SKIP_COUNTER
SKIP_COUNTER(name, gb, num) * MUST be called before UPDATE_CACHE / CLOSE_READER).
will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS) *
* SKIP_COUNTER(name, gb, num)
LAST_SKIP_BITS(name, gb, num) * Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).
like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER *
* LAST_SKIP_BITS(name, gb, num)
for examples see get_bits, show_bits, skip_bits, get_vlc * Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.
*/ *
* For examples see get_bits, show_bits, skip_bits, get_vlc.
*/
#ifdef LONG_BITSTREAM_READER #ifdef LONG_BITSTREAM_READER
# define MIN_CACHE_BITS 32 # define MIN_CACHE_BITS 32
@ -122,57 +125,56 @@ for examples see get_bits, show_bits, skip_bits, get_vlc
#if UNCHECKED_BITSTREAM_READER #if UNCHECKED_BITSTREAM_READER
#define OPEN_READER(name, gb) \ #define OPEN_READER(name, gb) \
unsigned int name##_index = (gb)->index; \ unsigned int name ## _index = (gb)->index; \
unsigned int av_unused name##_cache = 0 unsigned int av_unused name ## _cache = 0
#define HAVE_BITS_REMAINING(name, gb) 1 #define HAVE_BITS_REMAINING(name, gb) 1
#else #else
#define OPEN_READER(name, gb) \ #define OPEN_READER(name, gb) \
unsigned int name##_index = (gb)->index; \ unsigned int name ## _index = (gb)->index; \
unsigned int av_unused name##_cache = 0; \ unsigned int av_unused name ## _cache = 0; \
unsigned int av_unused name##_size_plus8 = \ unsigned int av_unused name ## _size_plus8 = (gb)->size_in_bits_plus8
(gb)->size_in_bits_plus8
#define HAVE_BITS_REMAINING(name, gb) \ #define HAVE_BITS_REMAINING(name, gb) name ## _index < name ## _size_plus8
name##_index < name##_size_plus8
#endif #endif
#define CLOSE_READER(name, gb) (gb)->index = name##_index #define CLOSE_READER(name, gb) (gb)->index = name ## _index
#ifdef BITSTREAM_READER_LE #ifdef BITSTREAM_READER_LE
# ifdef LONG_BITSTREAM_READER # ifdef LONG_BITSTREAM_READER
# define UPDATE_CACHE(name, gb) name##_cache = \ # define UPDATE_CACHE(name, gb) name ## _cache = \
AV_RL64((gb)->buffer + (name##_index >> 3)) >> (name##_index & 7) AV_RL64((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
# else # else
# define UPDATE_CACHE(name, gb) name##_cache = \ # define UPDATE_CACHE(name, gb) name ## _cache = \
AV_RL32((gb)->buffer + (name##_index >> 3)) >> (name##_index & 7) AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
# endif # endif
# define SKIP_CACHE(name, gb, num) name##_cache >>= (num) # define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
#else #else
# ifdef LONG_BITSTREAM_READER # ifdef LONG_BITSTREAM_READER
# define UPDATE_CACHE(name, gb) name##_cache = \ # define UPDATE_CACHE(name, gb) name ## _cache = \
AV_RB64((gb)->buffer + (name##_index >> 3)) >> (32 - (name##_index & 7)) AV_RB64((gb)->buffer + (name ## _index >> 3)) >> (32 - (name ## _index & 7))
# else # else
# define UPDATE_CACHE(name, gb) name##_cache = \ # define UPDATE_CACHE(name, gb) name ## _cache = \
AV_RB32((gb)->buffer + (name##_index >> 3)) << (name##_index & 7) AV_RB32((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7)
# endif # endif
# define SKIP_CACHE(name, gb, num) name##_cache <<= (num) # define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
#endif #endif
#if UNCHECKED_BITSTREAM_READER #if UNCHECKED_BITSTREAM_READER
# define SKIP_COUNTER(name, gb, num) name##_index += (num) # define SKIP_COUNTER(name, gb, num) name ## _index += (num)
#else #else
# define SKIP_COUNTER(name, gb, num) \ # define SKIP_COUNTER(name, gb, num) \
name##_index = FFMIN(name##_size_plus8, name##_index + (num)) name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))
#endif #endif
#define SKIP_BITS(name, gb, num) do { \ #define SKIP_BITS(name, gb, num) \
do { \
SKIP_CACHE(name, gb, num); \ SKIP_CACHE(name, gb, num); \
SKIP_COUNTER(name, gb, num); \ SKIP_COUNTER(name, gb, num); \
} while (0) } while (0)
@ -180,21 +182,22 @@ for examples see get_bits, show_bits, skip_bits, get_vlc
#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num) #define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
#ifdef BITSTREAM_READER_LE #ifdef BITSTREAM_READER_LE
# define SHOW_UBITS(name, gb, num) zero_extend(name##_cache, num) # define SHOW_UBITS(name, gb, num) zero_extend(name ## _cache, num)
# define SHOW_SBITS(name, gb, num) sign_extend(name##_cache, num) # define SHOW_SBITS(name, gb, num) sign_extend(name ## _cache, num)
#else #else
# define SHOW_UBITS(name, gb, num) NEG_USR32(name##_cache, num) # define SHOW_UBITS(name, gb, num) NEG_USR32(name ## _cache, num)
# define SHOW_SBITS(name, gb, num) NEG_SSR32(name##_cache, num) # define SHOW_SBITS(name, gb, num) NEG_SSR32(name ## _cache, num)
#endif #endif
#define GET_CACHE(name, gb) ((uint32_t)name##_cache) #define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
static inline int get_bits_count(const GetBitContext *s) static inline int get_bits_count(const GetBitContext *s)
{ {
return s->index; return s->index;
} }
static inline void skip_bits_long(GetBitContext *s, int n){ static inline void skip_bits_long(GetBitContext *s, int n)
{
#if UNCHECKED_BITSTREAM_READER #if UNCHECKED_BITSTREAM_READER
s->index += n; s->index += n;
#else #else
@ -214,7 +217,7 @@ static inline int get_xbits(GetBitContext *s, int n)
OPEN_READER(re, s); OPEN_READER(re, s);
UPDATE_CACHE(re, s); UPDATE_CACHE(re, s);
cache = GET_CACHE(re, s); cache = GET_CACHE(re, s);
sign = ~cache >> 31; sign = ~cache >> 31;
LAST_SKIP_BITS(re, s, n); LAST_SKIP_BITS(re, s, n);
CLOSE_READER(re, s); CLOSE_READER(re, s);
return (NEG_USR32(sign ^ cache, n) ^ sign) - sign; return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
@ -268,10 +271,10 @@ static inline void skip_bits(GetBitContext *s, int n)
static inline unsigned int get_bits1(GetBitContext *s) static inline unsigned int get_bits1(GetBitContext *s)
{ {
unsigned int index = s->index; unsigned int index = s->index;
uint8_t result = s->buffer[index>>3]; uint8_t result = s->buffer[index >> 3];
#ifdef BITSTREAM_READER_LE #ifdef BITSTREAM_READER_LE
result >>= index & 7; result >>= index & 7;
result &= 1; result &= 1;
#else #else
result <<= index & 7; result <<= index & 7;
result >>= 8 - 1; result >>= 8 - 1;
@ -300,15 +303,15 @@ static inline void skip_bits1(GetBitContext *s)
*/ */
static inline unsigned int get_bits_long(GetBitContext *s, int n) static inline unsigned int get_bits_long(GetBitContext *s, int n)
{ {
if (n <= MIN_CACHE_BITS) if (n <= MIN_CACHE_BITS) {
return get_bits(s, n); return get_bits(s, n);
else { } else {
#ifdef BITSTREAM_READER_LE #ifdef BITSTREAM_READER_LE
int ret = get_bits(s, 16); int ret = get_bits(s, 16);
return ret | (get_bits(s, n-16) << 16); return ret | (get_bits(s, n - 16) << 16);
#else #else
int ret = get_bits(s, 16) << (n-16); int ret = get_bits(s, 16) << (n - 16);
return ret | get_bits(s, n-16); return ret | get_bits(s, n - 16);
#endif #endif
} }
} }
@ -323,9 +326,9 @@ static inline uint64_t get_bits64(GetBitContext *s, int n)
} else { } else {
#ifdef BITSTREAM_READER_LE #ifdef BITSTREAM_READER_LE
uint64_t ret = get_bits_long(s, 32); uint64_t ret = get_bits_long(s, 32);
return ret | (uint64_t)get_bits_long(s, n - 32) << 32; return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
#else #else
uint64_t ret = (uint64_t)get_bits_long(s, n - 32) << 32; uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
return ret | get_bits_long(s, 32); return ret | get_bits_long(s, 32);
#endif #endif
} }
@ -344,9 +347,9 @@ static inline int get_sbits_long(GetBitContext *s, int n)
*/ */
static inline unsigned int show_bits_long(GetBitContext *s, int n) static inline unsigned int show_bits_long(GetBitContext *s, int n)
{ {
if (n <= MIN_CACHE_BITS) if (n <= MIN_CACHE_BITS) {
return show_bits(s, n); return show_bits(s, n);
else { } else {
GetBitContext gb = *s; GetBitContext gb = *s;
return get_bits_long(&gb, n); return get_bits_long(&gb, n);
} }
@ -377,19 +380,20 @@ static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
if (bit_size > INT_MAX - 7 || bit_size < 0 || !buffer) { if (bit_size > INT_MAX - 7 || bit_size < 0 || !buffer) {
buffer_size = bit_size = 0; buffer_size = bit_size = 0;
buffer = NULL; buffer = NULL;
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
} }
buffer_size = (bit_size + 7) >> 3; buffer_size = (bit_size + 7) >> 3;
s->buffer = buffer; s->buffer = buffer;
s->size_in_bits = bit_size; s->size_in_bits = bit_size;
#if !UNCHECKED_BITSTREAM_READER #if !UNCHECKED_BITSTREAM_READER
s->size_in_bits_plus8 = bit_size + 8; s->size_in_bits_plus8 = bit_size + 8;
#endif #endif
s->buffer_end = buffer + buffer_size; s->buffer_end = buffer + buffer_size;
s->index = 0; s->index = 0;
return ret; return ret;
} }
@ -412,34 +416,36 @@ static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
static inline void align_get_bits(GetBitContext *s) static inline void align_get_bits(GetBitContext *s)
{ {
int n = -get_bits_count(s) & 7; int n = -get_bits_count(s) & 7;
if (n) skip_bits(s, n); if (n)
skip_bits(s, n);
} }
#define init_vlc(vlc, nb_bits, nb_codes, \ #define init_vlc(vlc, nb_bits, nb_codes, \
bits, bits_wrap, bits_size, \ bits, bits_wrap, bits_size, \
codes, codes_wrap, codes_size, \ codes, codes_wrap, codes_size, \
flags) \ flags) \
ff_init_vlc_sparse(vlc, nb_bits, nb_codes, \ ff_init_vlc_sparse(vlc, nb_bits, nb_codes, \
bits, bits_wrap, bits_size, \ bits, bits_wrap, bits_size, \
codes, codes_wrap, codes_size, \ codes, codes_wrap, codes_size, \
NULL, 0, 0, flags) NULL, 0, 0, flags)
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
const void *bits, int bits_wrap, int bits_size, const void *bits, int bits_wrap, int bits_size,
const void *codes, int codes_wrap, int codes_size, const void *codes, int codes_wrap, int codes_size,
const void *symbols, int symbols_wrap, int symbols_size, const void *symbols, int symbols_wrap, int symbols_size,
int flags); int flags);
#define INIT_VLC_LE 2
#define INIT_VLC_USE_NEW_STATIC 4
void ff_free_vlc(VLC *vlc); void ff_free_vlc(VLC *vlc);
#define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size) do { \ #define INIT_VLC_LE 2
static VLC_TYPE table[static_size][2]; \ #define INIT_VLC_USE_NEW_STATIC 4
(vlc)->table = table; \
(vlc)->table_allocated = static_size; \
init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC); \
} while (0)
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size) \
do { \
static VLC_TYPE table[static_size][2]; \
(vlc)->table = table; \
(vlc)->table_allocated = static_size; \
init_vlc(vlc, bits, a, b, c, d, e, f, g, INIT_VLC_USE_NEW_STATIC); \
} while (0)
/** /**
* If the vlc code is invalid and max_depth=1, then no bits will be removed. * If the vlc code is invalid and max_depth=1, then no bits will be removed.
@ -478,32 +484,32 @@ void ff_free_vlc(VLC *vlc);
SKIP_BITS(name, gb, n); \ SKIP_BITS(name, gb, n); \
} while (0) } while (0)
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update) \ #define GET_RL_VLC(level, run, name, gb, table, bits, \
do { \ max_depth, need_update) \
int n, nb_bits; \ do { \
unsigned int index; \ int n, nb_bits; \
\ unsigned int index; \
index = SHOW_UBITS(name, gb, bits); \ \
level = table[index].level; \ index = SHOW_UBITS(name, gb, bits); \
n = table[index].len; \ level = table[index].level; \
\ n = table[index].len; \
if (max_depth > 1 && n < 0) { \ \
SKIP_BITS(name, gb, bits); \ if (max_depth > 1 && n < 0) { \
if (need_update) { \ SKIP_BITS(name, gb, bits); \
UPDATE_CACHE(name, gb); \ if (need_update) { \
} \ UPDATE_CACHE(name, gb); \
\ } \
nb_bits = -n; \ \
\ nb_bits = -n; \
index = SHOW_UBITS(name, gb, nb_bits) + level; \ \
level = table[index].level; \ index = SHOW_UBITS(name, gb, nb_bits) + level; \
n = table[index].len; \ level = table[index].level; \
} \ n = table[index].len; \
run = table[index].run; \ } \
SKIP_BITS(name, gb, n); \ run = table[index].run; \
SKIP_BITS(name, gb, n); \
} while (0) } while (0)
/** /**
* Parse a vlc code. * Parse a vlc code.
* @param bits is the number of bits which will be read at once, must be * @param bits is the number of bits which will be read at once, must be
@ -523,6 +529,7 @@ static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
GET_VLC(code, re, s, table, bits, max_depth); GET_VLC(code, re, s, table, bits, max_depth);
CLOSE_READER(re, s); CLOSE_READER(re, s);
return code; return code;
} }
@ -556,9 +563,8 @@ static inline void print_bin(int bits, int n)
{ {
int i; int i;
for (i = n-1; i >= 0; i--) { for (i = n - 1; i >= 0; i--)
av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1); av_log(NULL, AV_LOG_DEBUG, "%d", (bits >> i) & 1);
}
for (i = n; i < 24; i++) for (i = n; i < 24; i++)
av_log(NULL, AV_LOG_DEBUG, " "); av_log(NULL, AV_LOG_DEBUG, " ");
} }
@ -570,9 +576,11 @@ static inline int get_bits_trace(GetBitContext *s, int n, const char *file,
print_bin(r, n); print_bin(r, n);
av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n", av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n",
r, n, r, get_bits_count(s)-n, file, func, line); r, n, r, get_bits_count(s) - n, file, func, line);
return r; return r;
} }
static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2],
int bits, int max_depth, const char *file, int bits, int max_depth, const char *file,
const char *func, int line) const char *func, int line)
@ -581,14 +589,16 @@ static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2],
int pos = get_bits_count(s); int pos = get_bits_count(s);
int r = get_vlc2(s, table, bits, max_depth); int r = get_vlc2(s, table, bits, max_depth);
int len = get_bits_count(s) - pos; int len = get_bits_count(s) - pos;
int bits2 = show >> (24-len); int bits2 = show >> (24 - len);
print_bin(bits2, len); print_bin(bits2, len);
av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n",
bits2, len, r, pos, file, func, line); bits2, len, r, pos, file, func, line);
return r; return r;
} }
static inline int get_xbits_trace(GetBitContext *s, int n, const char *file, static inline int get_xbits_trace(GetBitContext *s, int n, const char *file,
const char *func, int line) const char *func, int line)
{ {
@ -597,20 +607,22 @@ static inline int get_xbits_trace(GetBitContext *s, int n, const char *file,
print_bin(show, n); print_bin(show, n);
av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n", av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n",
show, n, r, get_bits_count(s)-n, file, func, line); show, n, r, get_bits_count(s) - n, file, func, line);
return r; return r;
} }
#define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) #define get_bits(s, n) get_bits_trace(s , n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__) #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__) #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__) #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
#else //TRACE #else //TRACE
#define tprintf(p, ...) {} #define tprintf(p, ...) { }
#endif #endif
#endif /* AVCODEC_GET_BITS_H */ #endif /* AVCODEC_GET_BITS_H */

81
libavcodec/put_bits.h
Unescape View File

@ -29,6 +29,7 @@
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include "libavutil/bswap.h" #include "libavutil/bswap.h"
#include "libavutil/common.h" #include "libavutil/common.h"
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
@ -49,19 +50,20 @@ typedef struct PutBitContext {
* @param buffer the buffer where to put bits * @param buffer the buffer where to put bits
* @param buffer_size the size in bytes of buffer * @param buffer_size the size in bytes of buffer
*/ */
static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size) static inline void init_put_bits(PutBitContext *s, uint8_t *buffer,
int buffer_size)
{ {
if(buffer_size < 0) { if (buffer_size < 0) {
buffer_size = 0; buffer_size = 0;
buffer = NULL; buffer = NULL;
} }
s->size_in_bits= 8*buffer_size; s->size_in_bits = 8 * buffer_size;
s->buf = buffer; s->buf = buffer;
s->buf_end = s->buf + buffer_size; s->buf_end = s->buf + buffer_size;
s->buf_ptr = s->buf; s->buf_ptr = s->buf;
s->bit_left=32; s->bit_left = 32;
s->bit_buf=0; s->bit_buf = 0;
} }
/** /**
@ -79,21 +81,21 @@ static inline void flush_put_bits(PutBitContext *s)
{ {
#ifndef BITSTREAM_WRITER_LE #ifndef BITSTREAM_WRITER_LE
if (s->bit_left < 32) if (s->bit_left < 32)
s->bit_buf<<= s->bit_left; s->bit_buf <<= s->bit_left;
#endif #endif
while (s->bit_left < 32) { while (s->bit_left < 32) {
/* XXX: should test end of buffer */ /* XXX: should test end of buffer */
#ifdef BITSTREAM_WRITER_LE #ifdef BITSTREAM_WRITER_LE
*s->buf_ptr++=s->bit_buf; *s->buf_ptr++ = s->bit_buf;
s->bit_buf>>=8; s->bit_buf >>= 8;
#else #else
*s->buf_ptr++=s->bit_buf >> 24; *s->buf_ptr++ = s->bit_buf >> 24;
s->bit_buf<<=8; s->bit_buf <<= 8;
#endif #endif
s->bit_left+=8; s->bit_left += 8;
} }
s->bit_left=32; s->bit_left = 32;
s->bit_buf=0; s->bit_buf = 0;
} }
#ifdef BITSTREAM_WRITER_LE #ifdef BITSTREAM_WRITER_LE
@ -111,7 +113,8 @@ void avpriv_align_put_bits(PutBitContext *s);
* *
* @param terminate_string 0-terminates the written string if value is 1 * @param terminate_string 0-terminates the written string if value is 1
*/ */
void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string); void avpriv_put_string(PutBitContext *pb, const char *string,
int terminate_string);
/** /**
* Copy the content of src to the bitstream. * Copy the content of src to the bitstream.
@ -132,7 +135,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
assert(n <= 31 && value < (1U << n)); assert(n <= 31 && value < (1U << n));
bit_buf = s->bit_buf; bit_buf = s->bit_buf;
bit_left = s->bit_left; bit_left = s->bit_left;
/* XXX: optimize */ /* XXX: optimize */
@ -140,26 +143,26 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
bit_buf |= value << (32 - bit_left); bit_buf |= value << (32 - bit_left);
if (n >= bit_left) { if (n >= bit_left) {
AV_WL32(s->buf_ptr, bit_buf); AV_WL32(s->buf_ptr, bit_buf);
s->buf_ptr+=4; s->buf_ptr += 4;
bit_buf = (bit_left==32)?0:value >> bit_left; bit_buf = (bit_left == 32) ? 0 : value >> bit_left;
bit_left+=32; bit_left += 32;
} }
bit_left-=n; bit_left -= n;
#else #else
if (n < bit_left) { if (n < bit_left) {
bit_buf = (bit_buf<<n) | value; bit_buf = (bit_buf << n) | value;
bit_left-=n; bit_left -= n;
} else { } else {
bit_buf<<=bit_left; bit_buf <<= bit_left;
bit_buf |= value >> (n - bit_left); bit_buf |= value >> (n - bit_left);
AV_WB32(s->buf_ptr, bit_buf); AV_WB32(s->buf_ptr, bit_buf);
s->buf_ptr+=4; s->buf_ptr += 4;
bit_left+=32 - n; bit_left += 32 - n;
bit_buf = value; bit_buf = value;
} }
#endif #endif
s->bit_buf = bit_buf; s->bit_buf = bit_buf;
s->bit_left = bit_left; s->bit_left = bit_left;
} }
@ -167,7 +170,7 @@ static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
{ {
assert(n >= 0 && n <= 31); assert(n >= 0 && n <= 31);
put_bits(pb, n, value & ((1<<n)-1)); put_bits(pb, n, value & ((1 << n) - 1));
} }
/** /**
@ -190,9 +193,9 @@ static void av_unused put_bits32(PutBitContext *s, uint32_t value)
* Return the pointer to the byte where the bitstream writer will put * Return the pointer to the byte where the bitstream writer will put
* the next bit. * the next bit.
*/ */
static inline uint8_t* put_bits_ptr(PutBitContext *s) static inline uint8_t *put_bits_ptr(PutBitContext *s)
{ {
return s->buf_ptr; return s->buf_ptr;
} }
/** /**
@ -201,9 +204,9 @@ static inline uint8_t* put_bits_ptr(PutBitContext *s)
*/ */
static inline void skip_put_bytes(PutBitContext *s, int n) static inline void skip_put_bytes(PutBitContext *s, int n)
{ {
assert((put_bits_count(s)&7)==0); assert((put_bits_count(s) & 7) == 0);
assert(s->bit_left==32); assert(s->bit_left == 32);
s->buf_ptr += n; s->buf_ptr += n;
} }
/** /**
@ -214,7 +217,7 @@ static inline void skip_put_bytes(PutBitContext *s, int n)
static inline void skip_put_bits(PutBitContext *s, int n) static inline void skip_put_bits(PutBitContext *s, int n)
{ {
s->bit_left -= n; s->bit_left -= n;
s->buf_ptr-= 4*(s->bit_left>>5); s->buf_ptr -= 4 * (s->bit_left >> 5);
s->bit_left &= 31; s->bit_left &= 31;
} }
@ -225,7 +228,7 @@ static inline void skip_put_bits(PutBitContext *s, int n)
*/ */
static inline void set_put_bits_buffer_size(PutBitContext *s, int size) static inline void set_put_bits_buffer_size(PutBitContext *s, int size)
{ {
s->buf_end= s->buf + size; s->buf_end = s->buf + size;
} }
#endif /* AVCODEC_PUT_BITS_H */ #endif /* AVCODEC_PUT_BITS_H */

Write Preview
Loading…
Cancel
Save