From 6668bc80b5eeae16c35302cfa6325219f7ce2da7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandra=20H=C3=A1jkov=C3=A1?= Date: Mon, 18 Apr 2016 10:56:03 +0200 Subject: [PATCH 1/5] mpc: Convert to the new bitstream reader --- libavcodec/mpc7.c | 73 +++++++++++++++++++++------------------- libavcodec/mpc8.c | 83 +++++++++++++++++++++++----------------------- libavformat/mpc8.c | 26 +++++++-------- 3 files changed, 94 insertions(+), 88 deletions(-) diff --git a/libavcodec/mpc7.c b/libavcodec/mpc7.c index 28b51922ec..5d749106de 100644 --- a/libavcodec/mpc7.c +++ b/libavcodec/mpc7.c @@ -28,8 +28,9 @@ #include "libavutil/channel_layout.h" #include "libavutil/internal.h" #include "libavutil/lfg.h" + #include "avcodec.h" -#include "get_bits.h" +#include "bitstream.h" #include "internal.h" #include "mpegaudiodsp.h" @@ -53,7 +54,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx) { int i, j; MPCContext *c = avctx->priv_data; - GetBitContext gb; + BitstreamContext bc; LOCAL_ALIGNED_16(uint8_t, buf, [16]); static int vlc_initialized = 0; @@ -78,18 +79,18 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx) ff_mpadsp_init(&c->mpadsp); c->bdsp.bswap_buf((uint32_t *) buf, (const uint32_t *) avctx->extradata, 4); ff_mpc_init(); - init_get_bits(&gb, buf, 128); + bitstream_init(&bc, buf, 128); - c->IS = get_bits1(&gb); - c->MSS = get_bits1(&gb); - c->maxbands = get_bits(&gb, 6); + c->IS = bitstream_read_bit(&bc); + c->MSS = bitstream_read_bit(&bc); + c->maxbands = bitstream_read(&bc, 6); if(c->maxbands >= BANDS){ av_log(avctx, AV_LOG_ERROR, "Too many bands: %i\n", c->maxbands); return -1; } - skip_bits_long(&gb, 88); - c->gapless = get_bits1(&gb); - c->lastframelen = get_bits(&gb, 11); + bitstream_skip(&bc, 88); + c->gapless = bitstream_read_bit(&bc); + c->lastframelen = bitstream_read(&bc, 11); av_log(avctx, AV_LOG_DEBUG, "IS: %d, MSS: %d, TG: %d, LFL: %d, bands: %d\n", c->IS, c->MSS, c->gapless, c->lastframelen, c->maxbands); c->frames_to_skip = 0; @@ -143,7 +144,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx) /** * Fill samples for given subband */ -static inline void idx_to_quant(MPCContext *c, GetBitContext *gb, int idx, int *dst) +static inline void idx_to_quant(MPCContext *c, BitstreamContext *bc, int idx, int *dst) { int i, i1, t; switch(idx){ @@ -153,43 +154,43 @@ static inline void idx_to_quant(MPCContext *c, GetBitContext *gb, int idx, int * } break; case 1: - i1 = get_bits1(gb); + i1 = bitstream_read_bit(bc); for(i = 0; i < SAMPLES_PER_BAND/3; i++){ - t = get_vlc2(gb, quant_vlc[0][i1].table, 9, 2); + t = bitstream_read_vlc(bc, quant_vlc[0][i1].table, 9, 2); *dst++ = mpc7_idx30[t]; *dst++ = mpc7_idx31[t]; *dst++ = mpc7_idx32[t]; } break; case 2: - i1 = get_bits1(gb); + i1 = bitstream_read_bit(bc); for(i = 0; i < SAMPLES_PER_BAND/2; i++){ - t = get_vlc2(gb, quant_vlc[1][i1].table, 9, 2); + t = bitstream_read_vlc(bc, quant_vlc[1][i1].table, 9, 2); *dst++ = mpc7_idx50[t]; *dst++ = mpc7_idx51[t]; } break; case 3: case 4: case 5: case 6: case 7: - i1 = get_bits1(gb); + i1 = bitstream_read_bit(bc); for(i = 0; i < SAMPLES_PER_BAND; i++) - *dst++ = get_vlc2(gb, quant_vlc[idx-1][i1].table, 9, 2) - mpc7_quant_vlc_off[idx-1]; + *dst++ = bitstream_read_vlc(bc, quant_vlc[idx - 1][i1].table, 9, 2) - mpc7_quant_vlc_off[idx - 1]; break; case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17: t = (1 << (idx - 2)) - 1; for(i = 0; i < SAMPLES_PER_BAND; i++) - *dst++ = get_bits(gb, idx - 1) - t; + *dst++ = bitstream_read(bc, idx - 1) - t; break; default: // case 0 and -2..-17 return; } } -static int get_scale_idx(GetBitContext *gb, int ref) +static int get_scale_idx(BitstreamContext *bc, int ref) { - int t = get_vlc2(gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7; + int t = bitstream_read_vlc(bc, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7; if (t == 8) - return get_bits(gb, 6); + return bitstream_read(bc, 6); return av_clip_uintp2(ref + t, 7); } @@ -200,7 +201,7 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data, const uint8_t *buf = avpkt->data; int buf_size; MPCContext *c = avctx->priv_data; - GetBitContext gb; + BitstreamContext bc; int i, ch; int mb = -1; Band *bands = c->bands; @@ -237,45 +238,49 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data, return AVERROR(ENOMEM); c->bdsp.bswap_buf((uint32_t *) c->bits, (const uint32_t *) buf, buf_size >> 2); - init_get_bits(&gb, c->bits, buf_size * 8); - skip_bits_long(&gb, skip); + bitstream_init(&bc, c->bits, buf_size * 8); + bitstream_skip(&bc, skip); /* read subband indexes */ for(i = 0; i <= c->maxbands; i++){ for(ch = 0; ch < 2; ch++){ int t = 4; - if(i) t = get_vlc2(&gb, hdr_vlc.table, MPC7_HDR_BITS, 1) - 5; - if(t == 4) bands[i].res[ch] = get_bits(&gb, 4); + if (i) + t = bitstream_read_vlc(&bc, hdr_vlc.table, MPC7_HDR_BITS, 1) - 5; + if (t == 4) + bands[i].res[ch] = bitstream_read(&bc, 4); else bands[i].res[ch] = av_clip(bands[i-1].res[ch] + t, 0, 17); } if(bands[i].res[0] || bands[i].res[1]){ mb = i; - if(c->MSS) bands[i].msf = get_bits1(&gb); + if (c->MSS) + bands[i].msf = bitstream_read_bit(&bc); } } /* get scale indexes coding method */ for(i = 0; i <= mb; i++) for(ch = 0; ch < 2; ch++) - if(bands[i].res[ch]) bands[i].scfi[ch] = get_vlc2(&gb, scfi_vlc.table, MPC7_SCFI_BITS, 1); + if (bands[i].res[ch]) + bands[i].scfi[ch] = bitstream_read_vlc(&bc, scfi_vlc.table, MPC7_SCFI_BITS, 1); /* get scale indexes */ for(i = 0; i <= mb; i++){ for(ch = 0; ch < 2; ch++){ if(bands[i].res[ch]){ bands[i].scf_idx[ch][2] = c->oldDSCF[ch][i]; - bands[i].scf_idx[ch][0] = get_scale_idx(&gb, bands[i].scf_idx[ch][2]); + bands[i].scf_idx[ch][0] = get_scale_idx(&bc, bands[i].scf_idx[ch][2]); switch(bands[i].scfi[ch]){ case 0: - bands[i].scf_idx[ch][1] = get_scale_idx(&gb, bands[i].scf_idx[ch][0]); - bands[i].scf_idx[ch][2] = get_scale_idx(&gb, bands[i].scf_idx[ch][1]); + bands[i].scf_idx[ch][1] = get_scale_idx(&bc, bands[i].scf_idx[ch][0]); + bands[i].scf_idx[ch][2] = get_scale_idx(&bc, bands[i].scf_idx[ch][1]); break; case 1: - bands[i].scf_idx[ch][1] = get_scale_idx(&gb, bands[i].scf_idx[ch][0]); + bands[i].scf_idx[ch][1] = get_scale_idx(&bc, bands[i].scf_idx[ch][0]); bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1]; break; case 2: bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0]; - bands[i].scf_idx[ch][2] = get_scale_idx(&gb, bands[i].scf_idx[ch][1]); + bands[i].scf_idx[ch][2] = get_scale_idx(&bc, bands[i].scf_idx[ch][1]); break; case 3: bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0]; @@ -290,11 +295,11 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data, off = 0; for(i = 0; i < BANDS; i++, off += SAMPLES_PER_BAND) for(ch = 0; ch < 2; ch++) - idx_to_quant(c, &gb, bands[i].res[ch], c->Q[ch] + off); + idx_to_quant(c, &bc, bands[i].res[ch], c->Q[ch] + off); ff_mpc_dequantize_and_synth(c, mb, (int16_t **)frame->extended_data, 2); - bits_used = get_bits_count(&gb); + bits_used = bitstream_tell(&bc); bits_avail = buf_size * 8; if (!last_frame && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))) { av_log(avctx, AV_LOG_ERROR, "Error decoding frame: used %i of %i bits\n", bits_used, bits_avail); diff --git a/libavcodec/mpc8.c b/libavcodec/mpc8.c index 84dbb61f7d..cf621afb12 100644 --- a/libavcodec/mpc8.c +++ b/libavcodec/mpc8.c @@ -27,8 +27,9 @@ #include "libavutil/channel_layout.h" #include "libavutil/lfg.h" + #include "avcodec.h" -#include "get_bits.h" +#include "bitstream.h" #include "internal.h" #include "mpegaudiodsp.h" @@ -42,22 +43,22 @@ static VLC q1_vlc, q2_vlc[2], q3_vlc[2], quant_vlc[4][2], q9up_vlc; static const int q3_offsets[2] = { MPC8_Q3_OFFSET, MPC8_Q4_OFFSET }; static const int quant_offsets[6] = { MPC8_Q5_OFFSET, MPC8_Q6_OFFSET, MPC8_Q7_OFFSET, MPC8_Q8_OFFSET }; -static inline int mpc8_dec_base(GetBitContext *gb, int k, int n) +static inline int mpc8_dec_base(BitstreamContext *bc, int k, int n) { int len = mpc8_cnk_len[k-1][n-1] - 1; - int code = len ? get_bits_long(gb, len) : 0; + int code = len ? bitstream_read(bc, len) : 0; if (code >= mpc8_cnk_lost[k-1][n-1]) - code = ((code << 1) | get_bits1(gb)) - mpc8_cnk_lost[k-1][n-1]; + code = ((code << 1) | bitstream_read_bit(bc)) - mpc8_cnk_lost[k - 1][n - 1]; return code; } -static inline int mpc8_dec_enum(GetBitContext *gb, int k, int n) +static inline int mpc8_dec_enum(BitstreamContext *bc, int k, int n) { int bits = 0; const uint32_t * C = mpc8_cnk[k-1]; - int code = mpc8_dec_base(gb, k, n); + int code = mpc8_dec_base(bc, k, n); do { n--; @@ -72,18 +73,18 @@ static inline int mpc8_dec_enum(GetBitContext *gb, int k, int n) return bits; } -static inline int mpc8_get_mod_golomb(GetBitContext *gb, int m) +static inline int mpc8_get_mod_golomb(BitstreamContext *bc, int m) { if(mpc8_cnk_len[0][m] < 1) return 0; - return mpc8_dec_base(gb, 1, m+1); + return mpc8_dec_base(bc, 1, m + 1); } -static int mpc8_get_mask(GetBitContext *gb, int size, int t) +static int mpc8_get_mask(BitstreamContext *bc, int size, int t) { int mask = 0; if(t && t != size) - mask = mpc8_dec_enum(gb, FFMIN(t, size - t), size); + mask = mpc8_dec_enum(bc, FFMIN(t, size - t), size); if((t << 1) > size) mask = ~mask; return mask; @@ -97,7 +98,7 @@ static av_cold int mpc8_decode_init(AVCodecContext * avctx) { int i; MPCContext *c = avctx->priv_data; - GetBitContext gb; + BitstreamContext bc; static int vlc_initialized = 0; int channels; @@ -122,17 +123,17 @@ static av_cold int mpc8_decode_init(AVCodecContext * avctx) ff_mpc_init(); - init_get_bits(&gb, avctx->extradata, 16); + bitstream_init(&bc, avctx->extradata, 16); - skip_bits(&gb, 3);//sample rate - c->maxbands = get_bits(&gb, 5) + 1; - channels = get_bits(&gb, 4) + 1; + bitstream_skip(&bc, 3); // sample rate + c->maxbands = bitstream_read(&bc, 5) + 1; + channels = bitstream_read(&bc, 4) + 1; if (channels > 2) { avpriv_request_sample(avctx, "Multichannel MPC SV8"); return AVERROR_PATCHWELCOME; } - c->MSS = get_bits1(&gb); - c->frames = 1 << (get_bits(&gb, 3) * 2); + c->MSS = bitstream_read_bit(&bc); + c->frames = 1 << (bitstream_read(&bc, 3) * 2); avctx->sample_fmt = AV_SAMPLE_FMT_S16P; avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; @@ -238,7 +239,7 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPCContext *c = avctx->priv_data; - GetBitContext gb2, *gb = &gb2; + BitstreamContext bc2, *bc = &bc2; int i, j, k, ch, cnt, res, t; Band *bands = c->bands; int off; @@ -258,13 +259,13 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, memset(c->Q, 0, sizeof(c->Q)); c->last_bits_used = 0; } - init_get_bits(gb, buf, buf_size * 8); - skip_bits(gb, c->last_bits_used & 7); + bitstream_init(bc, buf, buf_size * 8); + bitstream_skip(bc, c->last_bits_used & 7); if(keyframe) - maxband = mpc8_get_mod_golomb(gb, c->maxbands + 1); + maxband = mpc8_get_mod_golomb(bc, c->maxbands + 1); else{ - maxband = c->last_max_band + get_vlc2(gb, band_vlc.table, MPC8_BANDS_BITS, 2); + maxband = c->last_max_band + bitstream_read_vlc(bc, band_vlc.table, MPC8_BANDS_BITS, 2); if(maxband > 32) maxband -= 33; } if(maxband > c->maxbands + 1) @@ -276,7 +277,7 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, last[0] = last[1] = 0; for(i = maxband - 1; i >= 0; i--){ for(ch = 0; ch < 2; ch++){ - last[ch] = get_vlc2(gb, res_vlc[last[ch] > 2].table, MPC8_RES_BITS, 2) + last[ch]; + last[ch] = bitstream_read_vlc(bc, res_vlc[last[ch] > 2].table, MPC8_RES_BITS, 2) + last[ch]; if(last[ch] > 15) last[ch] -= 17; bands[i].res[ch] = last[ch]; } @@ -288,8 +289,8 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, for(i = 0; i < maxband; i++) if(bands[i].res[0] || bands[i].res[1]) cnt++; - t = mpc8_get_mod_golomb(gb, cnt); - mask = mpc8_get_mask(gb, cnt, t); + t = mpc8_get_mod_golomb(bc, cnt); + mask = mpc8_get_mask(bc, cnt, t); for(i = maxband - 1; i >= 0; i--) if(bands[i].res[0] || bands[i].res[1]){ bands[i].msf = mask & 1; @@ -309,7 +310,7 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, if(bands[i].res[0] || bands[i].res[1]){ cnt = !!bands[i].res[0] + !!bands[i].res[1] - 1; if(cnt >= 0){ - t = get_vlc2(gb, scfi_vlc[cnt].table, scfi_vlc[cnt].bits, 1); + t = bitstream_read_vlc(bc, scfi_vlc[cnt].table, scfi_vlc[cnt].bits, 1); if(bands[i].res[0]) bands[i].scfi[0] = t >> (2 * cnt); if(bands[i].res[1]) bands[i].scfi[1] = t & 3; } @@ -321,21 +322,21 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, if(!bands[i].res[ch]) continue; if(c->oldDSCF[ch][i]){ - bands[i].scf_idx[ch][0] = get_bits(gb, 7) - 6; + bands[i].scf_idx[ch][0] = bitstream_read(bc, 7) - 6; c->oldDSCF[ch][i] = 0; }else{ - t = get_vlc2(gb, dscf_vlc[1].table, MPC8_DSCF1_BITS, 2); + t = bitstream_read_vlc(bc, dscf_vlc[1].table, MPC8_DSCF1_BITS, 2); if(t == 64) - t += get_bits(gb, 6); + t += bitstream_read(bc, 6); bands[i].scf_idx[ch][0] = ((bands[i].scf_idx[ch][2] + t - 25) & 0x7F) - 6; } for(j = 0; j < 2; j++){ if((bands[i].scfi[ch] << j) & 2) bands[i].scf_idx[ch][j + 1] = bands[i].scf_idx[ch][j]; else{ - t = get_vlc2(gb, dscf_vlc[0].table, MPC8_DSCF0_BITS, 2); + t = bitstream_read_vlc(bc, dscf_vlc[0].table, MPC8_DSCF0_BITS, 2); if(t == 31) - t = 64 + get_bits(gb, 6); + t = 64 + bitstream_read(bc, 6); bands[i].scf_idx[ch][j + 1] = ((bands[i].scf_idx[ch][j] + t - 25) & 0x7F) - 6; } } @@ -354,16 +355,16 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, break; case 1: for(j = 0; j < SAMPLES_PER_BAND; j += SAMPLES_PER_BAND / 2){ - cnt = get_vlc2(gb, q1_vlc.table, MPC8_Q1_BITS, 2); - t = mpc8_get_mask(gb, 18, cnt); + cnt = bitstream_read_vlc(bc, q1_vlc.table, MPC8_Q1_BITS, 2); + t = mpc8_get_mask(bc, 18, cnt); for(k = 0; k < SAMPLES_PER_BAND / 2; k++, t <<= 1) - c->Q[ch][off + j + k] = (t & 0x20000) ? (get_bits1(gb) << 1) - 1 : 0; + c->Q[ch][off + j + k] = (t & 0x20000) ? (bitstream_read_bit(bc) << 1) - 1 : 0; } break; case 2: cnt = 6;//2*mpc8_thres[res] for(j = 0; j < SAMPLES_PER_BAND; j += 3){ - t = get_vlc2(gb, q2_vlc[cnt > 3].table, MPC8_Q2_BITS, 2); + t = bitstream_read_vlc(bc, q2_vlc[cnt > 3].table, MPC8_Q2_BITS, 2); c->Q[ch][off + j + 0] = mpc8_idx50[t]; c->Q[ch][off + j + 1] = mpc8_idx51[t]; c->Q[ch][off + j + 2] = mpc8_idx52[t]; @@ -373,7 +374,7 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, case 3: case 4: for(j = 0; j < SAMPLES_PER_BAND; j += 2){ - t = get_vlc2(gb, q3_vlc[res - 3].table, MPC8_Q3_BITS, 2) + q3_offsets[res - 3]; + t = bitstream_read_vlc(bc, q3_vlc[res - 3].table, MPC8_Q3_BITS, 2) + q3_offsets[res - 3]; c->Q[ch][off + j + 1] = t >> 4; c->Q[ch][off + j + 0] = (t & 8) ? (t & 0xF) - 16 : (t & 0xF); } @@ -384,17 +385,17 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, case 8: cnt = 2 * mpc8_thres[res]; for(j = 0; j < SAMPLES_PER_BAND; j++){ - t = get_vlc2(gb, quant_vlc[res - 5][cnt > mpc8_thres[res]].table, quant_vlc[res - 5][cnt > mpc8_thres[res]].bits, 2) + quant_offsets[res - 5]; + t = bitstream_read_vlc(bc, quant_vlc[res - 5][cnt > mpc8_thres[res]].table, quant_vlc[res - 5][cnt > mpc8_thres[res]].bits, 2) + quant_offsets[res - 5]; c->Q[ch][off + j] = t; cnt = (cnt >> 1) + FFABS(c->Q[ch][off + j]); } break; default: for(j = 0; j < SAMPLES_PER_BAND; j++){ - c->Q[ch][off + j] = get_vlc2(gb, q9up_vlc.table, MPC8_Q9UP_BITS, 2); + c->Q[ch][off + j] = bitstream_read_vlc(bc, q9up_vlc.table, MPC8_Q9UP_BITS, 2); if(res != 9){ c->Q[ch][off + j] <<= res - 9; - c->Q[ch][off + j] |= get_bits(gb, res - 9); + c->Q[ch][off + j] |= bitstream_read(bc, res - 9); } c->Q[ch][off + j] -= (1 << (res - 2)) - 1; } @@ -408,8 +409,8 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data, c->cur_frame++; - c->last_bits_used = get_bits_count(gb); - if(get_bits_left(gb) < 8) // we have only padding left + c->last_bits_used = bitstream_tell(bc); + if (bitstream_bits_left(bc) < 8) // we have only padding left c->last_bits_used = buf_size << 3; if(c->cur_frame >= c->frames) c->cur_frame = 0; diff --git a/libavformat/mpc8.c b/libavformat/mpc8.c index 132e3cd907..c4027e5d88 100644 --- a/libavformat/mpc8.c +++ b/libavformat/mpc8.c @@ -19,8 +19,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "libavcodec/get_bits.h" -#include "libavcodec/unary_legacy.h" +#include "libavcodec/bitstream.h" +#include "libavcodec/unary.h" #include "apetag.h" #include "avformat.h" @@ -107,17 +107,17 @@ static int mpc8_probe(AVProbeData *p) return 0; } -static inline int64_t gb_get_v(GetBitContext *gb) +static inline int64_t gb_get_v(BitstreamContext *bc) { int64_t v = 0; int bits = 0; - while(get_bits1(gb) && bits < 64-7){ + while (bitstream_read_bit(bc) && bits < 64 - 7) { v <<= 7; - v |= get_bits(gb, 7); + v |= bitstream_read(bc, 7); bits += 7; } v <<= 7; - v |= get_bits(gb, 7); + v |= bitstream_read(bc, 7); return v; } @@ -138,7 +138,7 @@ static void mpc8_parse_seektable(AVFormatContext *s, int64_t off) int64_t size, pos, ppos[2]; uint8_t *buf; int i, t, seekd; - GetBitContext gb; + BitstreamContext bc; if (s->nb_streams == 0) { av_log(s, AV_LOG_ERROR, "No stream added before parsing seek table\n"); @@ -158,21 +158,21 @@ static void mpc8_parse_seektable(AVFormatContext *s, int64_t off) if(!(buf = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE))) return; avio_read(s->pb, buf, size); - init_get_bits(&gb, buf, size * 8); - size = gb_get_v(&gb); + bitstream_init8(&bc, buf, size); + size = gb_get_v(&bc); if(size > UINT_MAX/4 || size > c->samples/1152){ av_log(s, AV_LOG_ERROR, "Seek table is too big\n"); return; } - seekd = get_bits(&gb, 4); + seekd = bitstream_read(&bc, 4); for(i = 0; i < 2; i++){ - pos = gb_get_v(&gb) + c->header_pos; + pos = gb_get_v(&bc) + c->header_pos; ppos[1 - i] = pos; av_add_index_entry(s->streams[0], pos, i, 0, 0, AVINDEX_KEYFRAME); } for(; i < size; i++){ - t = get_unary(&gb, 1, 33) << 12; - t += get_bits(&gb, 12); + t = get_unary(&bc, 1, 33) << 12; + t += bitstream_read(&bc, 12); if(t & 1) t = -(t & ~1); pos = (t >> 1) + ppos[0]*2 - ppos[1]; From e7f24c9ffc6a12a37016914859a74c3127868996 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandra=20H=C3=A1jkov=C3=A1?= Date: Fri, 15 Apr 2016 10:45:11 +0200 Subject: [PATCH 2/5] wavpack: Convert to the new bitstream reader --- libavcodec/wavpack.c | 92 ++++++++++++++++++++++---------------------- 1 file changed, 46 insertions(+), 46 deletions(-) diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index b8adb3d484..66430b90e3 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -23,10 +23,10 @@ #define BITSTREAM_READER_LE #include "avcodec.h" +#include "bitstream.h" #include "bytestream.h" -#include "get_bits.h" #include "internal.h" -#include "unary_legacy.h" +#include "unary.h" /** * @file @@ -109,10 +109,10 @@ typedef struct WavpackFrameContext { int stereo, stereo_in; int joint; uint32_t CRC; - GetBitContext gb; + BitstreamContext bc; int got_extra_bits; uint32_t crc_extra_bits; - GetBitContext gb_extra_bits; + BitstreamContext bc_extra_bits; int data_size; // in bits int samples; int terms; @@ -240,7 +240,7 @@ static av_always_inline int wp_log2(int32_t val) } \ } -static av_always_inline int get_tail(GetBitContext *gb, int k) +static av_always_inline int get_tail(BitstreamContext *bc, int k) { int p, e, res; @@ -248,9 +248,9 @@ static av_always_inline int get_tail(GetBitContext *gb, int k) return 0; p = av_log2(k); e = (1 << (p + 1)) - k - 1; - res = get_bitsz(gb, p); + res = bitstream_read(bc, p); if (res >= e) - res = (res << 1) - e + get_bits1(gb); + res = (res << 1) - e + bitstream_read_bit(bc); return res; } @@ -288,7 +288,7 @@ static void update_error_limit(WavpackFrameContext *ctx) } } -static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, +static int wv_get_value(WavpackFrameContext *ctx, BitstreamContext *bc, int channel, int *last) { int t, t2; @@ -306,13 +306,13 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, return 0; } } else { - t = get_unary_0_33(gb); + t = get_unary_0_33(bc); if (t >= 2) { - if (get_bits_left(gb) < t - 1) + if (bitstream_bits_left(bc) < t - 1) goto error; - t = get_bits(gb, t - 1) | (1 << (t - 1)); + t = bitstream_read(bc, t - 1) | (1 << (t - 1)); } else { - if (get_bits_left(gb) < 0) + if (bitstream_bits_left(bc) < 0) goto error; } ctx->zeroes = t; @@ -329,19 +329,19 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, t = 0; ctx->zero = 0; } else { - t = get_unary_0_33(gb); - if (get_bits_left(gb) < 0) + t = get_unary_0_33(bc); + if (bitstream_bits_left(bc) < 0) goto error; if (t == 16) { - t2 = get_unary_0_33(gb); + t2 = get_unary_0_33(bc); if (t2 < 2) { - if (get_bits_left(gb) < 0) + if (bitstream_bits_left(bc) < 0) goto error; t += t2; } else { - if (get_bits_left(gb) < t2 - 1) + if (bitstream_bits_left(bc) < t2 - 1) goto error; - t += get_bits(gb, t2 - 1) | (1 << (t2 - 1)); + t += bitstream_read(bc, t2 - 1) | (1 << (t2 - 1)); } } @@ -381,15 +381,15 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, INC_MED(2); } if (!c->error_limit) { - ret = base + get_tail(gb, add); - if (get_bits_left(gb) <= 0) + ret = base + get_tail(bc, add); + if (bitstream_bits_left(bc) <= 0) goto error; } else { int mid = (base * 2 + add + 1) >> 1; while (add > c->error_limit) { - if (get_bits_left(gb) <= 0) + if (bitstream_bits_left(bc) <= 0) goto error; - if (get_bits1(gb)) { + if (bitstream_read_bit(bc)) { add -= (mid - base); base = mid; } else @@ -398,7 +398,7 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, } ret = mid; } - sign = get_bits1(gb); + sign = bitstream_read_bit(bc); if (ctx->hybrid_bitrate) c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level); return sign ? ~ret : ret; @@ -417,8 +417,8 @@ static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, S <<= s->extra_bits; if (s->got_extra_bits && - get_bits_left(&s->gb_extra_bits) >= s->extra_bits) { - S |= get_bits(&s->gb_extra_bits, s->extra_bits); + bitstream_bits_left(&s->bc_extra_bits) >= s->extra_bits) { + S |= bitstream_read(&s->bc_extra_bits, s->extra_bits); *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16); } } @@ -444,7 +444,7 @@ static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S) if (s->got_extra_bits) { const int max_bits = 1 + 23 + 8 + 1; - const int left_bits = get_bits_left(&s->gb_extra_bits); + const int left_bits = bitstream_bits_left(&s->bc_extra_bits); if (left_bits + 8 * AV_INPUT_BUFFER_PADDING_SIZE < max_bits) return 0.0; @@ -456,8 +456,8 @@ static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S) if (sign) S = -S; if (S >= 0x1000000) { - if (s->got_extra_bits && get_bits1(&s->gb_extra_bits)) - S = get_bits(&s->gb_extra_bits, 23); + if (s->got_extra_bits && bitstream_read_bit(&s->bc_extra_bits)) + S = bitstream_read(&s->bc_extra_bits, 23); else S = 0; exp = 255; @@ -473,11 +473,11 @@ static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S) if ((s->float_flag & WV_FLT_SHIFT_ONES) || (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && - get_bits1(&s->gb_extra_bits))) { + bitstream_read_bit(&s->bc_extra_bits))) { S |= (1 << shift) - 1; } else if (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)) { - S |= get_bits(&s->gb_extra_bits, shift); + S |= bitstream_read(&s->bc_extra_bits, shift); } } } else { @@ -488,14 +488,14 @@ static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S) sign = 0; exp = 0; if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) { - if (get_bits1(&s->gb_extra_bits)) { - S = get_bits(&s->gb_extra_bits, 23); + if (bitstream_read_bit(&s->bc_extra_bits)) { + S = bitstream_read(&s->bc_extra_bits, 23); if (s->float_max_exp >= 25) - exp = get_bits(&s->gb_extra_bits, 8); - sign = get_bits1(&s->gb_extra_bits); + exp = bitstream_read(&s->bc_extra_bits, 8); + sign = bitstream_read_bit(&s->bc_extra_bits); } else { if (s->float_flag & WV_FLT_ZERO_SIGN) - sign = get_bits1(&s->gb_extra_bits); + sign = bitstream_read_bit(&s->bc_extra_bits); } } } @@ -527,7 +527,7 @@ static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc, return 0; } -static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, +static inline int wv_unpack_stereo(WavpackFrameContext *s, BitstreamContext *bc, void *dst_l, void *dst_r, const int type) { int i, j, count = 0; @@ -545,10 +545,10 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, s->one = s->zero = s->zeroes = 0; do { - L = wv_get_value(s, gb, 0, &last); + L = wv_get_value(s, bc, 0, &last); if (last) break; - R = wv_get_value(s, gb, 1, &last); + R = wv_get_value(s, bc, 1, &last); if (last) break; for (i = 0; i < s->terms; i++) { @@ -645,7 +645,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, return 0; } -static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, +static inline int wv_unpack_mono(WavpackFrameContext *s, BitstreamContext *bc, void *dst, const int type) { int i, j, count = 0; @@ -660,7 +660,7 @@ static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, s->one = s->zero = s->zeroes = 0; do { - T = wv_get_value(s, gb, 0, &last); + T = wv_get_value(s, bc, 0, &last); S = 0; if (last) break; @@ -990,7 +990,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, case WP_ID_DATA: s->sc.offset = bytestream2_tell(&gb); s->sc.size = size * 8; - init_get_bits(&s->gb, gb.buffer, size * 8); + bitstream_init8(&s->bc, gb.buffer, size); s->data_size = size * 8; bytestream2_skip(&gb, size); got_bs = 1; @@ -1004,8 +1004,8 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, } s->extra_sc.offset = bytestream2_tell(&gb); s->extra_sc.size = size * 8; - init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8); - s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32); + bitstream_init8(&s->bc_extra_bits, gb.buffer, size); + s->crc_extra_bits = bitstream_read(&s->bc_extra_bits, 32); bytestream2_skip(&gb, size); s->got_extra_bits = 1; break; @@ -1084,7 +1084,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, return AVERROR_INVALIDDATA; } if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) { - const int size = get_bits_left(&s->gb_extra_bits); + const int size = bitstream_bits_left(&s->bc_extra_bits); const int wanted = s->samples * s->extra_bits << s->stereo_in; if (size < wanted) { av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n"); @@ -1134,11 +1134,11 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, wc->ch_offset += 1 + s->stereo; if (s->stereo_in) { - ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt); + ret = wv_unpack_stereo(s, &s->bc, samples_l, samples_r, avctx->sample_fmt); if (ret < 0) return ret; } else { - ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt); + ret = wv_unpack_mono(s, &s->bc, samples_l, avctx->sample_fmt); if (ret < 0) return ret; From b061f298f7f2c227c12dd76a15041ec0a66eeca0 Mon Sep 17 00:00:00 2001 From: Diego Biurrun Date: Tue, 21 Jun 2016 14:39:18 +0200 Subject: [PATCH 3/5] truemotion2rt: Convert to the new bitstream reader --- libavcodec/truemotion2rt.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/libavcodec/truemotion2rt.c b/libavcodec/truemotion2rt.c index ed7fb68899..e6dbad8fcf 100644 --- a/libavcodec/truemotion2rt.c +++ b/libavcodec/truemotion2rt.c @@ -29,11 +29,11 @@ #define BITSTREAM_READER_LE #include "avcodec.h" -#include "get_bits.h" +#include "bitstream.h" #include "internal.h" typedef struct TrueMotion2RTContext { - GetBitContext gb; + BitstreamContext bc; int delta_size; int hscale; } TrueMotion2RTContext; @@ -107,7 +107,7 @@ static int truemotion2rt_decode_frame(AVCodecContext *avctx, void *data, { TrueMotion2RTContext *s = avctx->priv_data; AVFrame * const p = data; - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; uint8_t *dst; int x, y, delta_mode; int ret; @@ -116,7 +116,7 @@ static int truemotion2rt_decode_frame(AVCodecContext *avctx, void *data, if (ret < 0) return ret; - ret = init_get_bits8(gb, avpkt->data + ret, avpkt->size - ret); + ret = bitstream_init8(bc, avpkt->data + ret, avpkt->size - ret); if (ret < 0) return ret; @@ -124,13 +124,13 @@ static int truemotion2rt_decode_frame(AVCodecContext *avctx, void *data, if (ret < 0) return ret; - skip_bits(gb, 32); + bitstream_skip(bc, 32); delta_mode = s->delta_size - 2; dst = p->data[0]; for (y = 0; y < avctx->height; y++) { int diff = 0; for (x = 0; x < avctx->width; x += s->hscale) { - diff += delta_tabs[delta_mode][get_bits(gb, s->delta_size)]; + diff += delta_tabs[delta_mode][bitstream_read(bc, s->delta_size)]; dst[x] = av_clip_uint8((y ? dst[x - p->linesize[0]] : 0) + diff); } dst += p->linesize[0]; @@ -156,7 +156,7 @@ static int truemotion2rt_decode_frame(AVCodecContext *avctx, void *data, for (y = 0; y < avctx->height >> 2; y++) { int diff = 0; for (x = 0; x < avctx->width >> 2; x += s->hscale) { - diff += delta_tabs[delta_mode][get_bits(gb, s->delta_size)]; + diff += delta_tabs[delta_mode][bitstream_read(bc, s->delta_size)]; dst[x] = av_clip_uint8((y ? dst[x - p->linesize[1]] : 128) + diff); } dst += p->linesize[1]; @@ -182,7 +182,7 @@ static int truemotion2rt_decode_frame(AVCodecContext *avctx, void *data, for (y = 0; y < avctx->height >> 2; y++) { int diff = 0; for (x = 0; x < avctx->width >> 2; x += s->hscale) { - diff += delta_tabs[delta_mode][get_bits(gb, s->delta_size)]; + diff += delta_tabs[delta_mode][bitstream_read(bc, s->delta_size)]; dst[x] = av_clip_uint8((y ? dst[x - p->linesize[2]] : 128) + diff); } dst += p->linesize[2]; From 2e0e150144d6c8fe641a45141638559fbf4d9642 Mon Sep 17 00:00:00 2001 From: Diego Biurrun Date: Tue, 21 Jun 2016 14:35:53 +0200 Subject: [PATCH 4/5] magicyuv: Convert to the new bitstream reader --- libavcodec/magicyuv.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/libavcodec/magicyuv.c b/libavcodec/magicyuv.c index 310ead4b06..027143fc87 100644 --- a/libavcodec/magicyuv.c +++ b/libavcodec/magicyuv.c @@ -22,14 +22,15 @@ #include #include -#include "../libavutil/pixdesc.h" +#include "libavutil/pixdesc.h" #include "avcodec.h" +#include "bitstream.h" #include "bytestream.h" -#include "get_bits.h" #include "huffyuvdsp.h" #include "internal.h" #include "thread.h" +#include "vlc.h" typedef struct Slice { uint32_t start; @@ -108,7 +109,7 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata, int interlaced = s->interlaced; AVFrame *p = s->p; int i, k, x; - GetBitContext gb; + BitstreamContext bc; uint8_t *dst; for (i = 0; i < s->planes; i++) { @@ -119,20 +120,20 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata, ptrdiff_t fake_stride = p->linesize[i] * (1 + interlaced); ptrdiff_t stride = p->linesize[i]; int flags, pred; - int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start, - s->slices[i][j].size); + int ret = bitstream_init8(&bc, s->buf + s->slices[i][j].start, + s->slices[i][j].size); if (ret < 0) return ret; - flags = get_bits(&gb, 8); - pred = get_bits(&gb, 8); + flags = bitstream_read(&bc, 8); + pred = bitstream_read(&bc, 8); dst = p->data[i] + j * sheight * stride; if (flags & 1) { for (k = 0; k < height; k++) { for (x = 0; x < width; x++) - dst[x] = get_bits(&gb, 8); + dst[x] = bitstream_read(&bc, 8); dst += stride; } @@ -140,10 +141,10 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata, for (k = 0; k < height; k++) { for (x = 0; x < width; x++) { int pix; - if (get_bits_left(&gb) <= 0) + if (bitstream_bits_left(&bc) <= 0) return AVERROR_INVALIDDATA; - pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3); + pix = bitstream_read_vlc(&bc, s->vlc[i].table, s->vlc[i].bits, 3); if (pix < 0) return AVERROR_INVALIDDATA; @@ -238,7 +239,7 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data, ThreadFrame frame = { .f = data }; AVFrame *p = data; GetByteContext gbyte; - GetBitContext gbit; + BitstreamContext bc; uint32_t first_offset, offset, next_offset, header_size, slice_width; int width, height, format, version, table_size; int ret, i, j, k; @@ -370,16 +371,16 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data, if (table_size < 2) return AVERROR_INVALIDDATA; - ret = init_get_bits8(&gbit, avpkt->data + bytestream2_tell(&gbyte), table_size); + ret = bitstream_init8(&bc, avpkt->data + bytestream2_tell(&gbyte), table_size); if (ret < 0) return ret; memset(s->len, 0, sizeof(s->len)); j = i = 0; - while (get_bits_left(&gbit) >= 8) { - int b = get_bits(&gbit, 4); - int x = get_bits(&gbit, 4); - int l = get_bitsz(&gbit, b) + 1; + while (bitstream_bits_left(&bc) >= 8) { + int b = bitstream_read(&bc, 4); + int x = bitstream_read(&bc, 4); + int l = bitstream_read(&bc, b) + 1; for (k = 0; k < l; k++) if (j + k < 256) From 381a4e31a6b801a046e38b0e2b08fb61499157a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandra=20H=C3=A1jkov=C3=A1?= Date: Wed, 13 Apr 2016 21:00:34 +0200 Subject: [PATCH 5/5] tak: Convert to the new bitstream reader --- libavcodec/tak.c | 49 +++++++------ libavcodec/tak.h | 10 +-- libavcodec/tak_parser.c | 15 ++-- libavcodec/takdec.c | 158 ++++++++++++++++++++-------------------- libavformat/takdec.c | 13 ++-- 5 files changed, 125 insertions(+), 120 deletions(-) diff --git a/libavcodec/tak.c b/libavcodec/tak.c index bd82c3d193..c90e55ad6a 100644 --- a/libavcodec/tak.c +++ b/libavcodec/tak.c @@ -24,6 +24,7 @@ #include "libavutil/intreadwrite.h" #define BITSTREAM_READER_LE +#include "bitstream.h" #include "tak.h" static const uint16_t frame_duration_type_quants[] = { @@ -85,30 +86,30 @@ int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size) return 0; } -void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s) +void avpriv_tak_parse_streaminfo(BitstreamContext *bc, TAKStreamInfo *s) { uint64_t channel_mask = 0; int frame_type, i; - s->codec = get_bits(gb, TAK_ENCODER_CODEC_BITS); - skip_bits(gb, TAK_ENCODER_PROFILE_BITS); + s->codec = bitstream_read(bc, TAK_ENCODER_CODEC_BITS); + bitstream_skip(bc, TAK_ENCODER_PROFILE_BITS); - frame_type = get_bits(gb, TAK_SIZE_FRAME_DURATION_BITS); - s->samples = get_bits64(gb, TAK_SIZE_SAMPLES_NUM_BITS); + frame_type = bitstream_read(bc, TAK_SIZE_FRAME_DURATION_BITS); + s->samples = bitstream_read_63(bc, TAK_SIZE_SAMPLES_NUM_BITS); - s->data_type = get_bits(gb, TAK_FORMAT_DATA_TYPE_BITS); - s->sample_rate = get_bits(gb, TAK_FORMAT_SAMPLE_RATE_BITS) + + s->data_type = bitstream_read(bc, TAK_FORMAT_DATA_TYPE_BITS); + s->sample_rate = bitstream_read(bc, TAK_FORMAT_SAMPLE_RATE_BITS) + TAK_SAMPLE_RATE_MIN; - s->bps = get_bits(gb, TAK_FORMAT_BPS_BITS) + + s->bps = bitstream_read(bc, TAK_FORMAT_BPS_BITS) + TAK_BPS_MIN; - s->channels = get_bits(gb, TAK_FORMAT_CHANNEL_BITS) + + s->channels = bitstream_read(bc, TAK_FORMAT_CHANNEL_BITS) + TAK_CHANNELS_MIN; - if (get_bits1(gb)) { - skip_bits(gb, TAK_FORMAT_VALID_BITS); - if (get_bits1(gb)) { + if (bitstream_read_bit(bc)) { + bitstream_skip(bc, TAK_FORMAT_VALID_BITS); + if (bitstream_read_bit(bc)) { for (i = 0; i < s->channels; i++) { - int value = get_bits(gb, TAK_FORMAT_CH_LAYOUT_BITS); + int value = bitstream_read(bc, TAK_FORMAT_CH_LAYOUT_BITS); if (value > 0 && value <= 18) channel_mask |= 1 << (value - 1); @@ -120,33 +121,33 @@ void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s) s->frame_samples = tak_get_nb_samples(s->sample_rate, frame_type); } -int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, +int ff_tak_decode_frame_header(AVCodecContext *avctx, BitstreamContext *bc, TAKStreamInfo *ti, int log_level_offset) { - if (get_bits(gb, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) { + if (bitstream_read(bc, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) { av_log(avctx, AV_LOG_ERROR + log_level_offset, "missing sync id\n"); return AVERROR_INVALIDDATA; } - ti->flags = get_bits(gb, TAK_FRAME_HEADER_FLAGS_BITS); - ti->frame_num = get_bits(gb, TAK_FRAME_HEADER_NO_BITS); + ti->flags = bitstream_read(bc, TAK_FRAME_HEADER_FLAGS_BITS); + ti->frame_num = bitstream_read(bc, TAK_FRAME_HEADER_NO_BITS); if (ti->flags & TAK_FRAME_FLAG_IS_LAST) { - ti->last_frame_samples = get_bits(gb, TAK_FRAME_HEADER_SAMPLE_COUNT_BITS) + 1; - skip_bits(gb, 2); + ti->last_frame_samples = bitstream_read(bc, TAK_FRAME_HEADER_SAMPLE_COUNT_BITS) + 1; + bitstream_skip(bc, 2); } else { ti->last_frame_samples = 0; } if (ti->flags & TAK_FRAME_FLAG_HAS_INFO) { - avpriv_tak_parse_streaminfo(gb, ti); + avpriv_tak_parse_streaminfo(bc, ti); - if (get_bits(gb, 6)) - skip_bits(gb, 25); - align_get_bits(gb); + if (bitstream_read(bc, 6)) + bitstream_skip(bc, 25); + bitstream_align(bc); } - skip_bits(gb, 24); + bitstream_skip(bc, 24); return 0; } diff --git a/libavcodec/tak.h b/libavcodec/tak.h index 19b1c47521..c752062521 100644 --- a/libavcodec/tak.h +++ b/libavcodec/tak.h @@ -30,7 +30,7 @@ #include #include "avcodec.h" -#include "get_bits.h" +#include "bitstream.h" #define TAK_FORMAT_DATA_TYPE_BITS 3 #define TAK_FORMAT_SAMPLE_RATE_BITS 18 @@ -145,21 +145,21 @@ int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size); /** * Parse the Streaminfo metadata block. - * @param[in] gb pointer to GetBitContext + * @param[in] bc pointer to BitstreamContext * @param[out] s storage for parsed information */ -void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s); +void avpriv_tak_parse_streaminfo(BitstreamContext *bc, TAKStreamInfo *s); /** * Validate and decode a frame header. * @param avctx AVCodecContext to use as av_log() context - * @param[in] gb GetBitContext from which to read frame header + * @param[in] bc BitstreamContext from which to read frame header * @param[out] s frame information * @param log_level_offset log level offset, can be used to silence * error messages. * @return non-zero on error, 0 if OK */ -int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, +int ff_tak_decode_frame_header(AVCodecContext *avctx, BitstreamContext *bc, TAKStreamInfo *s, int log_level_offset); #endif /* AVCODEC_TAK_H */ diff --git a/libavcodec/tak_parser.c b/libavcodec/tak_parser.c index 9ac1deb9f7..82fb7e8c6b 100644 --- a/libavcodec/tak_parser.c +++ b/libavcodec/tak_parser.c @@ -25,6 +25,7 @@ **/ #define BITSTREAM_READER_LE +#include "bitstream.h" #include "parser.h" #include "tak.h" @@ -47,14 +48,14 @@ static int tak_parse(AVCodecParserContext *s, AVCodecContext *avctx, TAKParseContext *t = s->priv_data; ParseContext *pc = &t->pc; int next = END_NOT_FOUND; - GetBitContext gb; + BitstreamContext bc; int consumed = 0; int needed = buf_size ? TAK_MAX_FRAME_HEADER_BYTES : 8; if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { TAKStreamInfo ti; - init_get_bits(&gb, buf, buf_size); - if (!ff_tak_decode_frame_header(avctx, &gb, &ti, 127)) + bitstream_init(&bc, buf, buf_size); + if (!ff_tak_decode_frame_header(avctx, &bc, &ti, 127)) s->duration = t->ti.last_frame_samples ? t->ti.last_frame_samples : t->ti.frame_samples; *poutbuf = buf; @@ -79,14 +80,14 @@ static int tak_parse(AVCodecParserContext *s, AVCodecContext *avctx, pc->buffer[t->index + 1] == 0xA0) { TAKStreamInfo ti; - init_get_bits(&gb, pc->buffer + t->index, - 8 * (pc->index - t->index)); - if (!ff_tak_decode_frame_header(avctx, &gb, + bitstream_init8(&bc, pc->buffer + t->index, + pc->index - t->index); + if (!ff_tak_decode_frame_header(avctx, &bc, pc->frame_start_found ? &ti : &t->ti, 127) && !ff_tak_check_crc(pc->buffer + t->index, - get_bits_count(&gb) / 8)) { + bitstream_tell(&bc) / 8)) { if (!pc->frame_start_found) { pc->frame_start_found = 1; s->duration = t->ti.last_frame_samples ? diff --git a/libavcodec/takdec.c b/libavcodec/takdec.c index e7320c66d4..11c04f4ff4 100644 --- a/libavcodec/takdec.c +++ b/libavcodec/takdec.c @@ -31,8 +31,9 @@ #define BITSTREAM_READER_LE #include "audiodsp.h" #include "avcodec.h" +#include "bitstream.h" #include "internal.h" -#include "unary_legacy.h" +#include "unary.h" #include "tak.h" #define MAX_SUBFRAMES 8 // max number of subframes per channel @@ -49,7 +50,7 @@ typedef struct TAKDecContext { AVCodecContext *avctx; // parent AVCodecContext AudioDSPContext adsp; TAKStreamInfo ti; - GetBitContext gb; // bitstream reader initialized to start at the current frame + BitstreamContext bc; // bitstream reader initialized to start at the current frame int uval; int nb_samples; // number of samples in the current frame @@ -238,7 +239,7 @@ static void decode_lpc(int32_t *coeffs, int mode, int length) } } -static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded, +static int decode_segment(BitstreamContext *bc, int mode, int32_t *decoded, int len) { struct CParam code; @@ -254,20 +255,20 @@ static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded, code = xcodes[mode - 1]; for (i = 0; i < len; i++) { - int x = get_bits_long(gb, code.init); - if (x >= code.escape && get_bits1(gb)) { + int x = bitstream_read(bc, code.init); + if (x >= code.escape && bitstream_read_bit(bc)) { x |= 1 << code.init; if (x >= code.aescape) { - int scale = get_unary(gb, 1, 9); + int scale = get_unary(bc, 1, 9); if (scale == 9) { - int scale_bits = get_bits(gb, 3); + int scale_bits = bitstream_read(bc, 3); if (scale_bits > 0) { if (scale_bits == 7) { - scale_bits += get_bits(gb, 5); + scale_bits += bitstream_read(bc, 5); if (scale_bits > 29) return AVERROR_INVALIDDATA; } - scale = get_bits_long(gb, scale_bits) + 1; + scale = bitstream_read(bc, scale_bits) + 1; x += code.scale * scale; } x += code.bias; @@ -284,13 +285,13 @@ static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded, static int decode_residues(TAKDecContext *s, int32_t *decoded, int length) { - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; int i, mode, ret; if (length > s->nb_samples) return AVERROR_INVALIDDATA; - if (get_bits1(gb)) { + if (bitstream_read_bit(bc)) { int wlength, rval; int coding_mode[128]; @@ -306,20 +307,21 @@ static int decode_residues(TAKDecContext *s, int32_t *decoded, int length) if (wlength <= 1 || wlength > 128) return AVERROR_INVALIDDATA; - coding_mode[0] = mode = get_bits(gb, 6); + coding_mode[0] = + mode = bitstream_read(bc, 6); for (i = 1; i < wlength; i++) { - int c = get_unary(gb, 1, 6); + int c = get_unary(bc, 1, 6); switch (c) { case 6: - mode = get_bits(gb, 6); + mode = bitstream_read(bc, 6); break; case 5: case 4: case 3: { /* mode += sign ? (1 - c) : (c - 1) */ - int sign = get_bits1(gb); + int sign = bitstream_read_bit(bc); mode += (-sign ^ (c - 1)) + sign; break; } @@ -349,23 +351,23 @@ static int decode_residues(TAKDecContext *s, int32_t *decoded, int length) break; } while (coding_mode[i] == mode); - if ((ret = decode_segment(gb, mode, decoded, len)) < 0) + if ((ret = decode_segment(bc, mode, decoded, len)) < 0) return ret; decoded += len; } } else { - mode = get_bits(gb, 6); - if ((ret = decode_segment(gb, mode, decoded, length)) < 0) + mode = bitstream_read(bc, 6); + if ((ret = decode_segment(bc, mode, decoded, length)) < 0) return ret; } return 0; } -static int get_bits_esc4(GetBitContext *gb) +static int bits_esc4(BitstreamContext *bc) { - if (get_bits1(gb)) - return get_bits(gb, 4) + 1; + if (bitstream_read_bit(bc)) + return bitstream_read(bc, 4) + 1; else return 0; } @@ -373,23 +375,23 @@ static int get_bits_esc4(GetBitContext *gb) static void decode_filter_coeffs(TAKDecContext *s, int filter_order, int size, int filter_quant, int16_t *filter) { - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; int i, j, a, b; int filter_tmp[MAX_PREDICTORS]; int16_t predictors[MAX_PREDICTORS]; - predictors[0] = get_sbits(gb, 10); - predictors[1] = get_sbits(gb, 10); - predictors[2] = get_sbits(gb, size) << (10 - size); - predictors[3] = get_sbits(gb, size) << (10 - size); + predictors[0] = bitstream_read_signed(bc, 10); + predictors[1] = bitstream_read_signed(bc, 10); + predictors[2] = bitstream_read_signed(bc, size) << (10 - size); + predictors[3] = bitstream_read_signed(bc, size) << (10 - size); if (filter_order > 4) { int av_uninit(code_size); - int code_size_base = size - get_bits1(gb); + int code_size_base = size - bitstream_read_bit(bc); for (i = 4; i < filter_order; i++) { if (!(i & 3)) - code_size = code_size_base - get_bits(gb, 2); - predictors[i] = get_sbits(gb, code_size) << (10 - size); + code_size = code_size_base - bitstream_read(bc, 2); + predictors[i] = bitstream_read_signed(bc, code_size) << (10 - size); } } @@ -421,18 +423,18 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded, int subframe_size, int prev_subframe_size) { LOCAL_ALIGNED_16(int16_t, filter, [MAX_PREDICTORS]); - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; int i, ret; int dshift, size, filter_quant, filter_order; memset(filter, 0, MAX_PREDICTORS * sizeof(*filter)); - if (!get_bits1(gb)) + if (!bitstream_read_bit(bc)) return decode_residues(s, decoded, subframe_size); - filter_order = predictor_sizes[get_bits(gb, 4)]; + filter_order = predictor_sizes[bitstream_read(bc, 4)]; - if (prev_subframe_size > 0 && get_bits1(gb)) { + if (prev_subframe_size > 0 && bitstream_read_bit(bc)) { if (filter_order > prev_subframe_size) return AVERROR_INVALIDDATA; @@ -447,7 +449,7 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded, if (filter_order > subframe_size) return AVERROR_INVALIDDATA; - lpc_mode = get_bits(gb, 2); + lpc_mode = bitstream_read(bc, 2); if (lpc_mode > 2) return AVERROR_INVALIDDATA; @@ -458,12 +460,12 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded, decode_lpc(decoded, lpc_mode, filter_order); } - dshift = get_bits_esc4(gb); - size = get_bits1(gb) + 6; + dshift = bits_esc4(bc); + size = bitstream_read_bit(bc) + 6; filter_quant = 10; - if (get_bits1(gb)) { - filter_quant -= get_bits(gb, 3) + 1; + if (bitstream_read_bit(bc)) { + filter_quant -= bitstream_read(bc, 3) + 1; if (filter_quant < 3) return AVERROR_INVALIDDATA; } @@ -502,35 +504,35 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded, static int decode_channel(TAKDecContext *s, int chan) { AVCodecContext *avctx = s->avctx; - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; int32_t *decoded = s->decoded[chan]; int left = s->nb_samples - 1; int i, prev, ret, nb_subframes; int subframe_len[MAX_SUBFRAMES]; - s->sample_shift[chan] = get_bits_esc4(gb); + s->sample_shift[chan] = bits_esc4(bc); if (s->sample_shift[chan] >= avctx->bits_per_coded_sample) return AVERROR_INVALIDDATA; /* NOTE: TAK 2.2.0 appears to set the sample value to 0 if * bits_per_coded_sample - sample_shift is 1, but this produces - * non-bit-exact output. Reading the 1 bit using get_sbits() instead - * of skipping it produces bit-exact output. This has been reported - * to the TAK author. */ - *decoded++ = get_sbits(gb, - avctx->bits_per_coded_sample - - s->sample_shift[chan]); - s->lpc_mode[chan] = get_bits(gb, 2); - nb_subframes = get_bits(gb, 3) + 1; + * non-bit-exact output. Reading the 1 bit using bitstream_read_signed() + * instead of skipping it produces bit-exact output. This has been + * reported to the TAK author. */ + *decoded++ = bitstream_read_signed(bc, + avctx->bits_per_coded_sample - + s->sample_shift[chan]); + s->lpc_mode[chan] = bitstream_read(bc, 2); + nb_subframes = bitstream_read(bc, 3) + 1; i = 0; if (nb_subframes > 1) { - if (get_bits_left(gb) < (nb_subframes - 1) * 6) + if (bitstream_bits_left(bc) < (nb_subframes - 1) * 6) return AVERROR_INVALIDDATA; prev = 0; for (; i < nb_subframes - 1; i++) { - int subframe_end = get_bits(gb, 6) * s->subframe_scale; + int subframe_end = bitstream_read(bc, 6) * s->subframe_scale; if (subframe_end <= prev) return AVERROR_INVALIDDATA; subframe_len[i] = subframe_end - prev; @@ -556,7 +558,7 @@ static int decode_channel(TAKDecContext *s, int chan) static int decorrelate(TAKDecContext *s, int c1, int c2, int length) { - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; int32_t *p1 = s->decoded[c1] + 1; int32_t *p2 = s->decoded[c2] + 1; int i; @@ -589,8 +591,8 @@ static int decorrelate(TAKDecContext *s, int c1, int c2, int length) case 4: /* side/left with scale factor */ FFSWAP(int32_t*, p1, p2); case 5: /* side/right with scale factor */ - dshift = get_bits_esc4(gb); - dfactor = get_sbits(gb, 10); + dshift = bits_esc4(bc); + dfactor = bitstream_read_signed(bc, 10); for (i = 0; i < length; i++) { int32_t a = p1[i]; int32_t b = p2[i]; @@ -610,15 +612,15 @@ static int decorrelate(TAKDecContext *s, int c1, int c2, int length) if (length < 256) return AVERROR_INVALIDDATA; - dshift = get_bits_esc4(gb); - filter_order = 8 << get_bits1(gb); - dval1 = get_bits1(gb); - dval2 = get_bits1(gb); + dshift = bits_esc4(bc); + filter_order = 8 << bitstream_read_bit(bc); + dval1 = bitstream_read_bit(bc); + dval2 = bitstream_read_bit(bc); for (i = 0; i < filter_order; i++) { if (!(i & 3)) - code_size = 14 - get_bits(gb, 3); - filter[i] = get_sbits(gb, code_size); + code_size = 14 - bitstream_read(bc, 3); + filter[i] = bitstream_read_signed(bc, code_size); } order_half = filter_order / 2; @@ -675,15 +677,15 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data, { TAKDecContext *s = avctx->priv_data; AVFrame *frame = data; - GetBitContext *gb = &s->gb; + BitstreamContext *bc = &s->bc; int chan, i, ret, hsize; if (pkt->size < TAK_MIN_FRAME_HEADER_BYTES) return AVERROR_INVALIDDATA; - init_get_bits(gb, pkt->data, pkt->size * 8); + bitstream_init8(bc, pkt->data, pkt->size); - if ((ret = ff_tak_decode_frame_header(avctx, gb, &s->ti, 0)) < 0) + if ((ret = ff_tak_decode_frame_header(avctx, bc, &s->ti, 0)) < 0) return ret; if (s->ti.flags & TAK_FRAME_FLAG_HAS_METADATA) { @@ -691,7 +693,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data, return AVERROR_PATCHWELCOME; } - hsize = get_bits_count(gb) / 8; + hsize = bitstream_tell(bc) / 8; if (avctx->err_recognition & AV_EF_CRCCHECK) { if (ff_tak_check_crc(pkt->data, hsize)) { av_log(avctx, AV_LOG_ERROR, "CRC error\n"); @@ -769,7 +771,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data, for (chan = 0; chan < avctx->channels; chan++) { int32_t *decoded = s->decoded[chan]; for (i = 0; i < s->nb_samples; i++) - decoded[i] = get_sbits(gb, avctx->bits_per_coded_sample); + decoded[i] = bitstream_read_signed(bc, avctx->bits_per_coded_sample); } } else { if (s->ti.codec == TAK_CODEC_MONO_STEREO) { @@ -778,25 +780,25 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data, return ret; if (avctx->channels == 2) { - if (get_bits1(gb)) { + if (bitstream_read_bit(bc)) { // some kind of subframe length, but it seems to be unused - skip_bits(gb, 6); + bitstream_skip(bc, 6); } - s->dmode = get_bits(gb, 3); + s->dmode = bitstream_read(bc, 3); if (ret = decorrelate(s, 0, 1, s->nb_samples - 1)) return ret; } } else if (s->ti.codec == TAK_CODEC_MULTICHANNEL) { - if (get_bits1(gb)) { + if (bitstream_read_bit(bc)) { int ch_mask = 0; - chan = get_bits(gb, 4) + 1; + chan = bitstream_read(bc, 4) + 1; if (chan > avctx->channels) return AVERROR_INVALIDDATA; for (i = 0; i < chan; i++) { - int nbit = get_bits(gb, 4); + int nbit = bitstream_read(bc, 4); if (nbit >= avctx->channels) return AVERROR_INVALIDDATA; @@ -804,10 +806,10 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data, if (ch_mask & 1 << nbit) return AVERROR_INVALIDDATA; - s->mcdparams[i].present = get_bits1(gb); + s->mcdparams[i].present = bitstream_read_bit(bc); if (s->mcdparams[i].present) { - s->mcdparams[i].index = get_bits(gb, 2); - s->mcdparams[i].chan2 = get_bits(gb, 4); + s->mcdparams[i].index = bitstream_read(bc, 2); + s->mcdparams[i].chan2 = bitstream_read(bc, 4); if (s->mcdparams[i].chan2 >= avctx->channels) { av_log(avctx, AV_LOG_ERROR, "invalid channel 2 (%d) for %d channel(s)\n", @@ -867,16 +869,16 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data, } } - align_get_bits(gb); - skip_bits(gb, 24); - if (get_bits_left(gb) < 0) + bitstream_align(bc); + bitstream_skip(bc, 24); + if (bitstream_bits_left(bc) < 0) av_log(avctx, AV_LOG_DEBUG, "overread\n"); - else if (get_bits_left(gb) > 0) + else if (bitstream_bits_left(bc) > 0) av_log(avctx, AV_LOG_DEBUG, "underread\n"); if (avctx->err_recognition & AV_EF_CRCCHECK) { if (ff_tak_check_crc(pkt->data + hsize, - get_bits_count(gb) / 8 - hsize)) { + bitstream_tell(bc) / 8 - hsize)) { av_log(avctx, AV_LOG_ERROR, "CRC error\n"); if (avctx->err_recognition & AV_EF_EXPLODE) return AVERROR_INVALIDDATA; diff --git a/libavformat/takdec.c b/libavformat/takdec.c index 19e0e69a5e..4b3037d9ca 100644 --- a/libavformat/takdec.c +++ b/libavformat/takdec.c @@ -20,6 +20,7 @@ */ #define BITSTREAM_READER_LE +#include "libavcodec/bitstream.h" #include "libavcodec/tak.h" #include "apetag.h" @@ -43,7 +44,7 @@ static int tak_read_header(AVFormatContext *s) { TAKDemuxContext *tc = s->priv_data; AVIOContext *pb = s->pb; - GetBitContext gb; + BitstreamContext bc; AVStream *st; uint8_t *buffer = NULL; int ret; @@ -82,7 +83,7 @@ static int tak_read_header(AVFormatContext *s) return AVERROR(EIO); } - init_get_bits(&gb, buffer, size * 8); + bitstream_init8(&bc, buffer, size); break; case TAK_METADATA_MD5: { uint8_t md5[16]; @@ -118,7 +119,7 @@ static int tak_read_header(AVFormatContext *s) if (type == TAK_METADATA_STREAMINFO) { TAKStreamInfo ti; - avpriv_tak_parse_streaminfo(&gb, &ti); + avpriv_tak_parse_streaminfo(&bc, &ti); if (ti.samples > 0) st->duration = ti.samples; st->codecpar->bits_per_coded_sample = ti.bps; @@ -135,12 +136,12 @@ static int tak_read_header(AVFormatContext *s) if (size != 11) return AVERROR_INVALIDDATA; tc->mlast_frame = 1; - tc->data_end = get_bits64(&gb, TAK_LAST_FRAME_POS_BITS) + - get_bits(&gb, TAK_LAST_FRAME_SIZE_BITS); + tc->data_end = bitstream_read_63(&bc, TAK_LAST_FRAME_POS_BITS) + + bitstream_read(&bc, TAK_LAST_FRAME_SIZE_BITS); av_freep(&buffer); } else if (type == TAK_METADATA_ENCODER) { av_log(s, AV_LOG_VERBOSE, "encoder version: %0X\n", - get_bits_long(&gb, TAK_ENCODER_VERSION_BITS)); + bitstream_read(&bc, TAK_ENCODER_VERSION_BITS)); av_freep(&buffer); } }