---
libavcodec/h264.c | 15 +--
libavcodec/h264.h | 13 ++-
libavcodec/h2645_parse.c | 21 ++--
libavcodec/h2645_parse.h | 4 +-
libavcodec/h264_cabac.c | 2 +
libavcodec/h264_cavlc.c | 167 ++++++++++++++-------------
libavcodec/h264_mb_template.c | 16 +--
libavcodec/h264_parse.c | 32 +++---
libavcodec/h264_parse.h | 6 +-
libavcodec/h264_parser.c | 64 +++++------
libavcodec/h264_ps.c | 260 +++++++++++++++++++++---------------------
libavcodec/h264_refs.c | 23 ++--
libavcodec/h264_sei.c | 192 +++++++++++++++----------------
libavcodec/h264_sei.h | 4 +-
libavcodec/h264_slice.c | 68 +++++------
libavcodec/vaapi_h264.c | 3 +-
16 files changed, 453 insertions(+), 437 deletions(-)
diff --git a/libavcodec/h264.c b/libavcodec/h264.c
index 224ba2f..9001fb1 100644
--- a/libavcodec/h264.c
+++ b/libavcodec/h264.c
@@ -31,6 +31,7 @@
#include "libavutil/stereo3d.h"
#include "libavutil/timer.h"
#include "internal.h"
+#include "bitstream.h"
#include "bytestream.h"
#include "cabac.h"
#include "cabac_functions.h"
@@ -777,7 +778,7 @@ static int get_last_needed_nal(H264Context *h)
for (i = 0; i < h->pkt.nb_nals; i++) {
H2645NAL *nal = &h->pkt.nals[i];
- GetBitContext gb;
+ BitstreamContext bc;
/* packets can sometimes contain multiple PPS/SPS,
* e.g. two PAFF field pictures in one packet, or a demuxer
@@ -791,8 +792,8 @@ static int get_last_needed_nal(H264Context *h)
case NAL_DPA:
case NAL_IDR_SLICE:
case NAL_SLICE:
- init_get_bits(&gb, nal->data + 1, (nal->size - 1) * 8);
- if (!get_ue_golomb(&gb))
+ bitstream_init8(&bc, nal->data + 1, (nal->size - 1));
+ if (!get_ue_golomb(&bc))
nals_needed = i;
}
}
@@ -849,7 +850,7 @@ static int decode_nal_units(H264Context *h, const uint8_t
*buf, int buf_size)
}
idr(h); // FIXME ensure we don't lose some frames if there is
reordering
case NAL_SLICE:
- sl->gb = nal->gb;
+ sl->bc = nal->bc;
if ((err = ff_h264_decode_slice_header(h, sl)))
break;
@@ -904,17 +905,17 @@ static int decode_nal_units(H264Context *h, const uint8_t
*buf, int buf_size)
goto end;
break;
case NAL_SEI:
- ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
+ ret = ff_h264_sei_decode(&h->sei, &nal->bc, &h->ps, avctx);
if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
goto end;
break;
case NAL_SPS:
- ret = ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps);
+ ret = ff_h264_decode_seq_parameter_set(&nal->bc, avctx, &h->ps);
if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
goto end;
break;
case NAL_PPS:
- ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
+ ret = ff_h264_decode_picture_parameter_set(&nal->bc, avctx, &h->ps,
nal->size_bits);
if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
goto end;
diff --git a/libavcodec/h264.h b/libavcodec/h264.h
index bfbcc81..238f98d 100644
--- a/libavcodec/h264.h
+++ b/libavcodec/h264.h
@@ -31,9 +31,10 @@
#include "libavutil/buffer.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/thread.h"
+
+#include "bitstream.h"
#include "cabac.h"
#include "error_resilience.h"
-#include "get_bits.h"
#include "h264_parse.h"
#include "h264_sei.h"
#include "h2645_parse.h"
@@ -300,7 +301,7 @@ typedef struct H264Ref {
typedef struct H264SliceContext {
struct H264Context *h264;
- GetBitContext gb;
+ BitstreamContext bc;
ERContext er;
int slice_num;
@@ -445,7 +446,7 @@ typedef struct H264Context {
H264DSPContext h264dsp;
H264ChromaContext h264chroma;
H264QpelContext h264qpel;
- GetBitContext gb;
+ BitstreamContext bc;
H264Picture DPB[H264_MAX_PICTURE_COUNT];
H264Picture *cur_pic_ptr;
@@ -637,13 +638,13 @@ extern const uint16_t ff_h264_mb_sizes[4];
/**
* Decode SPS
*/
-int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
+int ff_h264_decode_seq_parameter_set(BitstreamContext *bc, AVCodecContext
*avctx,
H264ParamSets *ps);
/**
* Decode PPS
*/
-int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext
*avctx,
+int ff_h264_decode_picture_parameter_set(BitstreamContext *bc, AVCodecContext
*avctx,
H264ParamSets *ps, int bit_length);
/**
@@ -666,7 +667,7 @@ void ff_h264_remove_all_refs(H264Context *h);
*/
int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int
mmco_count);
-int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb,
+int ff_h264_decode_ref_pic_marking(H264Context *h, BitstreamContext *bc,
int first_slice);
int ff_generate_sliding_window_mmcos(H264Context *h, int first_slice);
diff --git a/libavcodec/h2645_parse.c b/libavcodec/h2645_parse.c
index defe001..48d66e7 100644
--- a/libavcodec/h2645_parse.c
+++ b/libavcodec/h2645_parse.c
@@ -20,6 +20,7 @@
#include <string.h>
+#include "bitstream.h"
#include "config.h"
#include "libavutil/intmath.h"
@@ -158,16 +159,16 @@ static int get_bit_length(H2645NAL *nal, int
skip_trailing_zeros)
*/
static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
{
- GetBitContext *gb = &nal->gb;
+ BitstreamContext *bc = &nal->bc;
int nuh_layer_id;
- if (get_bits1(gb) != 0)
+ if (bitstream_read_bit(bc) != 0)
return AVERROR_INVALIDDATA;
- nal->type = get_bits(gb, 6);
+ nal->type = bitstream_read(bc, 6);
- nuh_layer_id = get_bits(gb, 6);
- nal->temporal_id = get_bits(gb, 3) - 1;
+ nuh_layer_id = bitstream_read(bc, 6);
+ nal->temporal_id = bitstream_read(bc, 3) - 1;
if (nal->temporal_id < 0)
return AVERROR_INVALIDDATA;
@@ -180,13 +181,13 @@ static int hevc_parse_nal_header(H2645NAL *nal, void
*logctx)
static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
{
- GetBitContext *gb = &nal->gb;
+ BitstreamContext *bc = &nal->bc;
- if (get_bits1(gb) != 0)
+ if (bitstream_read_bit(bc) != 0)
return AVERROR_INVALIDDATA;
- nal->ref_idc = get_bits(gb, 2);
- nal->type = get_bits(gb, 5);
+ nal->ref_idc = bitstream_read(bc, 2);
+ nal->type = bitstream_read(bc, 5);
av_log(logctx, AV_LOG_DEBUG,
"nal_unit_type: %d, nal_ref_idc: %d\n",
@@ -257,7 +258,7 @@ int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t
*buf, int length,
nal->size_bits = get_bit_length(nal, skip_trailing_zeros);
- ret = init_get_bits(&nal->gb, nal->data, nal->size_bits);
+ ret = bitstream_init(&nal->bc, nal->data, nal->size_bits);
if (ret < 0)
return ret;
diff --git a/libavcodec/h2645_parse.h b/libavcodec/h2645_parse.h
index 9cc4441..c30c001 100644
--- a/libavcodec/h2645_parse.h
+++ b/libavcodec/h2645_parse.h
@@ -24,7 +24,7 @@
#include <stdint.h>
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
typedef struct H2645NAL {
uint8_t *rbsp_buffer;
@@ -42,7 +42,7 @@ typedef struct H2645NAL {
int raw_size;
const uint8_t *raw_data;
- GetBitContext gb;
+ BitstreamContext bc;
/**
* NAL unit type
diff --git a/libavcodec/h264_cabac.c b/libavcodec/h264_cabac.c
index 5e7f3e7..1865064 100644
--- a/libavcodec/h264_cabac.c
+++ b/libavcodec/h264_cabac.c
@@ -30,6 +30,8 @@
#include "libavutil/attributes.h"
#include "libavutil/timer.h"
+
+#include "bitstream.h"
#include "config.h"
#include "cabac.h"
#include "cabac_functions.h"
diff --git a/libavcodec/h264_cavlc.c b/libavcodec/h264_cavlc.c
index 1a80f76..3e29ca5 100644
--- a/libavcodec/h264_cavlc.c
+++ b/libavcodec/h264_cavlc.c
@@ -29,11 +29,13 @@
#include "internal.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "h264.h"
#include "h264_mvpred.h"
#include "h264data.h"
#include "golomb.h"
#include "mpegutils.h"
+#include "vlc.h"
#include <assert.h>
@@ -412,22 +414,19 @@ av_cold void ff_h264_decode_init_vlc(void){
}
}
-static inline int get_level_prefix(GetBitContext *gb){
+static inline int get_level_prefix(BitstreamContext *bc)
+{
unsigned int buf;
int log;
- OPEN_READER(re, gb);
- UPDATE_CACHE(re, gb);
- buf=GET_CACHE(re, gb);
+ buf = bitstream_peek(bc, 32);
log= 32 - av_log2(buf);
#ifdef TRACE
- print_bin(buf>>(32-log), log);
- av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s
get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
+ av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s
get_level_prefix\n", buf>>(32-log), log, log-1, bitstream_tell(bc), __FILE__);
#endif
- LAST_SKIP_BITS(re, gb, log);
- CLOSE_READER(re, gb);
+ bitstream_skip(bc, log);
return log-1;
}
@@ -440,7 +439,7 @@ static inline int get_level_prefix(GetBitContext *gb){
* @return <0 if an error occurred
*/
static int decode_residual(const H264Context *h, H264SliceContext *sl,
- GetBitContext *gb, int16_t *block, int n,
+ BitstreamContext *bc, int16_t *block, int n,
const uint8_t *scantable, const uint32_t *qmul,
int max_coeff)
{
@@ -452,18 +451,22 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
if(max_coeff <= 8){
if (max_coeff == 4)
- coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table,
CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
+ coeff_token = bitstream_read_vlc(bc,
chroma_dc_coeff_token_vlc.table,
+ CHROMA_DC_COEFF_TOKEN_VLC_BITS,
1);
else
- coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table,
CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
+ coeff_token = bitstream_read_vlc(bc,
chroma422_dc_coeff_token_vlc.table,
+
CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
total_coeff= coeff_token>>2;
}else{
if(n >= LUMA_DC_BLOCK_INDEX){
total_coeff= pred_non_zero_count(h, sl, (n -
LUMA_DC_BLOCK_INDEX)*16);
- coeff_token= get_vlc2(gb, coeff_token_vlc[
coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
+ coeff_token = bitstream_read_vlc(bc,
coeff_token_vlc[coeff_token_table_index[total_coeff]].table,
+ COEFF_TOKEN_VLC_BITS, 2);
total_coeff= coeff_token>>2;
}else{
total_coeff= pred_non_zero_count(h, sl, n);
- coeff_token= get_vlc2(gb, coeff_token_vlc[
coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
+ coeff_token = bitstream_read_vlc(bc,
coeff_token_vlc[coeff_token_table_index[total_coeff]].table,
+ COEFF_TOKEN_VLC_BITS, 2);
total_coeff= coeff_token>>2;
}
}
@@ -482,8 +485,8 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
assert(total_coeff<=16);
- i = show_bits(gb, 3);
- skip_bits(gb, trailing_ones);
+ i = bitstream_peek(bc, 3);
+ bitstream_skip(bc, trailing_ones);
level[0] = 1-((i&4)>>1);
level[1] = 1-((i&2) );
level[2] = 1-((i&1)<<1);
@@ -491,28 +494,28 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
if(trailing_ones<total_coeff) {
int mask, prefix;
int suffix_length = total_coeff > 10 & trailing_ones < 3;
- int bitsi= show_bits(gb, LEVEL_TAB_BITS);
+ int bitsi = bitstream_peek(bc, LEVEL_TAB_BITS);
int level_code= cavlc_level_tab[suffix_length][bitsi][0];
- skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
+ bitstream_skip(bc, cavlc_level_tab[suffix_length][bitsi][1]);
if(level_code >= 100){
prefix= level_code - 100;
if(prefix == LEVEL_TAB_BITS)
- prefix += get_level_prefix(gb);
+ prefix += get_level_prefix(bc);
//first coefficient has suffix_length equal to 0 or 1
if(prefix<14){ //FIXME try to build a large unified VLC table for
all this
if(suffix_length)
- level_code= (prefix<<1) + get_bits1(gb); //part
+ level_code = (prefix << 1) + bitstream_read_bit(bc); //part
else
level_code= prefix; //part
}else if(prefix==14){
if(suffix_length)
- level_code= (prefix<<1) + get_bits1(gb); //part
+ level_code = (prefix << 1) + bitstream_read_bit(bc); //part
else
- level_code= prefix + get_bits(gb, 4); //part
+ level_code= prefix + bitstream_read(bc, 4); //part
}else{
- level_code= 30 + get_bits(gb, prefix-3); //part
+ level_code = 30 + bitstream_read(bc, prefix - 3); //part
if(prefix>=16){
if(prefix > 25+3){
av_log(h->avctx, AV_LOG_ERROR, "Invalid level
prefix\n");
@@ -537,19 +540,19 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
//remaining coefficients have suffix_length > 0
for(i=trailing_ones+1;i<total_coeff;i++) {
static const unsigned int suffix_limit[7] =
{0,3,6,12,24,48,INT_MAX };
- int bitsi= show_bits(gb, LEVEL_TAB_BITS);
+ int bitsi= bitstream_peek(bc, LEVEL_TAB_BITS);
level_code= cavlc_level_tab[suffix_length][bitsi][0];
- skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
+ bitstream_skip(bc, cavlc_level_tab[suffix_length][bitsi][1]);
if(level_code >= 100){
prefix= level_code - 100;
if(prefix == LEVEL_TAB_BITS){
- prefix += get_level_prefix(gb);
+ prefix += get_level_prefix(bc);
}
if(prefix<15){
- level_code = (prefix<<suffix_length) + get_bits(gb,
suffix_length);
+ level_code = (prefix << suffix_length) +
bitstream_read(bc, suffix_length);
}else{
- level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
+ level_code = (15 << suffix_length) + bitstream_read(bc,
prefix - 3);
if(prefix>=16)
level_code += (1<<(prefix-3))-4096;
}
@@ -566,13 +569,14 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
else{
if (max_coeff <= 8) {
if (max_coeff == 4)
- zeros_left = get_vlc2(gb,
chroma_dc_total_zeros_vlc[total_coeff - 1].table,
- CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
+ zeros_left = bitstream_read_vlc(bc,
chroma_dc_total_zeros_vlc[total_coeff - 1].table,
+
CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
else
- zeros_left = get_vlc2(gb,
chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
- CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
+ zeros_left = bitstream_read_vlc(bc,
chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
+
CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
} else {
- zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table,
TOTAL_ZEROS_VLC_BITS, 1);
+ zeros_left= bitstream_read_vlc(bc, total_zeros_vlc[total_coeff -
1].table,
+ TOTAL_ZEROS_VLC_BITS, 1);
}
}
@@ -582,9 +586,9 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
((type*)block)[*scantable] = level[0]; \
for(i=1;i<total_coeff && zeros_left > 0;i++) { \
if(zeros_left < 7) \
- run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table,
RUN_VLC_BITS, 1); \
+ run_before = bitstream_read_vlc(bc, run_vlc[zeros_left -
1].table, RUN_VLC_BITS, 1); \
else \
- run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
+ run_before = bitstream_read_vlc(bc, run7_vlc.table,
RUN7_VLC_BITS, 2); \
zeros_left -= run_before; \
scantable -= 1 + run_before; \
((type*)block)[*scantable]= level[i]; \
@@ -597,9 +601,9 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] +
32))>>6; \
for(i=1;i<total_coeff && zeros_left > 0;i++) { \
if(zeros_left < 7) \
- run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table,
RUN_VLC_BITS, 1); \
+ run_before = bitstream_read_vlc(bc, run_vlc[zeros_left -
1].table, RUN_VLC_BITS, 1); \
else \
- run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
+ run_before = bitstream_read_vlc(bc, run7_vlc.table,
RUN7_VLC_BITS, 2); \
zeros_left -= run_before; \
scantable -= 1 + run_before; \
((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] +
32))>>6; \
@@ -627,7 +631,7 @@ static int decode_residual(const H264Context *h,
H264SliceContext *sl,
static av_always_inline
int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
- GetBitContext *gb, const uint8_t *scan,
+ BitstreamContext *bc, const uint8_t *scan,
const uint8_t *scan8x8, int pixel_shift,
int mb_type, int cbp, int p)
{
@@ -638,7 +642,7 @@ int decode_luma_residual(const H264Context *h,
H264SliceContext *sl,
AV_ZERO128(sl->mb_luma_dc[p]+8);
AV_ZERO128(sl->mb_luma_dc[p]+16);
AV_ZERO128(sl->mb_luma_dc[p]+24);
- if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX
+ p, scan, NULL, 16) < 0) {
+ if (decode_residual(h, sl, bc, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX
+ p, scan, NULL, 16) < 0) {
return -1; //FIXME continue if partitioned and other return -1 too
}
@@ -648,7 +652,7 @@ int decode_luma_residual(const H264Context *h,
H264SliceContext *sl,
for(i8x8=0; i8x8<4; i8x8++){
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8 + p*16;
- if( decode_residual(h, sl, gb, sl->mb + (16*index <<
pixel_shift),
+ if (decode_residual(h, sl, bc, sl->mb + (16 * index <<
pixel_shift),
index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale],
15) < 0 ){
return -1;
}
@@ -670,7 +674,7 @@ int decode_luma_residual(const H264Context *h,
H264SliceContext *sl,
uint8_t *nnz;
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8 + p*16;
- if( decode_residual(h, sl, gb, buf, index,
scan8x8+16*i4x4,
+ if (decode_residual(h, sl, bc, buf, index, scan8x8 +
16 * i4x4,
h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
return -1;
}
@@ -680,7 +684,7 @@ int decode_luma_residual(const H264Context *h,
H264SliceContext *sl,
}else{
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8 + p*16;
- if( decode_residual(h, sl, gb, sl->mb + (16*index <<
pixel_shift), index,
+ if (decode_residual(h, sl, bc, sl->mb + (16 * index <<
pixel_shift), index,
scan,
h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
return -1;
}
@@ -711,12 +715,12 @@ int ff_h264_decode_mb_cavlc(const H264Context *h,
H264SliceContext *sl)
down the code */
if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
if (sl->mb_skip_run == -1)
- sl->mb_skip_run = get_ue_golomb(&sl->gb);
+ sl->mb_skip_run = get_ue_golomb(&sl->bc);
if (sl->mb_skip_run--) {
if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
if (sl->mb_skip_run == 0)
- sl->mb_mbaff = sl->mb_field_decoding_flag =
get_bits1(&sl->gb);
+ sl->mb_mbaff = sl->mb_field_decoding_flag =
bitstream_read_bit(&sl->bc);
}
decode_mb_skip(h, sl);
return 0;
@@ -724,12 +728,12 @@ int ff_h264_decode_mb_cavlc(const H264Context *h,
H264SliceContext *sl)
}
if (FRAME_MBAFF(h)) {
if ((sl->mb_y & 1) == 0)
- sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
+ sl->mb_mbaff = sl->mb_field_decoding_flag =
bitstream_read_bit(&sl->bc);
}
sl->prev_mb_skipped = 0;
- mb_type= get_ue_golomb(&sl->gb);
+ mb_type = get_ue_golomb(&sl->bc);
if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
if(mb_type < 23){
partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
@@ -771,12 +775,12 @@ decode_intra_mb:
h->ps.sps->bit_depth_luma;
// We assume these blocks are very rare so we do not optimize it.
- sl->intra_pcm_ptr = align_get_bits(&sl->gb);
- if (get_bits_left(&sl->gb) < mb_size) {
+ sl->intra_pcm_ptr = bitstream_align(&sl->bc);
+ if (bitstream_bits_left(&sl->bc) < mb_size) {
av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM
block.\n");
return AVERROR_INVALIDDATA;
}
- skip_bits_long(&sl->gb, mb_size);
+ bitstream_skip(&sl->bc, mb_size);
// In deblocking, the quantizer is 0
h->cur_pic.qscale_table[mb_xy] = 0;
@@ -797,7 +801,7 @@ decode_intra_mb:
if(IS_INTRA4x4(mb_type)){
int i;
int di = 1;
- if(dct8x8_allowed && get_bits1(&sl->gb)){
+ if(dct8x8_allowed && bitstream_read_bit(&sl->bc)){
mb_type |= MB_TYPE_8x8DCT;
di = 4;
}
@@ -806,8 +810,8 @@ decode_intra_mb:
for(i=0; i<16; i+=di){
int mode = pred_intra_mode(h, sl, i);
- if(!get_bits1(&sl->gb)){
- const int rem_mode= get_bits(&sl->gb, 3);
+ if(!bitstream_read_bit(&sl->bc)){
+ const int rem_mode= bitstream_read(&sl->bc, 3);
mode = rem_mode + (rem_mode >= mode);
}
@@ -828,7 +832,7 @@ decode_intra_mb:
}
if(decode_chroma){
pred_mode= ff_h264_check_intra_pred_mode(h->avctx,
sl->top_samples_available,
-
sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
+
sl->left_samples_available, get_ue_golomb_31(&sl->bc), 1);
if(pred_mode < 0)
return -1;
sl->chroma_pred_mode = pred_mode;
@@ -840,7 +844,7 @@ decode_intra_mb:
if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
for(i=0; i<4; i++){
- sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
+ sl->sub_mb_type[i] = get_ue_golomb_31(&sl->bc);
if(sl->sub_mb_type[i] >=13){
av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of
range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
return -1;
@@ -858,7 +862,7 @@ decode_intra_mb:
}else{
assert(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP
correct ?
for(i=0; i<4; i++){
- sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
+ sl->sub_mb_type[i] = get_ue_golomb_31(&sl->bc);
if(sl->sub_mb_type[i] >=4){
av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of
range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
return -1;
@@ -877,9 +881,9 @@ decode_intra_mb:
if(ref_count == 1){
tmp= 0;
}else if(ref_count == 2){
- tmp= get_bits1(&sl->gb)^1;
+ tmp = bitstream_read_bit(&sl->bc) ^ 1;
}else{
- tmp= get_ue_golomb_31(&sl->gb);
+ tmp = get_ue_golomb_31(&sl->bc);
if(tmp>=ref_count){
av_log(h->avctx, AV_LOG_ERROR, "ref %u
overflow\n", tmp);
return -1;
@@ -913,8 +917,8 @@ decode_intra_mb:
const int index= 4*i + block_width*j;
int16_t (* mv_cache)[2]= &sl->mv_cache[list][
scan8[index] ];
pred_motion(h, sl, index, block_width, list,
sl->ref_cache[list][ scan8[index] ], &mx, &my);
- mx += get_se_golomb(&sl->gb);
- my += get_se_golomb(&sl->gb);
+ mx += get_se_golomb(&sl->bc);
+ my += get_se_golomb(&sl->bc);
ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
if(IS_SUB_8X8(sub_mb_type)){
@@ -953,9 +957,9 @@ decode_intra_mb:
if (rc == 1) {
val= 0;
} else if (rc == 2) {
- val= get_bits1(&sl->gb)^1;
+ val = bitstream_read_bit(&sl->bc) ^ 1;
}else{
- val= get_ue_golomb_31(&sl->gb);
+ val = get_ue_golomb_31(&sl->bc);
if (val >= rc) {
av_log(h->avctx, AV_LOG_ERROR, "ref %u
overflow\n", val);
return -1;
@@ -967,8 +971,8 @@ decode_intra_mb:
for (list = 0; list < sl->list_count; list++) {
if(IS_DIR(mb_type, 0, list)){
pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][
scan8[0] ], &mx, &my);
- mx += get_se_golomb(&sl->gb);
- my += get_se_golomb(&sl->gb);
+ mx += get_se_golomb(&sl->bc);
+ my += get_se_golomb(&sl->bc);
ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8,
pack16to32(mx,my), 4);
@@ -984,9 +988,9 @@ decode_intra_mb:
if (rc == 1) {
val= 0;
} else if (rc == 2) {
- val= get_bits1(&sl->gb)^1;
+ val = bitstream_read_bit(&sl->bc) ^ 1;
}else{
- val= get_ue_golomb_31(&sl->gb);
+ val = get_ue_golomb_31(&sl->bc);
if (val >= rc) {
av_log(h->avctx, AV_LOG_ERROR, "ref %u
overflow\n", val);
return -1;
@@ -1002,8 +1006,8 @@ decode_intra_mb:
unsigned int val;
if(IS_DIR(mb_type, i, list)){
pred_16x8_motion(h, sl, 8*i, list,
sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
- mx += get_se_golomb(&sl->gb);
- my += get_se_golomb(&sl->gb);
+ mx += get_se_golomb(&sl->bc);
+ my += get_se_golomb(&sl->bc);
ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
val= pack16to32(mx,my);
@@ -1022,9 +1026,9 @@ decode_intra_mb:
if (rc == 1) {
val= 0;
} else if (rc == 2) {
- val= get_bits1(&sl->gb)^1;
+ val = bitstream_read_bit(&sl->bc) ^ 1;
}else{
- val= get_ue_golomb_31(&sl->gb);
+ val = get_ue_golomb_31(&sl->bc);
if (val >= rc) {
av_log(h->avctx, AV_LOG_ERROR, "ref %u
overflow\n", val);
return -1;
@@ -1040,8 +1044,8 @@ decode_intra_mb:
unsigned int val;
if(IS_DIR(mb_type, i, list)){
pred_8x16_motion(h, sl, i*4, list,
sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
- mx += get_se_golomb(&sl->gb);
- my += get_se_golomb(&sl->gb);
+ mx += get_se_golomb(&sl->bc);
+ my += get_se_golomb(&sl->bc);
ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
val= pack16to32(mx,my);
@@ -1057,7 +1061,7 @@ decode_intra_mb:
write_back_motion(h, sl, mb_type);
if(!IS_INTRA16x16(mb_type)){
- cbp= get_ue_golomb(&sl->gb);
+ cbp = get_ue_golomb(&sl->bc);
if(decode_chroma){
if(cbp > 47){
@@ -1079,7 +1083,7 @@ decode_intra_mb:
}
if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
- mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
+ mb_type |= MB_TYPE_8x8DCT * bitstream_read_bit(&sl->bc);
}
sl->cbp=
h->cbp_table[mb_xy]= cbp;
@@ -1089,7 +1093,7 @@ decode_intra_mb:
int i4x4, i8x8, chroma_idx;
int dquant;
int ret;
- GetBitContext *gb = &sl->gb;
+ BitstreamContext *bc = &sl->bc;
const uint8_t *scan, *scan8x8;
const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
@@ -1101,7 +1105,7 @@ decode_intra_mb:
scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
}
- dquant= get_se_golomb(&sl->gb);
+ dquant = get_se_golomb(&sl->bc);
sl->qscale += dquant;
@@ -1117,21 +1121,21 @@ decode_intra_mb:
sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
- if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift,
mb_type, cbp, 0)) < 0 ) {
+ if ((ret = decode_luma_residual(h, sl, bc, scan, scan8x8, pixel_shift,
mb_type, cbp, 0)) < 0 ) {
return -1;
}
h->cbp_table[mb_xy] |= ret << 12;
if (CHROMA444(h)) {
- if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift,
mb_type, cbp, 1) < 0 ) {
+ if (decode_luma_residual(h, sl, bc, scan, scan8x8, pixel_shift,
mb_type, cbp, 1) < 0 ) {
return -1;
}
- if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift,
mb_type, cbp, 2) < 0 ) {
+ if (decode_luma_residual(h, sl, bc, scan, scan8x8, pixel_shift,
mb_type, cbp, 2) < 0 ) {
return -1;
}
} else if (CHROMA422(h)) {
if(cbp&0x30){
for(chroma_idx=0; chroma_idx<2; chroma_idx++)
- if (decode_residual(h, sl, gb, sl->mb + ((256 +
16*16*chroma_idx) << pixel_shift),
+ if (decode_residual(h, sl, bc, sl->mb + ((256 +
16*16*chroma_idx) << pixel_shift),
CHROMA_DC_BLOCK_INDEX + chroma_idx,
ff_h264_chroma422_dc_scan,
NULL, 8) < 0) {
return -1;
@@ -1145,7 +1149,7 @@ decode_intra_mb:
for (i8x8 = 0; i8x8 < 2; i8x8++) {
for (i4x4 = 0; i4x4 < 4; i4x4++) {
const int index = 16 + 16*chroma_idx + 8*i8x8 +
i4x4;
- if (decode_residual(h, sl, gb, mb, index, scan +
1, qmul, 15) < 0)
+ if (decode_residual(h, sl, bc, mb, index, scan +
1, qmul, 15) < 0)
return -1;
mb += 16 << pixel_shift;
}
@@ -1158,7 +1162,7 @@ decode_intra_mb:
} else /* yuv420 */ {
if(cbp&0x30){
for(chroma_idx=0; chroma_idx<2; chroma_idx++)
- if (decode_residual(h, sl, gb, sl->mb + ((256 + 16 * 16 *
chroma_idx) << pixel_shift),
+ if (decode_residual(h, sl, bc, sl->mb + ((256 + 16 * 16 *
chroma_idx) << pixel_shift),
CHROMA_DC_BLOCK_INDEX + chroma_idx,
ff_h264_chroma_dc_scan, NULL, 4) < 0) {
return -1;
}
@@ -1169,7 +1173,8 @@ decode_intra_mb:
const uint32_t *qmul =
h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ?
0:3)][sl->chroma_qp[chroma_idx]];
for(i4x4=0; i4x4<4; i4x4++){
const int index= 16 + 16*chroma_idx + i4x4;
- if( decode_residual(h, sl, gb, sl->mb + (16*index <<
pixel_shift), index, scan + 1, qmul, 15) < 0){
+ if (decode_residual(h, sl, bc, sl->mb + (16 * index <<
pixel_shift),
+ index, scan + 1, qmul, 15) < 0){
return -1;
}
}
diff --git a/libavcodec/h264_mb_template.c b/libavcodec/h264_mb_template.c
index 1f583df..2be235d 100644
--- a/libavcodec/h264_mb_template.c
+++ b/libavcodec/h264_mb_template.c
@@ -99,14 +99,14 @@ static av_noinline void FUNC(hl_decode_mb)(const
H264Context *h, H264SliceContex
if (PIXEL_SHIFT) {
const int bit_depth = h->ps.sps->bit_depth_luma;
int j;
- GetBitContext gb;
- init_get_bits(&gb, sl->intra_pcm_ptr,
+ BitstreamContext bc;
+ bitstream_init(&bc, sl->intra_pcm_ptr,
ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
bit_depth);
for (i = 0; i < 16; i++) {
uint16_t *tmp_y = (uint16_t *)(dest_y + i * linesize);
for (j = 0; j < 16; j++)
- tmp_y[j] = get_bits(&gb, bit_depth);
+ tmp_y[j] = bitstream_read(&bc, bit_depth);
}
if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
if (!h->ps.sps->chroma_format_idc) {
@@ -124,12 +124,12 @@ static av_noinline void FUNC(hl_decode_mb)(const
H264Context *h, H264SliceContex
for (i = 0; i < block_h; i++) {
uint16_t *tmp_cb = (uint16_t *)(dest_cb + i *
uvlinesize);
for (j = 0; j < 8; j++)
- tmp_cb[j] = get_bits(&gb, bit_depth);
+ tmp_cb[j] = bitstream_read(&bc, bit_depth);
}
for (i = 0; i < block_h; i++) {
uint16_t *tmp_cr = (uint16_t *)(dest_cr + i *
uvlinesize);
for (j = 0; j < 8; j++)
- tmp_cr[j] = get_bits(&gb, bit_depth);
+ tmp_cr[j] = bitstream_read(&bc, bit_depth);
}
}
}
@@ -309,14 +309,14 @@ static av_noinline void FUNC(hl_decode_mb_444)(const
H264Context *h, H264SliceCo
if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
if (PIXEL_SHIFT) {
const int bit_depth = h->ps.sps->bit_depth_luma;
- GetBitContext gb;
- init_get_bits(&gb, sl->intra_pcm_ptr, 768 * bit_depth);
+ BitstreamContext bc;
+ bitstream_init(&bc, sl->intra_pcm_ptr, 768 * bit_depth);
for (p = 0; p < plane_count; p++)
for (i = 0; i < 16; i++) {
uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);
for (j = 0; j < 16; j++)
- tmp[j] = get_bits(&gb, bit_depth);
+ tmp[j] = bitstream_read(&bc, bit_depth);
}
} else {
for (p = 0; p < plane_count; p++)
diff --git a/libavcodec/h264_parse.c b/libavcodec/h264_parse.c
index 7211c9d..72cab2f 100644
--- a/libavcodec/h264_parse.c
+++ b/libavcodec/h264_parse.c
@@ -16,13 +16,13 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "bitstream.h"
#include "bytestream.h"
-#include "get_bits.h"
#include "golomb.h"
#include "h264.h"
#include "h264_parse.h"
-int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
+int ff_h264_pred_weight_table(BitstreamContext *bc, const SPS *sps,
const int *ref_count, int slice_type_nos,
H264PredWeightTable *pwt)
{
@@ -31,9 +31,9 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS
*sps,
pwt->use_weight = 0;
pwt->use_weight_chroma = 0;
- pwt->luma_log2_weight_denom = get_ue_golomb(gb);
+ pwt->luma_log2_weight_denom = get_ue_golomb(bc);
if (sps->chroma_format_idc)
- pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
+ pwt->chroma_log2_weight_denom = get_ue_golomb(bc);
luma_def = 1 << pwt->luma_log2_weight_denom;
chroma_def = 1 << pwt->chroma_log2_weight_denom;
@@ -43,10 +43,10 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS
*sps,
for (i = 0; i < ref_count[list]; i++) {
int luma_weight_flag, chroma_weight_flag;
- luma_weight_flag = get_bits1(gb);
+ luma_weight_flag = bitstream_read_bit(bc);
if (luma_weight_flag) {
- pwt->luma_weight[i][list][0] = get_se_golomb(gb);
- pwt->luma_weight[i][list][1] = get_se_golomb(gb);
+ pwt->luma_weight[i][list][0] = get_se_golomb(bc);
+ pwt->luma_weight[i][list][1] = get_se_golomb(bc);
if (pwt->luma_weight[i][list][0] != luma_def ||
pwt->luma_weight[i][list][1] != 0) {
pwt->use_weight = 1;
@@ -58,12 +58,12 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS
*sps,
}
if (sps->chroma_format_idc) {
- chroma_weight_flag = get_bits1(gb);
+ chroma_weight_flag = bitstream_read_bit(bc);
if (chroma_weight_flag) {
int j;
for (j = 0; j < 2; j++) {
- pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
- pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
+ pwt->chroma_weight[i][list][j][0] = get_se_golomb(bc);
+ pwt->chroma_weight[i][list][j][1] = get_se_golomb(bc);
if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
pwt->chroma_weight[i][list][j][1] != 0) {
pwt->use_weight_chroma = 1;
@@ -179,7 +179,7 @@ int ff_h264_check_intra_pred_mode(void *logctx, int
top_samples_available,
}
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2],
- GetBitContext *gb, const PPS *pps,
+ BitstreamContext *bc, const PPS *pps,
int slice_type_nos, int picture_structure)
{
int list_count;
@@ -190,14 +190,14 @@ int ff_h264_parse_ref_count(int *plist_count, int
ref_count[2],
ref_count[1] = pps->ref_count[1];
if (slice_type_nos != AV_PICTURE_TYPE_I) {
- num_ref_idx_active_override_flag = get_bits1(gb);
+ num_ref_idx_active_override_flag = bitstream_read_bit(bc);
if (num_ref_idx_active_override_flag) {
- ref_count[0] = get_ue_golomb(gb) + 1;
+ ref_count[0] = get_ue_golomb(bc) + 1;
if (ref_count[0] < 1)
goto fail;
if (slice_type_nos == AV_PICTURE_TYPE_B) {
- ref_count[1] = get_ue_golomb(gb) + 1;
+ ref_count[1] = get_ue_golomb(bc) + 1;
if (ref_count[1] < 1)
goto fail;
}
@@ -321,12 +321,12 @@ static int decode_extradata_ps(const uint8_t *data, int
size, H264ParamSets *ps,
H2645NAL *nal = &pkt.nals[i];
switch (nal->type) {
case NAL_SPS:
- ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps);
+ ret = ff_h264_decode_seq_parameter_set(&nal->bc, logctx, ps);
if (ret < 0)
goto fail;
break;
case NAL_PPS:
- ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps,
+ ret = ff_h264_decode_picture_parameter_set(&nal->bc, logctx, ps,
nal->size_bits);
if (ret < 0)
goto fail;
diff --git a/libavcodec/h264_parse.h b/libavcodec/h264_parse.h
index fde1a45..e1b112c 100644
--- a/libavcodec/h264_parse.h
+++ b/libavcodec/h264_parse.h
@@ -24,7 +24,7 @@
#ifndef AVCODEC_H264_PARSE_H
#define AVCODEC_H264_PARSE_H
-#include "get_bits.h"
+#include "bitstream.h"
typedef struct H264PredWeightTable {
int use_weight;
@@ -56,7 +56,7 @@ struct SPS;
struct PPS;
struct H264ParamSets;
-int ff_h264_pred_weight_table(GetBitContext *gb, const struct SPS *sps,
+int ff_h264_pred_weight_table(BitstreamContext *bc, const struct SPS *sps,
const int *ref_count, int slice_type_nos,
H264PredWeightTable *pwt);
@@ -76,7 +76,7 @@ int ff_h264_check_intra_pred_mode(void *logctx, int
top_samples_available,
int mode, int is_chroma);
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2],
- GetBitContext *gb, const struct PPS *pps,
+ BitstreamContext *bc, const struct PPS *pps,
int slice_type_nos, int picture_structure);
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc,
diff --git a/libavcodec/h264_parser.c b/libavcodec/h264_parser.c
index b86bf2b..bc9809a 100644
--- a/libavcodec/h264_parser.c
+++ b/libavcodec/h264_parser.c
@@ -34,7 +34,7 @@
#include "libavutil/mem.h"
#include "libavutil/pixfmt.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "golomb.h"
#include "h264.h"
#include "h264_sei.h"
@@ -112,7 +112,7 @@ found:
return i - (state & 5);
}
-static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,
+static int scan_mmco_reset(AVCodecParserContext *s, BitstreamContext *bc,
AVCodecContext *avctx)
{
H264PredWeightTable pwt;
@@ -122,25 +122,25 @@ static int scan_mmco_reset(AVCodecParserContext *s,
GetBitContext *gb,
if (p->ps.pps->redundant_pic_cnt_present)
- get_ue_golomb(gb); // redundant_pic_count
+ get_ue_golomb(bc); // redundant_pic_count
if (slice_type_nos == AV_PICTURE_TYPE_B)
- get_bits1(gb); // direct_spatial_mv_pred
+ bitstream_read_bit(bc); // direct_spatial_mv_pred
- if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps,
+ if (ff_h264_parse_ref_count(&list_count, ref_count, bc, p->ps.pps,
slice_type_nos, p->picture_structure) < 0)
return AVERROR_INVALIDDATA;
if (slice_type_nos != AV_PICTURE_TYPE_I) {
int list;
for (list = 0; list < list_count; list++) {
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
int index;
for (index = 0; ; index++) {
- unsigned int reordering_of_pic_nums_idc =
get_ue_golomb_31(gb);
+ unsigned int reordering_of_pic_nums_idc =
get_ue_golomb_31(bc);
if (reordering_of_pic_nums_idc < 3)
- get_ue_golomb(gb);
+ get_ue_golomb(bc);
else if (reordering_of_pic_nums_idc > 3) {
av_log(avctx, AV_LOG_ERROR,
"illegal reordering_of_pic_nums_idc %d\n",
@@ -161,13 +161,13 @@ static int scan_mmco_reset(AVCodecParserContext *s,
GetBitContext *gb,
if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
(p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos ==
AV_PICTURE_TYPE_B))
- ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
+ ff_h264_pred_weight_table(bc, p->ps.sps, ref_count, slice_type_nos,
&pwt);
- if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
+ if (bitstream_read_bit(bc)) { // adaptive_ref_pic_marking_mode_flag
int i;
for (i = 0; i < MAX_MMCO_COUNT; i++) {
- MMCOOpcode opcode = get_ue_golomb_31(gb);
+ MMCOOpcode opcode = get_ue_golomb_31(bc);
if (opcode > (unsigned) MMCO_LONG) {
av_log(avctx, AV_LOG_ERROR,
"illegal memory management control operation %d\n",
@@ -180,10 +180,10 @@ static int scan_mmco_reset(AVCodecParserContext *s,
GetBitContext *gb,
return 1;
if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)
- get_ue_golomb(gb);
+ get_ue_golomb(bc);
if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)
- get_ue_golomb_31(gb);
+ get_ue_golomb_31(bc);
}
}
@@ -252,23 +252,23 @@ static inline int parse_nal_units(AVCodecParserContext *s,
if (consumed < 0)
break;
- ret = init_get_bits(&nal.gb, nal.data, nal.size * 8);
+ ret = bitstream_init8(&nal.bc, nal.data, nal.size);
if (ret < 0)
goto fail;
- get_bits1(&nal.gb);
- nal.ref_idc = get_bits(&nal.gb, 2);
- nal.type = get_bits(&nal.gb, 5);
+ bitstream_read_bit(&nal.bc);
+ nal.ref_idc = bitstream_read(&nal.bc, 2);
+ nal.type = bitstream_read(&nal.bc, 5);
switch (nal.type) {
case NAL_SPS:
- ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps);
+ ff_h264_decode_seq_parameter_set(&nal.bc, avctx, &p->ps);
break;
case NAL_PPS:
- ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
+ ff_h264_decode_picture_parameter_set(&nal.bc, avctx, &p->ps,
nal.size_bits);
break;
case NAL_SEI:
- ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);
+ ff_h264_sei_decode(&p->sei, &nal.bc, &p->ps, avctx);
break;
case NAL_IDR_SLICE:
s->key_frame = 1;
@@ -279,14 +279,14 @@ static inline int parse_nal_units(AVCodecParserContext *s,
p->poc.prev_poc_lsb = 0;
/* fall through */
case NAL_SLICE:
- get_ue_golomb(&nal.gb); // skip first_mb_in_slice
- slice_type = get_ue_golomb_31(&nal.gb);
+ get_ue_golomb(&nal.bc); // skip first_mb_in_slice
+ slice_type = get_ue_golomb_31(&nal.bc);
s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
/* key frame, since recovery_frame_cnt is set */
s->key_frame = 1;
}
- pps_id = get_ue_golomb(&nal.gb);
+ pps_id = get_ue_golomb(&nal.bc);
if (pps_id >= MAX_PPS_COUNT) {
av_log(avctx, AV_LOG_ERROR,
"pps_id %u out of range\n", pps_id);
@@ -307,7 +307,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,
sps = p->ps.sps;
- p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
+ p->poc.frame_num = bitstream_read(&nal.bc,
sps->log2_max_frame_num);
s->coded_width = 16 * sps->mb_width;
s->coded_height = 16 * sps->mb_height;
@@ -344,30 +344,30 @@ static inline int parse_nal_units(AVCodecParserContext *s,
if (sps->frame_mbs_only_flag) {
p->picture_structure = PICT_FRAME;
} else {
- if (get_bits1(&nal.gb)) { // field_pic_flag
- p->picture_structure = PICT_TOP_FIELD +
get_bits1(&nal.gb); // bottom_field_flag
+ if (bitstream_read_bit(&nal.bc)) { // field_pic_flag
+ p->picture_structure = PICT_TOP_FIELD +
bitstream_read_bit(&nal.bc); // bottom_field_flag
} else {
p->picture_structure = PICT_FRAME;
}
}
if (nal.type == NAL_IDR_SLICE)
- get_ue_golomb(&nal.gb); /* idr_pic_id */
+ get_ue_golomb(&nal.bc); /* idr_pic_id */
if (sps->poc_type == 0) {
- p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
+ p->poc.poc_lsb = bitstream_read(&nal.bc,
sps->log2_max_poc_lsb);
if (p->ps.pps->pic_order_present == 1 &&
p->picture_structure == PICT_FRAME)
- p->poc.delta_poc_bottom = get_se_golomb(&nal.gb);
+ p->poc.delta_poc_bottom = get_se_golomb(&nal.bc);
}
if (sps->poc_type == 1 &&
!sps->delta_pic_order_always_zero_flag) {
- p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
+ p->poc.delta_poc[0] = get_se_golomb(&nal.bc);
if (p->ps.pps->pic_order_present == 1 &&
p->picture_structure == PICT_FRAME)
- p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
+ p->poc.delta_poc[1] = get_se_golomb(&nal.bc);
}
/* Decode POC of this picture.
@@ -381,7 +381,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,
* Maybe, we should parse all undisposable non-IDR slice of
this
* picture until encountering MMCO_RESET in a slice of it.
*/
if (nal.ref_idc && nal.type != NAL_IDR_SLICE) {
- got_reset = scan_mmco_reset(s, &nal.gb, avctx);
+ got_reset = scan_mmco_reset(s, &nal.bc, avctx);
if (got_reset < 0)
goto fail;
}
diff --git a/libavcodec/h264_ps.c b/libavcodec/h264_ps.c
index f6cd1ca..5fc1f0f 100644
--- a/libavcodec/h264_ps.c
+++ b/libavcodec/h264_ps.c
@@ -28,6 +28,8 @@
#include <inttypes.h>
#include "libavutil/imgutils.h"
+
+#include "bitstream.h"
#include "internal.h"
#include "mathops.h"
#include "avcodec.h"
@@ -126,45 +128,45 @@ static void remove_sps(H264ParamSets *s, int id)
av_buffer_unref(&s->sps_list[id]);
}
-static inline int decode_hrd_parameters(GetBitContext *gb, AVCodecContext
*avctx,
+static inline int decode_hrd_parameters(BitstreamContext *bc, AVCodecContext
*avctx,
SPS *sps)
{
int cpb_count, i;
- cpb_count = get_ue_golomb_31(gb) + 1;
+ cpb_count = get_ue_golomb_31(bc) + 1;
if (cpb_count > 32U) {
av_log(avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
return AVERROR_INVALIDDATA;
}
- get_bits(gb, 4); /* bit_rate_scale */
- get_bits(gb, 4); /* cpb_size_scale */
+ bitstream_read(bc, 4); /* bit_rate_scale */
+ bitstream_read(bc, 4); /* cpb_size_scale */
for (i = 0; i < cpb_count; i++) {
- get_ue_golomb_long(gb); /* bit_rate_value_minus1 */
- get_ue_golomb_long(gb); /* cpb_size_value_minus1 */
- get_bits1(gb); /* cbr_flag */
- }
- sps->initial_cpb_removal_delay_length = get_bits(gb, 5) + 1;
- sps->cpb_removal_delay_length = get_bits(gb, 5) + 1;
- sps->dpb_output_delay_length = get_bits(gb, 5) + 1;
- sps->time_offset_length = get_bits(gb, 5);
+ get_ue_golomb_long(bc); /* bit_rate_value_minus1 */
+ get_ue_golomb_long(bc); /* cpb_size_value_minus1 */
+ bitstream_read_bit(bc); /* cbr_flag */
+ }
+ sps->initial_cpb_removal_delay_length = bitstream_read(bc, 5) + 1;
+ sps->cpb_removal_delay_length = bitstream_read(bc, 5) + 1;
+ sps->dpb_output_delay_length = bitstream_read(bc, 5) + 1;
+ sps->time_offset_length = bitstream_read(bc, 5);
sps->cpb_cnt = cpb_count;
return 0;
}
-static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext
*avctx,
+static inline int decode_vui_parameters(BitstreamContext *bc, AVCodecContext
*avctx,
SPS *sps)
{
int aspect_ratio_info_present_flag;
unsigned int aspect_ratio_idc;
- aspect_ratio_info_present_flag = get_bits1(gb);
+ aspect_ratio_info_present_flag = bitstream_read_bit(bc);
if (aspect_ratio_info_present_flag) {
- aspect_ratio_idc = get_bits(gb, 8);
+ aspect_ratio_idc = bitstream_read(bc, 8);
if (aspect_ratio_idc == EXTENDED_SAR) {
- sps->sar.num = get_bits(gb, 16);
- sps->sar.den = get_bits(gb, 16);
+ sps->sar.num = bitstream_read(bc, 16);
+ sps->sar.den = bitstream_read(bc, 16);
} else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
sps->sar = pixel_aspect[aspect_ratio_idc];
} else {
@@ -176,19 +178,19 @@ static inline int decode_vui_parameters(GetBitContext
*gb, AVCodecContext *avctx
sps->sar.den = 0;
}
- if (get_bits1(gb)) /* overscan_info_present_flag */
- get_bits1(gb); /* overscan_appropriate_flag */
+ if (bitstream_read_bit(bc)) /* overscan_info_present_flag */
+ bitstream_read_bit(bc); /* overscan_appropriate_flag */
- sps->video_signal_type_present_flag = get_bits1(gb);
+ sps->video_signal_type_present_flag = bitstream_read_bit(bc);
if (sps->video_signal_type_present_flag) {
- get_bits(gb, 3); /* video_format */
- sps->full_range = get_bits1(gb); /* video_full_range_flag */
+ bitstream_read(bc, 3); /* video_format */
+ sps->full_range = bitstream_read_bit(bc); /* video_full_range_flag */
- sps->colour_description_present_flag = get_bits1(gb);
+ sps->colour_description_present_flag = bitstream_read_bit(bc);
if (sps->colour_description_present_flag) {
- sps->color_primaries = get_bits(gb, 8); /* colour_primaries */
- sps->color_trc = get_bits(gb, 8); /*
transfer_characteristics */
- sps->colorspace = get_bits(gb, 8); /* matrix_coefficients */
+ sps->color_primaries = bitstream_read(bc, 8); /* colour_primaries
*/
+ sps->color_trc = bitstream_read(bc, 8); /*
transfer_characteristics */
+ sps->colorspace = bitstream_read(bc, 8); /*
matrix_coefficients */
if (sps->color_primaries >= AVCOL_PRI_NB)
sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
if (sps->color_trc >= AVCOL_TRC_NB)
@@ -199,49 +201,49 @@ static inline int decode_vui_parameters(GetBitContext
*gb, AVCodecContext *avctx
}
/* chroma_location_info_present_flag */
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
/* chroma_sample_location_type_top_field */
- avctx->chroma_sample_location = get_ue_golomb(gb) + 1;
- get_ue_golomb(gb); /* chroma_sample_location_type_bottom_field */
+ avctx->chroma_sample_location = get_ue_golomb(bc) + 1;
+ get_ue_golomb(bc); /* chroma_sample_location_type_bottom_field */
}
- sps->timing_info_present_flag = get_bits1(gb);
+ sps->timing_info_present_flag = bitstream_read_bit(bc);
if (sps->timing_info_present_flag) {
- sps->num_units_in_tick = get_bits_long(gb, 32);
- sps->time_scale = get_bits_long(gb, 32);
+ sps->num_units_in_tick = bitstream_read(bc, 32);
+ sps->time_scale = bitstream_read(bc, 32);
if (!sps->num_units_in_tick || !sps->time_scale) {
av_log(avctx, AV_LOG_ERROR,
"time_scale/num_units_in_tick invalid or unsupported
(%"PRIu32"/%"PRIu32")\n",
sps->time_scale, sps->num_units_in_tick);
return AVERROR_INVALIDDATA;
}
- sps->fixed_frame_rate_flag = get_bits1(gb);
+ sps->fixed_frame_rate_flag = bitstream_read_bit(bc);
}
- sps->nal_hrd_parameters_present_flag = get_bits1(gb);
+ sps->nal_hrd_parameters_present_flag = bitstream_read_bit(bc);
if (sps->nal_hrd_parameters_present_flag)
- if (decode_hrd_parameters(gb, avctx, sps) < 0)
+ if (decode_hrd_parameters(bc, avctx, sps) < 0)
return AVERROR_INVALIDDATA;
- sps->vcl_hrd_parameters_present_flag = get_bits1(gb);
+ sps->vcl_hrd_parameters_present_flag = bitstream_read_bit(bc);
if (sps->vcl_hrd_parameters_present_flag)
- if (decode_hrd_parameters(gb, avctx, sps) < 0)
+ if (decode_hrd_parameters(bc, avctx, sps) < 0)
return AVERROR_INVALIDDATA;
if (sps->nal_hrd_parameters_present_flag ||
sps->vcl_hrd_parameters_present_flag)
- get_bits1(gb); /* low_delay_hrd_flag */
- sps->pic_struct_present_flag = get_bits1(gb);
+ bitstream_read_bit(bc); /* low_delay_hrd_flag */
+ sps->pic_struct_present_flag = bitstream_read_bit(bc);
- sps->bitstream_restriction_flag = get_bits1(gb);
+ sps->bitstream_restriction_flag = bitstream_read_bit(bc);
if (sps->bitstream_restriction_flag) {
- get_bits1(gb); /* motion_vectors_over_pic_boundaries_flag */
- get_ue_golomb(gb); /* max_bytes_per_pic_denom */
- get_ue_golomb(gb); /* max_bits_per_mb_denom */
- get_ue_golomb(gb); /* log2_max_mv_length_horizontal */
- get_ue_golomb(gb); /* log2_max_mv_length_vertical */
- sps->num_reorder_frames = get_ue_golomb(gb);
- get_ue_golomb(gb); /*max_dec_frame_buffering*/
-
- if (get_bits_left(gb) < 0) {
+ bitstream_read_bit(bc); /* motion_vectors_over_pic_boundaries_flag */
+ get_ue_golomb(bc); /* max_bytes_per_pic_denom */
+ get_ue_golomb(bc); /* max_bits_per_mb_denom */
+ get_ue_golomb(bc); /* log2_max_mv_length_horizontal */
+ get_ue_golomb(bc); /* log2_max_mv_length_vertical */
+ sps->num_reorder_frames = get_ue_golomb(bc);
+ get_ue_golomb(bc); /*max_dec_frame_buffering*/
+
+ if (bitstream_bits_left(bc) < 0) {
sps->num_reorder_frames = 0;
sps->bitstream_restriction_flag = 0;
}
@@ -255,27 +257,27 @@ static inline int decode_vui_parameters(GetBitContext
*gb, AVCodecContext *avctx
return AVERROR_INVALIDDATA;
}
}
- if (get_bits_left(gb) < 0) {
+ if (bitstream_bits_left(bc) < 0) {
av_log(avctx, AV_LOG_ERROR,
- "Overread VUI by %d bits\n", -get_bits_left(gb));
+ "Overread VUI by %d bits\n", -bitstream_bits_left(bc));
return AVERROR_INVALIDDATA;
}
return 0;
}
-static void decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
+static void decode_scaling_list(BitstreamContext *bc, uint8_t *factors, int
size,
const uint8_t *jvt_list,
const uint8_t *fallback_list)
{
int i, last = 8, next = 8;
const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
- if (!get_bits1(gb)) /* matrix not written, we use the predicted one */
+ if (!bitstream_read_bit(bc)) /* matrix not written, we use the predicted
one */
memcpy(factors, fallback_list, size * sizeof(uint8_t));
else
for (i = 0; i < size; i++) {
if (next)
- next = (last + get_se_golomb(gb)) & 0xff;
+ next = (last + get_se_golomb(bc)) & 0xff;
if (!i && !next) { /* matrix not written, we use the preset one */
memcpy(factors, jvt_list, size * sizeof(uint8_t));
break;
@@ -284,7 +286,7 @@ static void decode_scaling_list(GetBitContext *gb, uint8_t
*factors, int size,
}
}
-static void decode_scaling_matrices(GetBitContext *gb, SPS *sps,
+static void decode_scaling_matrices(BitstreamContext *bc, SPS *sps,
PPS *pps, int is_sps,
uint8_t(*scaling_matrix4)[16],
uint8_t(*scaling_matrix8)[64])
@@ -296,30 +298,30 @@ static void decode_scaling_matrices(GetBitContext *gb,
SPS *sps,
fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
};
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
sps->scaling_matrix_present |= is_sps;
- decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0],
fallback[0]); // Intra, Y
- decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0],
scaling_matrix4[0]); // Intra, Cr
- decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0],
scaling_matrix4[1]); // Intra, Cb
- decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1],
fallback[1]); // Inter, Y
- decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1],
scaling_matrix4[3]); // Inter, Cr
- decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1],
scaling_matrix4[4]); // Inter, Cb
+ decode_scaling_list(bc, scaling_matrix4[0], 16, default_scaling4[0],
fallback[0]); // Intra, Y
+ decode_scaling_list(bc, scaling_matrix4[1], 16, default_scaling4[0],
scaling_matrix4[0]); // Intra, Cr
+ decode_scaling_list(bc, scaling_matrix4[2], 16, default_scaling4[0],
scaling_matrix4[1]); // Intra, Cb
+ decode_scaling_list(bc, scaling_matrix4[3], 16, default_scaling4[1],
fallback[1]); // Inter, Y
+ decode_scaling_list(bc, scaling_matrix4[4], 16, default_scaling4[1],
scaling_matrix4[3]); // Inter, Cr
+ decode_scaling_list(bc, scaling_matrix4[5], 16, default_scaling4[1],
scaling_matrix4[4]); // Inter, Cb
if (is_sps || pps->transform_8x8_mode) {
- decode_scaling_list(gb, scaling_matrix8[0], 64,
default_scaling8[0], fallback[2]); // Intra, Y
+ decode_scaling_list(bc, scaling_matrix8[0], 64,
default_scaling8[0], fallback[2]); // Intra, Y
if (sps->chroma_format_idc == 3) {
- decode_scaling_list(gb, scaling_matrix8[1], 64,
default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
- decode_scaling_list(gb, scaling_matrix8[2], 64,
default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
+ decode_scaling_list(bc, scaling_matrix8[1], 64,
default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
+ decode_scaling_list(bc, scaling_matrix8[2], 64,
default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
}
- decode_scaling_list(gb, scaling_matrix8[3], 64,
default_scaling8[1], fallback[3]); // Inter, Y
+ decode_scaling_list(bc, scaling_matrix8[3], 64,
default_scaling8[1], fallback[3]); // Inter, Y
if (sps->chroma_format_idc == 3) {
- decode_scaling_list(gb, scaling_matrix8[4], 64,
default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
- decode_scaling_list(gb, scaling_matrix8[5], 64,
default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
+ decode_scaling_list(bc, scaling_matrix8[4], 64,
default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
+ decode_scaling_list(bc, scaling_matrix8[5], 64,
default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
}
}
}
}
-int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
+int ff_h264_decode_seq_parameter_set(BitstreamContext *bc, AVCodecContext
*avctx,
H264ParamSets *ps)
{
AVBufferRef *sps_buf;
@@ -328,16 +330,16 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
int i, log2_max_frame_num_minus4;
SPS *sps;
- profile_idc = get_bits(gb, 8);
- constraint_set_flags |= get_bits1(gb) << 0; // constraint_set0_flag
- constraint_set_flags |= get_bits1(gb) << 1; // constraint_set1_flag
- constraint_set_flags |= get_bits1(gb) << 2; // constraint_set2_flag
- constraint_set_flags |= get_bits1(gb) << 3; // constraint_set3_flag
- constraint_set_flags |= get_bits1(gb) << 4; // constraint_set4_flag
- constraint_set_flags |= get_bits1(gb) << 5; // constraint_set5_flag
- skip_bits(gb, 2); // reserved_zero_2bits
- level_idc = get_bits(gb, 8);
- sps_id = get_ue_golomb_31(gb);
+ profile_idc = bitstream_read(bc, 8);
+ constraint_set_flags |= bitstream_read_bit(bc) << 0; //
constraint_set0_flag
+ constraint_set_flags |= bitstream_read_bit(bc) << 1; //
constraint_set1_flag
+ constraint_set_flags |= bitstream_read_bit(bc) << 2; //
constraint_set2_flag
+ constraint_set_flags |= bitstream_read_bit(bc) << 3; //
constraint_set3_flag
+ constraint_set_flags |= bitstream_read_bit(bc) << 4; //
constraint_set4_flag
+ constraint_set_flags |= bitstream_read_bit(bc) << 5; //
constraint_set5_flag
+ bitstream_skip(bc, 2); //
reserved_zero_2bits
+ level_idc = bitstream_read(bc, 8);
+ sps_id = get_ue_golomb_31(bc);
if (sps_id >= MAX_SPS_COUNT) {
av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
@@ -370,23 +372,23 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
sps->profile_idc == 128 || // Multiview High profile (MVC)
sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
sps->profile_idc == 144) { // old High444 profile
- sps->chroma_format_idc = get_ue_golomb_31(gb);
+ sps->chroma_format_idc = get_ue_golomb_31(bc);
if (sps->chroma_format_idc > 3) {
avpriv_request_sample(avctx, "chroma_format_idc %u",
sps->chroma_format_idc);
goto fail;
} else if (sps->chroma_format_idc == 3) {
- sps->residual_color_transform_flag = get_bits1(gb);
+ sps->residual_color_transform_flag = bitstream_read_bit(bc);
}
- sps->bit_depth_luma = get_ue_golomb(gb) + 8;
- sps->bit_depth_chroma = get_ue_golomb(gb) + 8;
+ sps->bit_depth_luma = get_ue_golomb(bc) + 8;
+ sps->bit_depth_chroma = get_ue_golomb(bc) + 8;
if (sps->bit_depth_chroma != sps->bit_depth_luma) {
avpriv_request_sample(avctx,
"Different chroma and luma bit depth");
goto fail;
}
- sps->transform_bypass = get_bits1(gb);
- decode_scaling_matrices(gb, sps, NULL, 1,
+ sps->transform_bypass = bitstream_read_bit(bc);
+ decode_scaling_matrices(bc, sps, NULL, 1,
sps->scaling_matrix4, sps->scaling_matrix8);
} else {
sps->chroma_format_idc = 1;
@@ -394,7 +396,7 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
sps->bit_depth_chroma = 8;
}
- log2_max_frame_num_minus4 = get_ue_golomb(gb);
+ log2_max_frame_num_minus4 = get_ue_golomb(bc);
if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
av_log(avctx, AV_LOG_ERROR,
@@ -404,15 +406,15 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
}
sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
- sps->poc_type = get_ue_golomb_31(gb);
+ sps->poc_type = get_ue_golomb_31(bc);
if (sps->poc_type == 0) { // FIXME #define
- sps->log2_max_poc_lsb = get_ue_golomb(gb) + 4;
+ sps->log2_max_poc_lsb = get_ue_golomb(bc) + 4;
} else if (sps->poc_type == 1) { // FIXME #define
- sps->delta_pic_order_always_zero_flag = get_bits1(gb);
- sps->offset_for_non_ref_pic = get_se_golomb(gb);
- sps->offset_for_top_to_bottom_field = get_se_golomb(gb);
- sps->poc_cycle_length = get_ue_golomb(gb);
+ sps->delta_pic_order_always_zero_flag = bitstream_read_bit(bc);
+ sps->offset_for_non_ref_pic = get_se_golomb(bc);
+ sps->offset_for_top_to_bottom_field = get_se_golomb(bc);
+ sps->poc_cycle_length = get_ue_golomb(bc);
if ((unsigned)sps->poc_cycle_length >=
FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
@@ -422,22 +424,22 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
}
for (i = 0; i < sps->poc_cycle_length; i++)
- sps->offset_for_ref_frame[i] = get_se_golomb(gb);
+ sps->offset_for_ref_frame[i] = get_se_golomb(bc);
} else if (sps->poc_type != 2) {
av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
goto fail;
}
- sps->ref_frame_count = get_ue_golomb_31(gb);
+ sps->ref_frame_count = get_ue_golomb_31(bc);
if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
sps->ref_frame_count >= 32U) {
av_log(avctx, AV_LOG_ERROR,
"too many reference frames %d\n", sps->ref_frame_count);
goto fail;
}
- sps->gaps_in_frame_num_allowed_flag = get_bits1(gb);
- sps->mb_width = get_ue_golomb(gb) + 1;
- sps->mb_height = get_ue_golomb(gb) + 1;
+ sps->gaps_in_frame_num_allowed_flag = bitstream_read_bit(bc);
+ sps->mb_width = get_ue_golomb(bc) + 1;
+ sps->mb_height = get_ue_golomb(bc) + 1;
if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
(unsigned)sps->mb_height >= INT_MAX / 16 ||
av_image_check_size(16 * sps->mb_width,
@@ -446,13 +448,13 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
goto fail;
}
- sps->frame_mbs_only_flag = get_bits1(gb);
+ sps->frame_mbs_only_flag = bitstream_read_bit(bc);
if (!sps->frame_mbs_only_flag)
- sps->mb_aff = get_bits1(gb);
+ sps->mb_aff = bitstream_read_bit(bc);
else
sps->mb_aff = 0;
- sps->direct_8x8_inference_flag = get_bits1(gb);
+ sps->direct_8x8_inference_flag = bitstream_read_bit(bc);
if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
av_log(avctx, AV_LOG_ERROR,
"This stream was generated by a broken encoder, invalid 8x8
inference\n");
@@ -464,12 +466,12 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR,
"MBAFF support not included; enable it at compile-time.\n");
#endif
- sps->crop = get_bits1(gb);
+ sps->crop = bitstream_read_bit(bc);
if (sps->crop) {
- unsigned int crop_left = get_ue_golomb(gb);
- unsigned int crop_right = get_ue_golomb(gb);
- unsigned int crop_top = get_ue_golomb(gb);
- unsigned int crop_bottom = get_ue_golomb(gb);
+ unsigned int crop_left = get_ue_golomb(bc);
+ unsigned int crop_right = get_ue_golomb(bc);
+ unsigned int crop_top = get_ue_golomb(bc);
+ unsigned int crop_bottom = get_ue_golomb(bc);
if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
@@ -521,9 +523,9 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb,
AVCodecContext *avctx,
sps->crop = 0;
}
- sps->vui_parameters_present_flag = get_bits1(gb);
+ sps->vui_parameters_present_flag = bitstream_read_bit(bc);
if (sps->vui_parameters_present_flag) {
- int ret = decode_vui_parameters(gb, avctx, sps);
+ int ret = decode_vui_parameters(bc, avctx, sps);
if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE)
goto fail;
}
@@ -659,12 +661,12 @@ static void build_qp_table(PPS *pps, int t, int index,
const int depth)
ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
}
-int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext
*avctx,
+int ff_h264_decode_picture_parameter_set(BitstreamContext *bc, AVCodecContext
*avctx,
H264ParamSets *ps, int bit_length)
{
AVBufferRef *pps_buf;
SPS *sps;
- unsigned int pps_id = get_ue_golomb(gb);
+ unsigned int pps_id = get_ue_golomb(bc);
PPS *pps;
int qp_bd_offset;
int bits_left;
@@ -680,7 +682,7 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb,
AVCodecContext *avct
return AVERROR(ENOMEM);
pps = (PPS*)pps_buf->data;
- pps->sps_id = get_ue_golomb_31(gb);
+ pps->sps_id = get_ue_golomb_31(bc);
if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
!ps->sps_list[pps->sps_id]) {
av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
@@ -697,11 +699,11 @@ int ff_h264_decode_picture_parameter_set(GetBitContext
*gb, AVCodecContext *avct
goto fail;
}
- pps->cabac = get_bits1(gb);
- pps->pic_order_present = get_bits1(gb);
- pps->slice_group_count = get_ue_golomb(gb) + 1;
+ pps->cabac = bitstream_read_bit(bc);
+ pps->pic_order_present = bitstream_read_bit(bc);
+ pps->slice_group_count = get_ue_golomb(bc) + 1;
if (pps->slice_group_count > 1) {
- pps->mb_slice_group_map_type = get_ue_golomb(gb);
+ pps->mb_slice_group_map_type = get_ue_golomb(bc);
av_log(avctx, AV_LOG_ERROR, "FMO not supported\n");
switch (pps->mb_slice_group_map_type) {
case 0:
@@ -735,8 +737,8 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb,
AVCodecContext *avct
break;
}
}
- pps->ref_count[0] = get_ue_golomb(gb) + 1;
- pps->ref_count[1] = get_ue_golomb(gb) + 1;
+ pps->ref_count[0] = get_ue_golomb(bc) + 1;
+ pps->ref_count[1] = get_ue_golomb(bc) + 1;
if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
ret = AVERROR_INVALIDDATA;
@@ -745,14 +747,14 @@ int ff_h264_decode_picture_parameter_set(GetBitContext
*gb, AVCodecContext *avct
qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
- pps->weighted_pred = get_bits1(gb);
- pps->weighted_bipred_idc = get_bits(gb, 2);
- pps->init_qp = get_se_golomb(gb) + 26 +
qp_bd_offset;
- pps->init_qs = get_se_golomb(gb) + 26 +
qp_bd_offset;
- pps->chroma_qp_index_offset[0] = get_se_golomb(gb);
- pps->deblocking_filter_parameters_present = get_bits1(gb);
- pps->constrained_intra_pred = get_bits1(gb);
- pps->redundant_pic_cnt_present = get_bits1(gb);
+ pps->weighted_pred = bitstream_read_bit(bc);
+ pps->weighted_bipred_idc = bitstream_read(bc, 2);
+ pps->init_qp = get_se_golomb(bc) + 26 +
qp_bd_offset;
+ pps->init_qs = get_se_golomb(bc) + 26 +
qp_bd_offset;
+ pps->chroma_qp_index_offset[0] = get_se_golomb(bc);
+ pps->deblocking_filter_parameters_present = bitstream_read_bit(bc);
+ pps->constrained_intra_pred = bitstream_read_bit(bc);
+ pps->redundant_pic_cnt_present = bitstream_read_bit(bc);
pps->transform_8x8_mode = 0;
memcpy(pps->scaling_matrix4, sps->scaling_matrix4,
@@ -760,14 +762,14 @@ int ff_h264_decode_picture_parameter_set(GetBitContext
*gb, AVCodecContext *avct
memcpy(pps->scaling_matrix8, sps->scaling_matrix8,
sizeof(pps->scaling_matrix8));
- bits_left = bit_length - get_bits_count(gb);
+ bits_left = bit_length - bitstream_tell(bc);
if (bits_left && (bits_left > 8 ||
- show_bits(gb, bits_left) != 1 << (bits_left - 1))) {
- pps->transform_8x8_mode = get_bits1(gb);
- decode_scaling_matrices(gb, sps, pps, 0,
+ bitstream_peek(bc, bits_left) != 1 << (bits_left - 1))) {
+ pps->transform_8x8_mode = bitstream_read_bit(bc);
+ decode_scaling_matrices(bc, sps, pps, 0,
pps->scaling_matrix4, pps->scaling_matrix8);
// second_chroma_qp_index_offset
- pps->chroma_qp_index_offset[1] = get_se_golomb(gb);
+ pps->chroma_qp_index_offset[1] = get_se_golomb(bc);
} else {
pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
}
diff --git a/libavcodec/h264_refs.c b/libavcodec/h264_refs.c
index 427930c..96b2bc7 100644
--- a/libavcodec/h264_refs.c
+++ b/libavcodec/h264_refs.c
@@ -27,6 +27,7 @@
#include <inttypes.h>
+#include "bitstream.h"
#include "internal.h"
#include "avcodec.h"
#include "h264.h"
@@ -237,11 +238,11 @@ int ff_h264_decode_ref_pic_list_reordering(const
H264Context *h, H264SliceContex
h264_initialise_ref_list(h, sl);
for (list = 0; list < sl->list_count; list++) {
- if (get_bits1(&sl->gb)) { // ref_pic_list_modification_flag_l[01]
+ if (bitstream_read_bit(&sl->bc)) { //
ref_pic_list_modification_flag_l[01]
int pred = h->curr_pic_num;
for (index = 0; ; index++) {
- unsigned int modification_of_pic_nums_idc =
get_ue_golomb_31(&sl->gb);
+ unsigned int modification_of_pic_nums_idc =
get_ue_golomb_31(&sl->bc);
unsigned int pic_id;
int i;
H264Picture *ref = NULL;
@@ -257,7 +258,7 @@ int ff_h264_decode_ref_pic_list_reordering(const
H264Context *h, H264SliceContex
switch (modification_of_pic_nums_idc) {
case 0:
case 1: {
- const unsigned int abs_diff_pic_num =
get_ue_golomb(&sl->gb) + 1;
+ const unsigned int abs_diff_pic_num =
get_ue_golomb(&sl->bc) + 1;
int frame_num;
if (abs_diff_pic_num > h->max_pic_num) {
@@ -288,7 +289,7 @@ int ff_h264_decode_ref_pic_list_reordering(const
H264Context *h, H264SliceContex
}
case 2: {
int long_idx;
- pic_id = get_ue_golomb(&sl->gb); // long_term_pic_idx
+ pic_id = get_ue_golomb(&sl->bc); // long_term_pic_idx
long_idx = pic_num_extract(h, pic_id, &pic_structure);
@@ -726,7 +727,7 @@ int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO
*mmco, int mmco_count)
return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
}
-int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb,
+int ff_h264_decode_ref_pic_marking(H264Context *h, BitstreamContext *bc,
int first_slice)
{
int i, ret;
@@ -734,21 +735,21 @@ int ff_h264_decode_ref_pic_marking(H264Context *h,
GetBitContext *gb,
int mmco_index = 0;
if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields
- skip_bits1(gb); // broken_link
- if (get_bits1(gb)) {
+ bitstream_skip(bc, 1); // broken_link
+ if (bitstream_read_bit(bc)) {
mmco[0].opcode = MMCO_LONG;
mmco[0].long_arg = 0;
mmco_index = 1;
}
} else {
- if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
+ if (bitstream_read_bit(bc)) { // adaptive_ref_pic_marking_mode_flag
for (i = 0; i < MAX_MMCO_COUNT; i++) {
- MMCOOpcode opcode = get_ue_golomb_31(gb);
+ MMCOOpcode opcode = get_ue_golomb_31(bc);
mmco[i].opcode = opcode;
if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
mmco[i].short_pic_num =
- (h->curr_pic_num - get_ue_golomb(gb) - 1) &
+ (h->curr_pic_num - get_ue_golomb(bc) - 1) &
(h->max_pic_num - 1);
#if 0
if (mmco[i].short_pic_num >= h->short_ref_count ||
@@ -762,7 +763,7 @@ int ff_h264_decode_ref_pic_marking(H264Context *h,
GetBitContext *gb,
}
if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
- unsigned int long_arg = get_ue_golomb_31(gb);
+ unsigned int long_arg = get_ue_golomb_31(bc);
if (long_arg >= 32 ||
(long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
long_arg == 16) &&
diff --git a/libavcodec/h264_sei.c b/libavcodec/h264_sei.c
index 0e3952d..62f6a45 100644
--- a/libavcodec/h264_sei.c
+++ b/libavcodec/h264_sei.c
@@ -26,7 +26,7 @@
*/
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "golomb.h"
#include "h264.h"
#include "h264_sei.h"
@@ -53,7 +53,7 @@ void ff_h264_sei_uninit(H264SEIContext *h)
av_freep(&h->a53_caption.a53_caption);
}
-static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb,
+static int decode_picture_timing(H264SEIPictureTiming *h, BitstreamContext *bc,
const SPS *sps, void *logctx)
{
if (!sps)
@@ -61,13 +61,13 @@ static int decode_picture_timing(H264SEIPictureTiming *h,
GetBitContext *gb,
if (sps->nal_hrd_parameters_present_flag ||
sps->vcl_hrd_parameters_present_flag) {
- h->cpb_removal_delay = get_bits(gb, sps->cpb_removal_delay_length);
- h->dpb_output_delay = get_bits(gb, sps->dpb_output_delay_length);
+ h->cpb_removal_delay = bitstream_read(bc,
sps->cpb_removal_delay_length);
+ h->dpb_output_delay = bitstream_read(bc,
sps->dpb_output_delay_length);
}
if (sps->pic_struct_present_flag) {
unsigned int i, num_clock_ts;
- h->pic_struct = get_bits(gb, 4);
+ h->pic_struct = bitstream_read(bc, 4);
h->ct_type = 0;
if (h->pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING)
@@ -76,32 +76,32 @@ static int decode_picture_timing(H264SEIPictureTiming *h,
GetBitContext *gb,
num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
for (i = 0; i < num_clock_ts; i++) {
- if (get_bits(gb, 1)) { /* clock_timestamp_flag */
+ if (bitstream_read(bc, 1)) { /* clock_timestamp_flag */
unsigned int full_timestamp_flag;
- h->ct_type |= 1 << get_bits(gb, 2);
- skip_bits(gb, 1); /* nuit_field_based_flag */
- skip_bits(gb, 5); /* counting_type */
- full_timestamp_flag = get_bits(gb, 1);
- skip_bits(gb, 1); /* discontinuity_flag */
- skip_bits(gb, 1); /* cnt_dropped_flag */
- skip_bits(gb, 8); /* n_frames */
+ h->ct_type |= 1 << bitstream_read(bc, 2);
+ bitstream_skip(bc, 1); /*
nuit_field_based_flag */
+ bitstream_skip(bc, 5); /* counting_type */
+ full_timestamp_flag = bitstream_read(bc, 1);
+ bitstream_skip(bc, 1); /* discontinuity_flag
*/
+ bitstream_skip(bc, 1); /* cnt_dropped_flag */
+ bitstream_skip(bc, 8); /* n_frames */
if (full_timestamp_flag) {
- skip_bits(gb, 6); /* seconds_value 0..59 */
- skip_bits(gb, 6); /* minutes_value 0..59 */
- skip_bits(gb, 5); /* hours_value 0..23 */
+ bitstream_skip(bc, 6); /* seconds_value 0..59
*/
+ bitstream_skip(bc, 6); /* minutes_value 0..59
*/
+ bitstream_skip(bc, 5); /* hours_value 0..23 */
} else {
- if (get_bits(gb, 1)) { /* seconds_flag */
- skip_bits(gb, 6); /* seconds_value range 0..59
*/
- if (get_bits(gb, 1)) { /* minutes_flag */
- skip_bits(gb, 6); /* minutes_value 0..59 */
- if (get_bits(gb, 1)) /* hours_flag */
- skip_bits(gb, 5); /* hours_value 0..23 */
+ if (bitstream_read(bc, 1)) { /* seconds_flag */
+ bitstream_skip(bc, 6); /* seconds_value range
0..59 */
+ if (bitstream_read(bc, 1)) { /* minutes_flag */
+ bitstream_skip(bc, 6); /* minutes_value 0..59
*/
+ if (bitstream_read(bc, 1)) /* hours_flag */
+ bitstream_skip(bc, 5); /* hours_value 0..23 */
}
}
}
if (sps->time_offset_length > 0)
- skip_bits(gb,
+ bitstream_skip(bc,
sps->time_offset_length); /* time_offset */
}
}
@@ -112,21 +112,21 @@ static int decode_picture_timing(H264SEIPictureTiming *h,
GetBitContext *gb,
return 0;
}
-static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb,
int size)
+static int decode_registered_user_data_afd(H264SEIAFD *h, BitstreamContext
*bc, int size)
{
int flag;
if (size-- < 1)
return AVERROR_INVALIDDATA;
- skip_bits(gb, 1); // 0
- flag = get_bits(gb, 1); // active_format_flag
- skip_bits(gb, 6); // reserved
+ bitstream_skip(bc, 1); // 0
+ flag = bitstream_read(bc, 1); // active_format_flag
+ bitstream_skip(bc, 6); // reserved
if (flag) {
if (size-- < 1)
return AVERROR_INVALIDDATA;
- skip_bits(gb, 4); // reserved
- h->active_format_description = get_bits(gb, 4);
+ bitstream_skip(bc, 4); // reserved
+ h->active_format_description = bitstream_read(bc, 4);
h->present = 1;
}
@@ -134,7 +134,7 @@ static int decode_registered_user_data_afd(H264SEIAFD *h,
GetBitContext *gb, int
}
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h,
- GetBitContext *gb, void
*logctx,
+ BitstreamContext *bc,
void *logctx,
int size)
{
int flag;
@@ -144,15 +144,15 @@ static int
decode_registered_user_data_closed_caption(H264SEIA53Caption *h,
if (size < 3)
return AVERROR(EINVAL);
- user_data_type_code = get_bits(gb, 8);
+ user_data_type_code = bitstream_read(bc, 8);
if (user_data_type_code == 0x3) {
- skip_bits(gb, 1); // reserved
+ bitstream_skip(bc, 1); // reserved
- flag = get_bits(gb, 1); // process_cc_data_flag
+ flag = bitstream_read(bc, 1); // process_cc_data_flag
if (flag) {
- skip_bits(gb, 1); // zero bit
- cc_count = get_bits(gb, 5);
- skip_bits(gb, 8); // reserved
+ bitstream_skip(bc, 1); // zero bit
+ cc_count = bitstream_read(bc, 5);
+ bitstream_skip(bc, 8); // reserved
size -= 2;
if (cc_count && size >= cc_count * 3) {
@@ -169,12 +169,12 @@ static int
decode_registered_user_data_closed_caption(H264SEIA53Caption *h,
return ret;
for (i = 0; i < cc_count; i++) {
- h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
- h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
- h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
+ h->a53_caption[h->a53_caption_size++] = bitstream_read(bc,
8);
+ h->a53_caption[h->a53_caption_size++] = bitstream_read(bc,
8);
+ h->a53_caption[h->a53_caption_size++] = bitstream_read(bc,
8);
}
- skip_bits(gb, 8); // marker_bits
+ bitstream_skip(bc, 8); // marker_bits
}
}
} else {
@@ -182,13 +182,13 @@ static int
decode_registered_user_data_closed_caption(H264SEIA53Caption *h,
avpriv_request_sample(logctx, "Subtitles with data type 0x%02x",
user_data_type_code);
for (i = 0; i < size - 1; i++)
- skip_bits(gb, 8);
+ bitstream_skip(bc, 8);
}
return 0;
}
-static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb,
+static int decode_registered_user_data(H264SEIContext *h, BitstreamContext *bc,
void *logctx, int size)
{
uint32_t country_code;
@@ -198,32 +198,32 @@ static int decode_registered_user_data(H264SEIContext *h,
GetBitContext *gb,
return AVERROR_INVALIDDATA;
size -= 7;
- country_code = get_bits(gb, 8); // itu_t_t35_country_code
+ country_code = bitstream_read(bc, 8); // itu_t_t35_country_code
if (country_code == 0xFF) {
- skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
+ bitstream_skip(bc, 8); //
itu_t_t35_country_code_extension_byte
size--;
}
/* itu_t_t35_payload_byte follows */
- skip_bits(gb, 8); // terminal provider code
- skip_bits(gb, 8); // terminal provider oriented code
- user_identifier = get_bits_long(gb, 32);
+ bitstream_skip(bc, 8); // terminal provider code
+ bitstream_skip(bc, 8); // terminal provider oriented code
+ user_identifier = bitstream_read(bc, 32);
switch (user_identifier) {
case MKBETAG('D', 'T', 'G', '1'): // afd_data
- return decode_registered_user_data_afd(&h->afd, gb, size);
+ return decode_registered_user_data_afd(&h->afd, bc, size);
case MKBETAG('G', 'A', '9', '4'): // closed captions
- return decode_registered_user_data_closed_caption(&h->a53_caption,
gb,
+ return decode_registered_user_data_closed_caption(&h->a53_caption,
bc,
logctx, size);
default:
- skip_bits(gb, size * 8);
+ bitstream_skip(bc, size * 8);
break;
}
return 0;
}
-static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext
*gb,
+static int decode_unregistered_user_data(H264SEIUnregistered *h,
BitstreamContext *bc,
void *logctx, int size)
{
uint8_t *user_data;
@@ -237,7 +237,7 @@ static int
decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *
return AVERROR(ENOMEM);
for (i = 0; i < size + 16; i++)
- user_data[i] = get_bits(gb, 8);
+ user_data[i] = bitstream_read(bc, 8);
user_data[i] = 0;
e = sscanf(user_data + 16, "x264 - core %d", &build);
@@ -251,26 +251,26 @@ static int
decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *
return 0;
}
-static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb)
+static int decode_recovery_point(H264SEIRecoveryPoint *h, BitstreamContext *bc)
{
- h->recovery_frame_cnt = get_ue_golomb(gb);
+ h->recovery_frame_cnt = get_ue_golomb(bc);
/* 1b exact_match_flag,
* 1b broken_link_flag,
* 2b changing_slice_group_idc */
- skip_bits(gb, 4);
+ bitstream_skip(bc, 4);
return 0;
}
-static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext
*gb,
+static int decode_buffering_period(H264SEIBufferingPeriod *h, BitstreamContext
*bc,
const H264ParamSets *ps, void *logctx)
{
unsigned int sps_id;
int sched_sel_idx;
SPS *sps;
- sps_id = get_ue_golomb_31(gb);
+ sps_id = get_ue_golomb_31(bc);
if (sps_id > 31 || !ps->sps_list[sps_id]) {
av_log(logctx, AV_LOG_ERROR,
"non-existing SPS %d referenced in buffering period\n", sps_id);
@@ -282,17 +282,17 @@ static int decode_buffering_period(H264SEIBufferingPeriod
*h, GetBitContext *gb,
if (sps->nal_hrd_parameters_present_flag) {
for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++)
{
h->initial_cpb_removal_delay[sched_sel_idx] =
- get_bits(gb, sps->initial_cpb_removal_delay_length);
+ bitstream_read(bc, sps->initial_cpb_removal_delay_length);
// initial_cpb_removal_delay_offset
- skip_bits(gb, sps->initial_cpb_removal_delay_length);
+ bitstream_skip(bc, sps->initial_cpb_removal_delay_length);
}
}
if (sps->vcl_hrd_parameters_present_flag) {
for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++)
{
h->initial_cpb_removal_delay[sched_sel_idx] =
- get_bits(gb, sps->initial_cpb_removal_delay_length);
+ bitstream_read(bc, sps->initial_cpb_removal_delay_length);
// initial_cpb_removal_delay_offset
- skip_bits(gb, sps->initial_cpb_removal_delay_length);
+ bitstream_skip(bc, sps->initial_cpb_removal_delay_length);
}
}
@@ -301,107 +301,107 @@ static int
decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb,
}
static int decode_frame_packing_arrangement(H264SEIFramePacking *h,
- GetBitContext *gb)
+ BitstreamContext *bc)
{
- get_ue_golomb(gb); // frame_packing_arrangement_id
- h->present = !get_bits1(gb);
+ get_ue_golomb(bc); // frame_packing_arrangement_id
+ h->present = !bitstream_read_bit(bc);
if (h->present) {
- h->arrangement_type = get_bits(gb, 7);
- h->quincunx_subsampling = get_bits1(gb);
- h->content_interpretation_type = get_bits(gb, 6);
+ h->arrangement_type = bitstream_read(bc, 7);
+ h->quincunx_subsampling = bitstream_read_bit(bc);
+ h->content_interpretation_type = bitstream_read(bc, 6);
// the following skips: spatial_flipping_flag, frame0_flipped_flag,
// field_views_flag, current_frame_is_frame0_flag,
// frame0_self_contained_flag, frame1_self_contained_flag
- skip_bits(gb, 6);
+ bitstream_skip(bc, 6);
if (!h->quincunx_subsampling && h->arrangement_type != 5)
- skip_bits(gb, 16); // frame[01]_grid_position_[xy]
- skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
- get_ue_golomb(gb); //
frame_packing_arrangement_repetition_period
+ bitstream_skip(bc, 16); // frame[01]_grid_position_[xy]
+ bitstream_skip(bc, 8); //
frame_packing_arrangement_reserved_byte
+ get_ue_golomb(bc); //
frame_packing_arrangement_repetition_period
}
- skip_bits1(gb); // frame_packing_arrangement_extension_flag
+ bitstream_skip(bc, 1); //
frame_packing_arrangement_extension_flag
return 0;
}
static int decode_display_orientation(H264SEIDisplayOrientation *h,
- GetBitContext *gb)
+ BitstreamContext *bc)
{
- h->present = !get_bits1(gb);
+ h->present = !bitstream_read_bit(bc);
if (h->present) {
- h->hflip = get_bits1(gb); // hor_flip
- h->vflip = get_bits1(gb); // ver_flip
+ h->hflip = bitstream_read_bit(bc); // hor_flip
+ h->vflip = bitstream_read_bit(bc); // ver_flip
- h->anticlockwise_rotation = get_bits(gb, 16);
- get_ue_golomb(gb); // display_orientation_repetition_period
- skip_bits1(gb); // display_orientation_extension_flag
+ h->anticlockwise_rotation = bitstream_read(bc, 16);
+ get_ue_golomb(bc); // display_orientation_repetition_period
+ bitstream_skip(bc, 1); // display_orientation_extension_flag
}
return 0;
}
-int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
+int ff_h264_sei_decode(H264SEIContext *h, BitstreamContext *bc,
const H264ParamSets *ps, void *logctx)
{
- while (get_bits_left(gb) > 16) {
+ while (bitstream_bits_left(bc) > 16) {
int size = 0;
int type = 0;
int ret = 0;
int last = 0;
- while (get_bits_left(gb) >= 8 &&
- (last = get_bits(gb, 8)) == 255) {
+ while (bitstream_bits_left(bc) >= 8 &&
+ (last = bitstream_read(bc, 8)) == 255) {
type += 255;
}
type += last;
last = 0;
- while (get_bits_left(gb) >= 8 &&
- (last = get_bits(gb, 8)) == 255) {
+ while (bitstream_bits_left(bc) >= 8 &&
+ (last = bitstream_read(bc, 8)) == 255) {
size += 255;
}
size += last;
- if (size > get_bits_left(gb) / 8) {
+ if (size > bitstream_bits_left(bc) / 8) {
av_log(logctx, AV_LOG_ERROR, "SEI type %d truncated at %d\n",
- type, get_bits_left(gb));
+ type, bitstream_bits_left(bc));
return AVERROR_INVALIDDATA;
}
switch (type) {
case SEI_TYPE_PIC_TIMING: // Picture timing SEI
- ret = decode_picture_timing(&h->picture_timing, gb, ps->sps,
logctx);
+ ret = decode_picture_timing(&h->picture_timing, bc, ps->sps,
logctx);
break;
case SEI_TYPE_USER_DATA_REGISTERED:
- ret = decode_registered_user_data(h, gb, logctx, size);
+ ret = decode_registered_user_data(h, bc, logctx, size);
break;
case SEI_TYPE_USER_DATA_UNREGISTERED:
- ret = decode_unregistered_user_data(&h->unregistered, gb, logctx,
size);
+ ret = decode_unregistered_user_data(&h->unregistered, bc, logctx,
size);
break;
case SEI_TYPE_RECOVERY_POINT:
- ret = decode_recovery_point(&h->recovery_point, gb);
+ ret = decode_recovery_point(&h->recovery_point, bc);
break;
case SEI_TYPE_BUFFERING_PERIOD:
- ret = decode_buffering_period(&h->buffering_period, gb, ps,
logctx);
+ ret = decode_buffering_period(&h->buffering_period, bc, ps,
logctx);
break;
case SEI_TYPE_FRAME_PACKING:
- ret = decode_frame_packing_arrangement(&h->frame_packing, gb);
+ ret = decode_frame_packing_arrangement(&h->frame_packing, bc);
break;
case SEI_TYPE_DISPLAY_ORIENTATION:
- ret = decode_display_orientation(&h->display_orientation, gb);
+ ret = decode_display_orientation(&h->display_orientation, bc);
break;
default:
av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
- skip_bits(gb, 8 * size);
+ bitstream_skip(bc, 8 * size);
}
if (ret < 0)
return ret;
// FIXME check bits here
- align_get_bits(gb);
+ bitstream_align(bc);
}
return 0;
diff --git a/libavcodec/h264_sei.h b/libavcodec/h264_sei.h
index 58f5ecc..c4ffd7e 100644
--- a/libavcodec/h264_sei.h
+++ b/libavcodec/h264_sei.h
@@ -19,7 +19,7 @@
#ifndef AVCODEC_H264_SEI_H
#define AVCODEC_H264_SEI_H
-#include "get_bits.h"
+#include "bitstream.h"
/**
* SEI message types
@@ -126,7 +126,7 @@ typedef struct H264SEIContext {
struct H264ParamSets;
-int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
+int ff_h264_sei_decode(H264SEIContext *h, BitstreamContext *bc,
const struct H264ParamSets *ps, void *logctx);
/**
diff --git a/libavcodec/h264_slice.c b/libavcodec/h264_slice.c
index 7031ee2..bf57f42 100644
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@ -28,6 +28,8 @@
#include "libavutil/avassert.h"
#include "libavutil/imgutils.h"
#include "libavutil/timer.h"
+
+#include "bitstream.h"
#include "internal.h"
#include "cabac.h"
#include "cabac_functions.h"
@@ -923,12 +925,12 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
int frame_num, droppable, picture_structure;
int mb_aff_frame = 0;
- first_mb_in_slice = get_ue_golomb(&sl->gb);
+ first_mb_in_slice = get_ue_golomb(&sl->bc);
if (first_mb_in_slice == 0) { // FIXME better field boundary detection
if (h->current_slice && h->cur_pic_ptr && FIELD_PICTURE(h)) {
ff_h264_field_end(h, sl, 1);
- }
+ }
h->current_slice = 0;
if (!h->first_field) {
@@ -940,7 +942,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
}
}
- slice_type = get_ue_golomb_31(&sl->gb);
+ slice_type = get_ue_golomb_31(&sl->bc);
if (slice_type > 9) {
av_log(h->avctx, AV_LOG_ERROR,
"slice type %d too large at %d\n",
@@ -963,7 +965,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
return AVERROR_INVALIDDATA;
}
- pps_id = get_ue_golomb(&sl->gb);
+ pps_id = get_ue_golomb(&sl->bc);
if (pps_id >= MAX_PPS_COUNT) {
av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
return AVERROR_INVALIDDATA;
@@ -1082,7 +1084,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
}
}
- frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
+ frame_num = bitstream_read(&sl->bc, sps->log2_max_frame_num);
if (!h->setup_finished)
h->poc.frame_num = frame_num;
@@ -1095,9 +1097,9 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
if (sps->frame_mbs_only_flag) {
picture_structure = PICT_FRAME;
} else {
- field_pic_flag = get_bits1(&sl->gb);
+ field_pic_flag = bitstream_read_bit(&sl->bc);
if (field_pic_flag) {
- bottom_field_flag = get_bits1(&sl->gb);
+ bottom_field_flag = bitstream_read_bit(&sl->bc);
picture_structure = PICT_TOP_FIELD + bottom_field_flag;
} else {
picture_structure = PICT_FRAME;
@@ -1304,29 +1306,29 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
}
if (h->nal_unit_type == NAL_IDR_SLICE)
- get_ue_golomb(&sl->gb); /* idr_pic_id */
+ get_ue_golomb(&sl->bc); /* idr_pic_id */
if (sps->poc_type == 0) {
- int poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
+ int poc_lsb = bitstream_read(&sl->bc, sps->log2_max_poc_lsb);
if (!h->setup_finished)
h->poc.poc_lsb = poc_lsb;
if (pps->pic_order_present == 1 && h->picture_structure == PICT_FRAME)
{
- int delta_poc_bottom = get_se_golomb(&sl->gb);
+ int delta_poc_bottom = get_se_golomb(&sl->bc);
if (!h->setup_finished)
h->poc.delta_poc_bottom = delta_poc_bottom;
}
}
if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
- int delta_poc = get_se_golomb(&sl->gb);
+ int delta_poc = get_se_golomb(&sl->bc);
if (!h->setup_finished)
h->poc.delta_poc[0] = delta_poc;
if (pps->pic_order_present == 1 && h->picture_structure == PICT_FRAME)
{
- delta_poc = get_se_golomb(&sl->gb);
+ delta_poc = get_se_golomb(&sl->bc);
if (!h->setup_finished)
h->poc.delta_poc[1] = delta_poc;
@@ -1338,13 +1340,13 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
sps, &h->poc, h->picture_structure, h->nal_ref_idc);
if (pps->redundant_pic_cnt_present)
- sl->redundant_pic_count = get_ue_golomb(&sl->gb);
+ sl->redundant_pic_count = get_ue_golomb(&sl->bc);
if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
- sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
+ sl->direct_spatial_mv_pred = bitstream_read_bit(&sl->bc);
ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
- &sl->gb, pps, sl->slice_type_nos,
+ &sl->bc, pps, sl->slice_type_nos,
h->picture_structure);
if (ret < 0)
return ret;
@@ -1360,7 +1362,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
(pps->weighted_bipred_idc == 1 &&
sl->slice_type_nos == AV_PICTURE_TYPE_B))
- ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
+ ff_h264_pred_weight_table(&sl->bc, sps, sl->ref_count,
sl->slice_type_nos, &sl->pwt);
else if (pps->weighted_bipred_idc == 2 &&
sl->slice_type_nos == AV_PICTURE_TYPE_B) {
@@ -1379,7 +1381,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
// further down the line. This may break decoding if the first slice is
// corrupt, thus we only do this if frame-mt is enabled.
if (h->nal_ref_idc) {
- ret = ff_h264_decode_ref_pic_marking(h, &sl->gb,
+ ret = ff_h264_decode_ref_pic_marking(h, &sl->bc,
!(h->avctx->active_thread_type &
FF_THREAD_FRAME) ||
h->current_slice == 0);
if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
@@ -1400,7 +1402,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
ff_h264_direct_ref_list_init(h, sl);
if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
- tmp = get_ue_golomb_31(&sl->gb);
+ tmp = get_ue_golomb_31(&sl->bc);
if (tmp > 2) {
av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n",
tmp);
return AVERROR_INVALIDDATA;
@@ -1409,7 +1411,7 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
}
sl->last_qscale_diff = 0;
- tmp = pps->init_qp + get_se_golomb(&sl->gb);
+ tmp = pps->init_qp + get_se_golomb(&sl->bc);
if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
return AVERROR_INVALIDDATA;
@@ -1419,16 +1421,16 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
// FIXME qscale / qp ... stuff
if (sl->slice_type == AV_PICTURE_TYPE_SP)
- get_bits1(&sl->gb); /* sp_for_switch_flag */
+ bitstream_read_bit(&sl->bc); /* sp_for_switch_flag */
if (sl->slice_type == AV_PICTURE_TYPE_SP ||
sl->slice_type == AV_PICTURE_TYPE_SI)
- get_se_golomb(&sl->gb); /* slice_qs_delta */
+ get_se_golomb(&sl->bc); /* slice_qs_delta */
sl->deblocking_filter = 1;
sl->slice_alpha_c0_offset = 0;
sl->slice_beta_offset = 0;
if (pps->deblocking_filter_parameters_present) {
- tmp = get_ue_golomb_31(&sl->gb);
+ tmp = get_ue_golomb_31(&sl->bc);
if (tmp > 2) {
av_log(h->avctx, AV_LOG_ERROR,
"deblocking_filter_idc %u out of range\n", tmp);
@@ -1439,8 +1441,8 @@ int ff_h264_decode_slice_header(H264Context *h,
H264SliceContext *sl)
sl->deblocking_filter ^= 1; // 1<->0
if (sl->deblocking_filter) {
- sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;
- sl->slice_beta_offset = get_se_golomb(&sl->gb) * 2;
+ sl->slice_alpha_c0_offset = get_se_golomb(&sl->bc) * 2;
+ sl->slice_beta_offset = get_se_golomb(&sl->bc) * 2;
if (sl->slice_alpha_c0_offset > 12 ||
sl->slice_alpha_c0_offset < -12 ||
sl->slice_beta_offset > 12 ||
@@ -1940,12 +1942,12 @@ static int decode_slice(struct AVCodecContext *avctx,
void *arg)
if (h->ps.pps->cabac) {
/* realign */
- align_get_bits(&sl->gb);
+ bitstream_align(&sl->bc);
/* init cabac */
ff_init_cabac_decoder(&sl->cabac,
- sl->gb.buffer + get_bits_count(&sl->gb) / 8,
- (get_bits_left(&sl->gb) + 7) / 8);
+ sl->bc.buffer + bitstream_tell(&sl->bc) / 8,
+ (bitstream_bits_left(&sl->bc) + 7) / 8);
ff_h264_init_cabac_states(h, sl);
@@ -2009,7 +2011,7 @@ static int decode_slice(struct AVCodecContext *avctx,
void *arg)
if (eos || sl->mb_y >= h->mb_height) {
ff_tlog(h->avctx, "slice end %d %d\n",
- get_bits_count(&sl->gb), sl->gb.size_in_bits);
+ bitstream_tell(&sl->bc), sl->bc.size_in_bits);
er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x -
1,
sl->mb_y, ER_MB_END);
if (sl->mb_x > lf_x_start)
@@ -2062,9 +2064,9 @@ static int decode_slice(struct AVCodecContext *avctx,
void *arg)
}
if (sl->mb_y >= h->mb_height) {
ff_tlog(h->avctx, "slice end %d %d\n",
- get_bits_count(&sl->gb), sl->gb.size_in_bits);
+ bitstream_tell(&sl->bc), sl->bc.size_in_bits);
- if (get_bits_left(&sl->gb) == 0) {
+ if (bitstream_bits_left(&sl->bc) == 0) {
er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
sl->mb_x - 1, sl->mb_y, ER_MB_END);
@@ -2078,11 +2080,11 @@ static int decode_slice(struct AVCodecContext *avctx,
void *arg)
}
}
- if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
+ if (bitstream_bits_left(&sl->bc) <= 0 && sl->mb_skip_run <= 0) {
ff_tlog(h->avctx, "slice end %d %d\n",
- get_bits_count(&sl->gb), sl->gb.size_in_bits);
+ bitstream_tell(&sl->bc), sl->bc.size_in_bits);
- if (get_bits_left(&sl->gb) == 0) {
+ if (bitstream_bits_left(&sl->bc) == 0) {
er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
sl->mb_x - 1, sl->mb_y, ER_MB_END);
if (sl->mb_x > lf_x_start)
diff --git a/libavcodec/vaapi_h264.c b/libavcodec/vaapi_h264.c
index 0925985..b0c9c49 100644
--- a/libavcodec/vaapi_h264.c
+++ b/libavcodec/vaapi_h264.c
@@ -20,6 +20,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "bitstream.h"
#include "vaapi_internal.h"
#include "h264.h"
#include "mpegutils.h"
@@ -324,7 +325,7 @@ static int vaapi_h264_decode_slice(AVCodecContext *avctx,
slice_param = (VASliceParameterBufferH264
*)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size);
if (!slice_param)
return -1;
- slice_param->slice_data_bit_offset = get_bits_count(&sl->gb);
+ slice_param->slice_data_bit_offset = bitstream_tell(&sl->bc);
slice_param->first_mb_in_slice = (sl->mb_y >>
FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x;
slice_param->slice_type = ff_h264_get_slice_type(sl);
slice_param->direct_spatial_mv_pred_flag = sl->slice_type ==
AV_PICTURE_TYPE_B ? sl->direct_spatial_mv_pred : 0;
--
2.1.4
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
