diff options
author | Alexandra Hájková <alexandra@khirnov.net> | 2016-05-10 00:41:48 +0200 |
---|---|---|
committer | Alexandra Hájková <alexandra@khirnov.net> | 2016-05-22 16:47:54 +0200 |
commit | 5ff207c5e49ae6bc74908fa3385a77d734c28e83 (patch) | |
tree | d0eac3fe17fb0244af6043f62632ac294ff61027 | |
parent | 5dc28c04d87886391127f8e461fa33605a7d9a73 (diff) |
h264: Convert to the new bitstream reader
-rw-r--r-- | libavcodec/h264.c | 15 | ||||
-rw-r--r-- | libavcodec/h264.h | 13 | ||||
-rw-r--r-- | libavcodec/h2645_parse.c | 21 | ||||
-rw-r--r-- | libavcodec/h2645_parse.h | 4 | ||||
-rw-r--r-- | libavcodec/h264_cabac.c | 2 | ||||
-rw-r--r-- | libavcodec/h264_cavlc.c | 167 | ||||
-rw-r--r-- | libavcodec/h264_mb_template.c | 16 | ||||
-rw-r--r-- | libavcodec/h264_parse.c | 32 | ||||
-rw-r--r-- | libavcodec/h264_parse.h | 6 | ||||
-rw-r--r-- | libavcodec/h264_parser.c | 64 | ||||
-rw-r--r-- | libavcodec/h264_ps.c | 260 | ||||
-rw-r--r-- | libavcodec/h264_refs.c | 23 | ||||
-rw-r--r-- | libavcodec/h264_sei.c | 192 | ||||
-rw-r--r-- | libavcodec/h264_sei.h | 4 | ||||
-rw-r--r-- | libavcodec/h264_slice.c | 68 | ||||
-rw-r--r-- | libavcodec/vaapi_h264.c | 3 |
16 files changed, 453 insertions, 437 deletions
diff --git a/libavcodec/h264.c b/libavcodec/h264.c index 224ba2fa27..9001fb1626 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 bfbcc81b45..238f98d73b 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 defe001de7..48d66e7ca3 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 9cc4441d9e..c30c00175c 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 5e7f3e7768..1865064ae7 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 1a80f76d96..3e29ca5d38 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 1f583dfbb9..2be235d7a0 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 7211c9d34c..72cab2fd2d 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 fde1a45be9..e1b112cc79 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 b86bf2b9b7..bc9809a157 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 f6cd1ca760..5fc1f0f19e 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 427930cfb1..96b2bc724a 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 0e3952d2c9..62f6a45a53 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 58f5ecc5a9..c4ffd7e72a 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 7031ee2de6..bf57f427ba 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 0925985235..b0c9c498f4 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; |