[FFmpeg-cvslog] atrac3plus: Convert to the new bitstream reader
Alexandra Hájková
git at videolan.org
Mon Apr 3 21:38:36 EEST 2017
ffmpeg | branch: master | Alexandra Hájková <alexandra at khirnov.net> | Sat Apr 9 14:47:04 2016 +0200| [edd4c19a781124cbdb3598f94ec3a0d9ff7058cd] | committer: Anton Khirnov
atrac3plus: Convert to the new bitstream reader
Signed-off-by: Anton Khirnov <anton at khirnov.net>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=edd4c19a781124cbdb3598f94ec3a0d9ff7058cd
---
libavcodec/atrac3plus.c | 525 +++++++++++++++++++++++----------------------
libavcodec/atrac3plus.h | 7 +-
libavcodec/atrac3plusdec.c | 15 +-
3 files changed, 275 insertions(+), 272 deletions(-)
diff --git a/libavcodec/atrac3plus.c b/libavcodec/atrac3plus.c
index 076fb84..2731a80 100644
--- a/libavcodec/atrac3plus.c
+++ b/libavcodec/atrac3plus.c
@@ -26,8 +26,9 @@
*/
#include "libavutil/avassert.h"
+
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "atrac3plus.h"
#include "atrac3plus_data.h"
@@ -212,20 +213,20 @@ av_cold void ff_atrac3p_init_vlcs(AVCodec *codec)
/**
* Decode number of coded quantization units.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] chan ptr to the channel parameters
* @param[in,out] ctx ptr to the channel unit context
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan,
+static int num_coded_units(BitstreamContext *bc, Atrac3pChanParams *chan,
Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)
{
- chan->fill_mode = get_bits(gb, 2);
+ chan->fill_mode = bitstream_read(bc, 2);
if (!chan->fill_mode) {
chan->num_coded_vals = ctx->num_quant_units;
} else {
- chan->num_coded_vals = get_bits(gb, 5);
+ chan->num_coded_vals = bitstream_read(bc, 5);
if (chan->num_coded_vals > ctx->num_quant_units) {
av_log(avctx, AV_LOG_ERROR,
"Invalid number of transmitted units!\n");
@@ -233,7 +234,7 @@ static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan,
}
if (chan->fill_mode == 3)
- chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1;
+ chan->split_point = bitstream_read(bc, 2) + (chan->ch_num << 1) + 1;
}
return 0;
@@ -318,21 +319,21 @@ static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec,
}
}
-#define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals) \
- start_val = get_bits((gb), 6); \
- unpack_vq_shape(start_val, &atrac3p_sf_shapes[get_bits((gb), 6)][0], \
+#define UNPACK_SF_VQ_SHAPE(bc, dst, num_vals) \
+ start_val = bitstream_read((bc), 6); \
+ unpack_vq_shape(start_val, &atrac3p_sf_shapes[bitstream_read((bc), 6)][0], \
(dst), (num_vals))
/**
* Decode word length for each quantization unit of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_channel_wordlen(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, AVCodecContext *avctx)
{
int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag,
@@ -343,107 +344,107 @@ static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
chan->fill_mode = 0;
- switch (get_bits(gb, 2)) { /* switch according to coding mode */
+ switch (bitstream_read(bc, 2)) { /* switch according to coding mode */
case 0: /* coded using constant number of bits */
for (i = 0; i < ctx->num_quant_units; i++)
- chan->qu_wordlen[i] = get_bits(gb, 3);
+ chan->qu_wordlen[i] = bitstream_read(bc, 3);
break;
case 1:
if (ch_num) {
- if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
+ if ((ret = num_coded_units(bc, chan, ctx, avctx)) < 0)
return ret;
if (chan->num_coded_vals) {
- vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
+ vlc_tab = &wl_vlc_tabs[bitstream_read(bc, 2)];
for (i = 0; i < chan->num_coded_vals; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_wordlen[i] = (ref_chan->qu_wordlen[i] + delta) & 7;
}
}
} else {
- weight_idx = get_bits(gb, 2);
- if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
+ weight_idx = bitstream_read(bc, 2);
+ if ((ret = num_coded_units(bc, chan, ctx, avctx)) < 0)
return ret;
if (chan->num_coded_vals) {
- pos = get_bits(gb, 5);
+ pos = bitstream_read(bc, 5);
if (pos > chan->num_coded_vals) {
av_log(avctx, AV_LOG_ERROR,
"WL mode 1: invalid position!\n");
return AVERROR_INVALIDDATA;
}
- delta_bits = get_bits(gb, 2);
- min_val = get_bits(gb, 3);
+ delta_bits = bitstream_read(bc, 2);
+ min_val = bitstream_read(bc, 3);
for (i = 0; i < pos; i++)
- chan->qu_wordlen[i] = get_bits(gb, 3);
+ chan->qu_wordlen[i] = bitstream_read(bc, 3);
for (i = pos; i < chan->num_coded_vals; i++)
- chan->qu_wordlen[i] = (min_val + get_bitsz(gb, delta_bits)) & 7;
+ chan->qu_wordlen[i] = (min_val + bitstream_read(bc, delta_bits)) & 7;
}
}
break;
case 2:
- if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
+ if ((ret = num_coded_units(bc, chan, ctx, avctx)) < 0)
return ret;
if (ch_num && chan->num_coded_vals) {
- vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ vlc_tab = &wl_vlc_tabs[bitstream_read(bc, 2)];
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_wordlen[0] = (ref_chan->qu_wordlen[0] + delta) & 7;
for (i = 1; i < chan->num_coded_vals; i++) {
diff = ref_chan->qu_wordlen[i] - ref_chan->qu_wordlen[i - 1];
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + diff + delta) & 7;
}
} else if (chan->num_coded_vals) {
- flag = get_bits(gb, 1);
- vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)];
+ flag = bitstream_read(bc, 1);
+ vlc_tab = &wl_vlc_tabs[bitstream_read(bc, 1)];
- start_val = get_bits(gb, 3);
+ start_val = bitstream_read(bc, 3);
unpack_vq_shape(start_val,
- &atrac3p_wl_shapes[start_val][get_bits(gb, 4)][0],
+ &atrac3p_wl_shapes[start_val][bitstream_read(bc, 4)][0],
chan->qu_wordlen, chan->num_coded_vals);
if (!flag) {
for (i = 0; i < chan->num_coded_vals; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_wordlen[i] = (chan->qu_wordlen[i] + delta) & 7;
}
} else {
for (i = 0; i < (chan->num_coded_vals & - 2); i += 2)
- if (!get_bits1(gb)) {
+ if (!bitstream_read_bit(bc)) {
chan->qu_wordlen[i] = (chan->qu_wordlen[i] +
- get_vlc2(gb, vlc_tab->table,
- vlc_tab->bits, 1)) & 7;
+ bitstream_read_vlc(bc, vlc_tab->table,
+ vlc_tab->bits, 1)) & 7;
chan->qu_wordlen[i + 1] = (chan->qu_wordlen[i + 1] +
- get_vlc2(gb, vlc_tab->table,
- vlc_tab->bits, 1)) & 7;
+ bitstream_read_vlc(bc, vlc_tab->table,
+ vlc_tab->bits, 1)) & 7;
}
if (chan->num_coded_vals & 1)
chan->qu_wordlen[i] = (chan->qu_wordlen[i] +
- get_vlc2(gb, vlc_tab->table,
- vlc_tab->bits, 1)) & 7;
+ bitstream_read_vlc(bc, vlc_tab->table,
+ vlc_tab->bits, 1)) & 7;
}
}
break;
case 3:
- weight_idx = get_bits(gb, 2);
- if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
+ weight_idx = bitstream_read(bc, 2);
+ if ((ret = num_coded_units(bc, chan, ctx, avctx)) < 0)
return ret;
if (chan->num_coded_vals) {
- vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
+ vlc_tab = &wl_vlc_tabs[bitstream_read(bc, 2)];
/* first coefficient is coded directly */
- chan->qu_wordlen[0] = get_bits(gb, 3);
+ chan->qu_wordlen[0] = bitstream_read(bc, 3);
for (i = 1; i < chan->num_coded_vals; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + delta) & 7;
}
}
@@ -452,7 +453,7 @@ static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (chan->fill_mode == 2) {
for (i = chan->num_coded_vals; i < ctx->num_quant_units; i++)
- chan->qu_wordlen[i] = ch_num ? get_bits1(gb) : 1;
+ chan->qu_wordlen[i] = ch_num ? bitstream_read_bit(bc) : 1;
} else if (chan->fill_mode == 3) {
pos = ch_num ? chan->num_coded_vals + chan->split_point
: ctx->num_quant_units - chan->split_point;
@@ -469,13 +470,13 @@ static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode scale factor indexes for each quant unit of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_channel_sf_idx(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, AVCodecContext *avctx)
{
int i, weight_idx = 0, delta, diff, num_long_vals,
@@ -484,40 +485,40 @@ static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
Atrac3pChanParams *chan = &ctx->channels[ch_num];
Atrac3pChanParams *ref_chan = &ctx->channels[0];
- switch (get_bits(gb, 2)) { /* switch according to coding mode */
+ switch (bitstream_read(bc, 2)) { /* switch according to coding mode */
case 0: /* coded using constant number of bits */
for (i = 0; i < ctx->used_quant_units; i++)
- chan->qu_sf_idx[i] = get_bits(gb, 6);
+ chan->qu_sf_idx[i] = bitstream_read(bc, 6);
break;
case 1:
if (ch_num) {
- vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
+ vlc_tab = &sf_vlc_tabs[bitstream_read(bc, 2)];
for (i = 0; i < ctx->used_quant_units; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F;
}
} else {
- weight_idx = get_bits(gb, 2);
+ weight_idx = bitstream_read(bc, 2);
if (weight_idx == 3) {
- UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
+ UNPACK_SF_VQ_SHAPE(bc, chan->qu_sf_idx, ctx->used_quant_units);
- num_long_vals = get_bits(gb, 5);
- delta_bits = get_bits(gb, 2);
- min_val = get_bits(gb, 4) - 7;
+ num_long_vals = bitstream_read(bc, 5);
+ delta_bits = bitstream_read(bc, 2);
+ min_val = bitstream_read(bc, 4) - 7;
for (i = 0; i < num_long_vals; i++)
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
- get_bits(gb, 4) - 7) & 0x3F;
+ bitstream_read(bc, 4) - 7) & 0x3F;
/* all others are: min_val + delta */
for (i = num_long_vals; i < ctx->used_quant_units; i++)
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val +
- get_bitsz(gb, delta_bits)) & 0x3F;
+ bitstream_read(bc, delta_bits)) & 0x3F;
} else {
- num_long_vals = get_bits(gb, 5);
- delta_bits = get_bits(gb, 3);
- min_val = get_bits(gb, 6);
+ num_long_vals = bitstream_read(bc, 5);
+ delta_bits = bitstream_read(bc, 3);
+ min_val = bitstream_read(bc, 6);
if (num_long_vals > ctx->used_quant_units || delta_bits == 7) {
av_log(avctx, AV_LOG_ERROR,
"SF mode 1: invalid parameters!\n");
@@ -526,34 +527,34 @@ static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/* read full-precision SF indexes */
for (i = 0; i < num_long_vals; i++)
- chan->qu_sf_idx[i] = get_bits(gb, 6);
+ chan->qu_sf_idx[i] = bitstream_read(bc, 6);
/* all others are: min_val + delta */
for (i = num_long_vals; i < ctx->used_quant_units; i++)
chan->qu_sf_idx[i] = (min_val +
- get_bitsz(gb, delta_bits)) & 0x3F;
+ bitstream_read(bc, delta_bits)) & 0x3F;
}
}
break;
case 2:
if (ch_num) {
- vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
+ vlc_tab = &sf_vlc_tabs[bitstream_read(bc, 2)];
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F;
for (i = 1; i < ctx->used_quant_units; i++) {
diff = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1];
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F;
}
} else {
- vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4];
+ vlc_tab = &sf_vlc_tabs[bitstream_read(bc, 2) + 4];
- UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
+ UNPACK_SF_VQ_SHAPE(bc, chan->qu_sf_idx, ctx->used_quant_units);
for (i = 0; i < ctx->used_quant_units; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
sign_extend(delta, 4)) & 0x3F;
}
@@ -565,29 +566,29 @@ static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
for (i = 0; i < ctx->used_quant_units; i++)
chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i];
} else {
- weight_idx = get_bits(gb, 2);
- vlc_sel = get_bits(gb, 2);
+ weight_idx = bitstream_read(bc, 2);
+ vlc_sel = bitstream_read(bc, 2);
vlc_tab = &sf_vlc_tabs[vlc_sel];
if (weight_idx == 3) {
vlc_tab = &sf_vlc_tabs[vlc_sel + 4];
- UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
+ UNPACK_SF_VQ_SHAPE(bc, chan->qu_sf_idx, ctx->used_quant_units);
- diff = (get_bits(gb, 4) + 56) & 0x3F;
- chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F;
+ diff = (bitstream_read(bc, 4) + 56) & 0x3F;
+ chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F;
for (i = 1; i < ctx->used_quant_units; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
diff = (diff + sign_extend(delta, 4)) & 0x3F;
chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i]) & 0x3F;
}
} else {
/* 1st coefficient is coded directly */
- chan->qu_sf_idx[0] = get_bits(gb, 6);
+ chan->qu_sf_idx[0] = bitstream_read(bc, 6);
for (i = 1; i < ctx->used_quant_units; i++) {
- delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ delta = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F;
}
}
@@ -604,13 +605,13 @@ static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode word length information for each channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_quant_wordlen(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int ch_num, i, ret;
@@ -619,7 +620,7 @@ static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
memset(ctx->channels[ch_num].qu_wordlen, 0,
sizeof(ctx->channels[ch_num].qu_wordlen));
- if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0)
+ if ((ret = decode_channel_wordlen(bc, ctx, ch_num, avctx)) < 0)
return ret;
}
@@ -637,13 +638,13 @@ static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode scale factor indexes for each channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_scale_factors(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int ch_num, ret;
@@ -655,7 +656,7 @@ static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
memset(ctx->channels[ch_num].qu_sf_idx, 0,
sizeof(ctx->channels[ch_num].qu_sf_idx));
- if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0)
+ if ((ret = decode_channel_sf_idx(bc, ctx, ch_num, avctx)) < 0)
return ret;
}
@@ -665,18 +666,18 @@ static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode number of code table values.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int get_num_ct_values(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
AVCodecContext *avctx)
{
int num_coded_vals;
- if (get_bits1(gb)) {
- num_coded_vals = get_bits(gb, 5);
+ if (bitstream_read_bit(bc)) {
+ num_coded_vals = bitstream_read(bc, 5);
if (num_coded_vals > ctx->used_quant_units) {
av_log(avctx, AV_LOG_ERROR,
"Invalid number of code table indexes: %d!\n", num_coded_vals);
@@ -688,7 +689,7 @@ static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
}
#define DEC_CT_IDX_COMMON(OP) \
- num_vals = get_num_ct_values(gb, ctx, avctx); \
+ num_vals = get_num_ct_values(bc, ctx, avctx); \
if (num_vals < 0) \
return num_vals; \
\
@@ -697,33 +698,33 @@ static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
chan->qu_tab_idx[i] = OP; \
} else if (ch_num && ref_chan->qu_wordlen[i]) \
/* get clone master flag */ \
- chan->qu_tab_idx[i] = get_bits1(gb); \
+ chan->qu_tab_idx[i] = bitstream_read_bit(bc); \
}
-#define CODING_DIRECT get_bits(gb, num_bits)
+#define CODING_DIRECT bitstream_read(bc, num_bits)
-#define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)
+#define CODING_VLC bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1)
#define CODING_VLC_DELTA \
(!i) ? CODING_VLC \
- : (pred + get_vlc2(gb, delta_vlc->table, \
- delta_vlc->bits, 1)) & mask; \
+ : (pred + bitstream_read_vlc(bc, delta_vlc->table, \
+ delta_vlc->bits, 1)) & mask; \
pred = chan->qu_tab_idx[i]
#define CODING_VLC_DIFF \
(ref_chan->qu_tab_idx[i] + \
- get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask
+ bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1)) & mask
/**
* Decode code table indexes for each quant unit of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_channel_code_tab(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, AVCodecContext *avctx)
{
int i, num_vals, num_bits, pred;
@@ -732,9 +733,9 @@ static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
Atrac3pChanParams *chan = &ctx->channels[ch_num];
Atrac3pChanParams *ref_chan = &ctx->channels[0];
- chan->table_type = get_bits1(gb);
+ chan->table_type = bitstream_read_bit(bc);
- switch (get_bits(gb, 2)) { /* switch according to coding mode */
+ switch (bitstream_read(bc, 2)) { /* switch according to coding mode */
case 0: /* directly coded */
num_bits = ctx->use_full_table + 2;
DEC_CT_IDX_COMMON(CODING_DIRECT);
@@ -770,13 +771,13 @@ static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode code table indexes for each channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_code_table_indexes(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int ch_num, ret;
@@ -784,13 +785,13 @@ static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (!ctx->used_quant_units)
return 0;
- ctx->use_full_table = get_bits1(gb);
+ ctx->use_full_table = bitstream_read_bit(bc);
for (ch_num = 0; ch_num < num_channels; ch_num++) {
memset(ctx->channels[ch_num].qu_tab_idx, 0,
sizeof(ctx->channels[ch_num].qu_tab_idx));
- if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0)
+ if ((ret = decode_channel_code_tab(bc, ctx, ch_num, avctx)) < 0)
return ret;
}
@@ -803,13 +804,13 @@ static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
* This is a generalized version for all known coding modes.
* Its speed can be improved by creating separate functions for each mode.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in] tab code table telling how to decode spectral lines
* @param[in] vlc_tab ptr to the huffman table associated with the code table
* @param[out] out pointer to buffer where decoded data should be stored
* @param[in] num_specs number of spectral lines to decode
*/
-static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,
+static void decode_qu_spectra(BitstreamContext *bc, const Atrac3pSpecCodeTab *tab,
VLC *vlc_tab, int16_t *out, const int num_specs)
{
int i, j, pos, cf;
@@ -820,15 +821,15 @@ static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,
unsigned val, mask = (1 << bits) - 1;
for (pos = 0; pos < num_specs;) {
- if (group_size == 1 || get_bits1(gb)) {
+ if (group_size == 1 || bitstream_read_bit(bc)) {
for (j = 0; j < group_size; j++) {
- val = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
+ val = bitstream_read_vlc(bc, vlc_tab->table, vlc_tab->bits, 1);
for (i = 0; i < num_coeffs; i++) {
cf = val & mask;
if (is_signed)
cf = sign_extend(cf, bits);
- else if (cf && get_bits1(gb))
+ else if (cf && bitstream_read_bit(bc))
cf = -cf;
out[pos++] = cf;
@@ -843,12 +844,12 @@ static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,
/**
* Decode huffman-coded IMDCT spectrum for all channels.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
*/
-static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static void decode_spectrum(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int i, ch_num, qu, wordlen, codetab, tab_index, num_specs;
@@ -880,7 +881,7 @@ static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (tab->redirect >= 0)
tab_index = tab->redirect;
- decode_qu_spectra(gb, tab, &spec_vlc_tabs[tab_index],
+ decode_qu_spectra(bc, tab, &spec_vlc_tabs[tab_index],
&chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
num_specs);
} else if (ch_num && ctx->channels[0].qu_wordlen[qu] && !codetab) {
@@ -900,7 +901,7 @@ static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (ctx->used_quant_units > 2) {
num_specs = atrac3p_subband_to_num_powgrps[ctx->num_coded_subbands - 1];
for (i = 0; i < num_specs; i++)
- chan->power_levs[i] = get_bits(gb, 4);
+ chan->power_levs[i] = bitstream_read(bc, 4);
}
}
}
@@ -913,22 +914,22 @@ static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
* Otherwise, all necessary bits will be directly stored
* prefixed by two signal bits = 1,1.
*
- * @param[in] gb ptr to the GetBitContext
+ * @param[in] bc ptr to the BitstreamContext
* @param[out] out where to place decoded flags
* @param[in] num_flags number of flags to process
* @return: 0 = all flag bits are zero, 1 = there is at least one non-zero flag bit
*/
-static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags)
+static int get_subband_flags(BitstreamContext *bc, uint8_t *out, int num_flags)
{
int i, result;
memset(out, 0, num_flags);
- result = get_bits1(gb);
+ result = bitstream_read_bit(bc);
if (result) {
- if (get_bits1(gb))
+ if (bitstream_read_bit(bc))
for (i = 0; i < num_flags; i++)
- out[i] = get_bits1(gb);
+ out[i] = bitstream_read_bit(bc);
else
memset(out, 1, num_flags);
}
@@ -939,63 +940,63 @@ static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags)
/**
* Decode mdct window shape flags for all channels.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
*/
-static void decode_window_shape(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static void decode_window_shape(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels)
{
int ch_num;
for (ch_num = 0; ch_num < num_channels; ch_num++)
- get_subband_flags(gb, ctx->channels[ch_num].wnd_shape,
+ get_subband_flags(bc, ctx->channels[ch_num].wnd_shape,
ctx->num_subbands);
}
/**
* Decode number of gain control points.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] coded_subbands number of subbands to process
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_gainc_npoints(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int coded_subbands)
{
int i, delta, delta_bits, min_val;
Atrac3pChanParams *chan = &ctx->channels[ch_num];
Atrac3pChanParams *ref_chan = &ctx->channels[0];
- switch (get_bits(gb, 2)) { /* switch according to coding mode */
+ switch (bitstream_read(bc, 2)) { /* switch according to coding mode */
case 0: /* fixed-length coding */
for (i = 0; i < coded_subbands; i++)
- chan->gain_data[i].num_points = get_bits(gb, 3);
+ chan->gain_data[i].num_points = bitstream_read(bc, 3);
break;
case 1: /* variable-length coding */
for (i = 0; i < coded_subbands; i++)
chan->gain_data[i].num_points =
- get_vlc2(gb, gain_vlc_tabs[0].table,
- gain_vlc_tabs[0].bits, 1);
+ bitstream_read_vlc(bc, gain_vlc_tabs[0].table,
+ gain_vlc_tabs[0].bits, 1);
break;
case 2:
if (ch_num) { /* VLC modulo delta to master channel */
for (i = 0; i < coded_subbands; i++) {
- delta = get_vlc2(gb, gain_vlc_tabs[1].table,
- gain_vlc_tabs[1].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[1].table,
+ gain_vlc_tabs[1].bits, 1);
chan->gain_data[i].num_points =
(ref_chan->gain_data[i].num_points + delta) & 7;
}
} else { /* VLC modulo delta to previous */
chan->gain_data[0].num_points =
- get_vlc2(gb, gain_vlc_tabs[0].table,
- gain_vlc_tabs[0].bits, 1);
+ bitstream_read_vlc(bc, gain_vlc_tabs[0].table,
+ gain_vlc_tabs[0].bits, 1);
for (i = 1; i < coded_subbands; i++) {
- delta = get_vlc2(gb, gain_vlc_tabs[1].table,
- gain_vlc_tabs[1].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[1].table,
+ gain_vlc_tabs[1].bits, 1);
chan->gain_data[i].num_points =
(chan->gain_data[i - 1].num_points + delta) & 7;
}
@@ -1007,11 +1008,11 @@ static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
chan->gain_data[i].num_points =
ref_chan->gain_data[i].num_points;
} else { /* shorter delta to min */
- delta_bits = get_bits(gb, 2);
- min_val = get_bits(gb, 3);
+ delta_bits = bitstream_read(bc, 2);
+ min_val = bitstream_read(bc, 3);
for (i = 0; i < coded_subbands; i++) {
- chan->gain_data[i].num_points = min_val + get_bitsz(gb, delta_bits);
+ chan->gain_data[i].num_points = min_val + bitstream_read(bc, delta_bits);
if (chan->gain_data[i].num_points > 7)
return AVERROR_INVALIDDATA;
}
@@ -1038,23 +1039,23 @@ static inline void gainc_level_mode3s(AtracGainInfo *dst, AtracGainInfo *ref)
/**
* Implements coding mode 1 (master) for gain compensation levels.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in] ctx ptr to the channel unit context
* @param[out] dst ptr to the output array
*/
-static inline void gainc_level_mode1m(GetBitContext *gb,
+static inline void gainc_level_mode1m(BitstreamContext *bc,
Atrac3pChanUnitCtx *ctx,
AtracGainInfo *dst)
{
int i, delta;
if (dst->num_points > 0)
- dst->lev_code[0] = get_vlc2(gb, gain_vlc_tabs[2].table,
- gain_vlc_tabs[2].bits, 1);
+ dst->lev_code[0] = bitstream_read_vlc(bc, gain_vlc_tabs[2].table,
+ gain_vlc_tabs[2].bits, 1);
for (i = 1; i < dst->num_points; i++) {
- delta = get_vlc2(gb, gain_vlc_tabs[3].table,
- gain_vlc_tabs[3].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[3].table,
+ gain_vlc_tabs[3].bits, 1);
dst->lev_code[i] = (dst->lev_code[i - 1] + delta) & 0xF;
}
}
@@ -1062,58 +1063,58 @@ static inline void gainc_level_mode1m(GetBitContext *gb,
/**
* Decode level code for each gain control point.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] coded_subbands number of subbands to process
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_gainc_levels(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int coded_subbands)
{
int sb, i, delta, delta_bits, min_val, pred;
Atrac3pChanParams *chan = &ctx->channels[ch_num];
Atrac3pChanParams *ref_chan = &ctx->channels[0];
- switch (get_bits(gb, 2)) { /* switch according to coding mode */
+ switch (bitstream_read(bc, 2)) { /* switch according to coding mode */
case 0: /* fixed-length coding */
for (sb = 0; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++)
- chan->gain_data[sb].lev_code[i] = get_bits(gb, 4);
+ chan->gain_data[sb].lev_code[i] = bitstream_read(bc, 4);
break;
case 1:
if (ch_num) { /* VLC modulo delta to master channel */
for (sb = 0; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++) {
- delta = get_vlc2(gb, gain_vlc_tabs[5].table,
- gain_vlc_tabs[5].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[5].table,
+ gain_vlc_tabs[5].bits, 1);
pred = (i >= ref_chan->gain_data[sb].num_points)
? 7 : ref_chan->gain_data[sb].lev_code[i];
chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF;
}
} else { /* VLC modulo delta to previous */
for (sb = 0; sb < coded_subbands; sb++)
- gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]);
+ gainc_level_mode1m(bc, ctx, &chan->gain_data[sb]);
}
break;
case 2:
if (ch_num) { /* VLC modulo delta to previous or clone master */
for (sb = 0; sb < coded_subbands; sb++)
if (chan->gain_data[sb].num_points > 0) {
- if (get_bits1(gb))
- gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]);
+ if (bitstream_read_bit(bc))
+ gainc_level_mode1m(bc, ctx, &chan->gain_data[sb]);
else
gainc_level_mode3s(&chan->gain_data[sb],
&ref_chan->gain_data[sb]);
}
} else { /* VLC modulo delta to lev_codes of previous subband */
if (chan->gain_data[0].num_points > 0)
- gainc_level_mode1m(gb, ctx, &chan->gain_data[0]);
+ gainc_level_mode1m(bc, ctx, &chan->gain_data[0]);
for (sb = 1; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++) {
- delta = get_vlc2(gb, gain_vlc_tabs[4].table,
- gain_vlc_tabs[4].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[4].table,
+ gain_vlc_tabs[4].bits, 1);
pred = (i >= chan->gain_data[sb - 1].num_points)
? 7 : chan->gain_data[sb - 1].lev_code[i];
chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF;
@@ -1126,12 +1127,12 @@ static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
gainc_level_mode3s(&chan->gain_data[sb],
&ref_chan->gain_data[sb]);
} else { /* shorter delta to min */
- delta_bits = get_bits(gb, 2);
- min_val = get_bits(gb, 4);
+ delta_bits = bitstream_read(bc, 2);
+ min_val = bitstream_read(bc, 4);
for (sb = 0; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++) {
- chan->gain_data[sb].lev_code[i] = min_val + get_bitsz(gb, delta_bits);
+ chan->gain_data[sb].lev_code[i] = min_val + bitstream_read(bc, delta_bits);
if (chan->gain_data[sb].lev_code[i] > 15)
return AVERROR_INVALIDDATA;
}
@@ -1145,35 +1146,35 @@ static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Implements coding mode 0 for gain compensation locations.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in] ctx ptr to the channel unit context
* @param[out] dst ptr to the output array
* @param[in] pos position of the value to be processed
*/
-static inline void gainc_loc_mode0(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static inline void gainc_loc_mode0(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
AtracGainInfo *dst, int pos)
{
int delta_bits;
if (!pos || dst->loc_code[pos - 1] < 15)
- dst->loc_code[pos] = get_bits(gb, 5);
+ dst->loc_code[pos] = bitstream_read(bc, 5);
else if (dst->loc_code[pos - 1] >= 30)
dst->loc_code[pos] = 31;
else {
delta_bits = av_log2(30 - dst->loc_code[pos - 1]) + 1;
dst->loc_code[pos] = dst->loc_code[pos - 1] +
- get_bits(gb, delta_bits) + 1;
+ bitstream_read(bc, delta_bits) + 1;
}
}
/**
* Implements coding mode 1 for gain compensation locations.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in] ctx ptr to the channel unit context
* @param[out] dst ptr to the output array
*/
-static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static inline void gainc_loc_mode1(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
AtracGainInfo *dst)
{
int i;
@@ -1181,7 +1182,7 @@ static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (dst->num_points > 0) {
/* 1st coefficient is stored directly */
- dst->loc_code[0] = get_bits(gb, 5);
+ dst->loc_code[0] = bitstream_read(bc, 5);
for (i = 1; i < dst->num_points; i++) {
/* switch VLC according to the curve direction
@@ -1190,7 +1191,7 @@ static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
? &gain_vlc_tabs[7]
: &gain_vlc_tabs[9];
dst->loc_code[i] = dst->loc_code[i - 1] +
- get_vlc2(gb, tab->table, tab->bits, 1);
+ bitstream_read_vlc(bc, tab->table, tab->bits, 1);
}
}
}
@@ -1198,14 +1199,14 @@ static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode location code for each gain control point.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] coded_subbands number of subbands to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_gainc_loc_codes(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int coded_subbands,
AVCodecContext *avctx)
{
@@ -1215,11 +1216,11 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
Atrac3pChanParams *chan = &ctx->channels[ch_num];
Atrac3pChanParams *ref_chan = &ctx->channels[0];
- switch (get_bits(gb, 2)) { /* switch according to coding mode */
+ switch (bitstream_read(bc, 2)) { /* switch according to coding mode */
case 0: /* sequence of numbers in ascending order */
for (sb = 0; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++)
- gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i);
+ gainc_loc_mode0(bc, ctx, &chan->gain_data[sb], i);
break;
case 1:
if (ch_num) {
@@ -1230,8 +1231,8 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
ref = &ref_chan->gain_data[sb];
/* 1st value is vlc-coded modulo delta to master */
- delta = get_vlc2(gb, gain_vlc_tabs[10].table,
- gain_vlc_tabs[10].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[10].table,
+ gain_vlc_tabs[10].bits, 1);
pred = ref->num_points > 0 ? ref->loc_code[0] : 0;
dst->loc_code[0] = (pred + delta) & 0x1F;
@@ -1241,19 +1242,19 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/* ascending curve */
if (more_than_ref) {
delta =
- get_vlc2(gb, gain_vlc_tabs[9].table,
- gain_vlc_tabs[9].bits, 1);
+ bitstream_read_vlc(bc, gain_vlc_tabs[9].table,
+ gain_vlc_tabs[9].bits, 1);
dst->loc_code[i] = dst->loc_code[i - 1] + delta;
} else {
- if (get_bits1(gb))
- gainc_loc_mode0(gb, ctx, dst, i); // direct coding
+ if (bitstream_read_bit(bc))
+ gainc_loc_mode0(bc, ctx, dst, i); // direct coding
else
dst->loc_code[i] = ref->loc_code[i]; // clone master
}
} else { /* descending curve */
tab = more_than_ref ? &gain_vlc_tabs[7]
: &gain_vlc_tabs[10];
- delta = get_vlc2(gb, tab->table, tab->bits, 1);
+ delta = bitstream_read_vlc(bc, tab->table, tab->bits, 1);
if (more_than_ref)
dst->loc_code[i] = dst->loc_code[i - 1] + delta;
else
@@ -1263,7 +1264,7 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
}
} else /* VLC delta to previous */
for (sb = 0; sb < coded_subbands; sb++)
- gainc_loc_mode1(gb, ctx, &chan->gain_data[sb]);
+ gainc_loc_mode1(bc, ctx, &chan->gain_data[sb]);
break;
case 2:
if (ch_num) {
@@ -1272,8 +1273,8 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
continue;
dst = &chan->gain_data[sb];
ref = &ref_chan->gain_data[sb];
- if (dst->num_points > ref->num_points || get_bits1(gb))
- gainc_loc_mode1(gb, ctx, dst);
+ if (dst->num_points > ref->num_points || bitstream_read_bit(bc))
+ gainc_loc_mode1(bc, ctx, dst);
else /* clone master for the whole subband */
for (i = 0; i < chan->gain_data[sb].num_points; i++)
dst->loc_code[i] = ref->loc_code[i];
@@ -1281,7 +1282,7 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
} else {
/* data for the first subband is coded directly */
for (i = 0; i < chan->gain_data[0].num_points; i++)
- gainc_loc_mode0(gb, ctx, &chan->gain_data[0], i);
+ gainc_loc_mode0(bc, ctx, &chan->gain_data[0], i);
for (sb = 1; sb < coded_subbands; sb++) {
if (chan->gain_data[sb].num_points <= 0)
@@ -1290,8 +1291,8 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/* 1st value is vlc-coded modulo delta to the corresponding
* value of the previous subband if any or zero */
- delta = get_vlc2(gb, gain_vlc_tabs[6].table,
- gain_vlc_tabs[6].bits, 1);
+ delta = bitstream_read_vlc(bc, gain_vlc_tabs[6].table,
+ gain_vlc_tabs[6].bits, 1);
pred = dst[-1].num_points > 0
? dst[-1].loc_code[0] : 0;
dst->loc_code[0] = (pred + delta) & 0x1F;
@@ -1302,7 +1303,7 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
* presence of prediction. */
tab = &gain_vlc_tabs[(dst->lev_code[i] > dst->lev_code[i - 1]) *
2 + more_than_ref + 6];
- delta = get_vlc2(gb, tab->table, tab->bits, 1);
+ delta = bitstream_read_vlc(bc, tab->table, tab->bits, 1);
if (more_than_ref)
dst->loc_code[i] = dst->loc_code[i - 1] + delta;
else
@@ -1316,19 +1317,19 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
for (sb = 0; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++) {
if (i >= ref_chan->gain_data[sb].num_points)
- gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i);
+ gainc_loc_mode0(bc, ctx, &chan->gain_data[sb], i);
else
chan->gain_data[sb].loc_code[i] =
ref_chan->gain_data[sb].loc_code[i];
}
} else { /* shorter delta to min */
- delta_bits = get_bits(gb, 2) + 1;
- min_val = get_bits(gb, 5);
+ delta_bits = bitstream_read(bc, 2) + 1;
+ min_val = bitstream_read(bc, 5);
for (sb = 0; sb < coded_subbands; sb++)
for (i = 0; i < chan->gain_data[sb].num_points; i++)
chan->gain_data[sb].loc_code[i] = min_val + i +
- get_bits(gb, delta_bits);
+ bitstream_read(bc, delta_bits);
}
break;
}
@@ -1353,13 +1354,13 @@ static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode gain control data for all channels.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_gainc_data(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int ch_num, coded_subbands, sb, ret;
@@ -1368,16 +1369,16 @@ static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
memset(ctx->channels[ch_num].gain_data, 0,
sizeof(*ctx->channels[ch_num].gain_data) * ATRAC3P_SUBBANDS);
- if (get_bits1(gb)) { /* gain control data present? */
- coded_subbands = get_bits(gb, 4) + 1;
- if (get_bits1(gb)) /* is high band gain data replication on? */
- ctx->channels[ch_num].num_gain_subbands = get_bits(gb, 4) + 1;
+ if (bitstream_read_bit(bc)) { /* gain control data present? */
+ coded_subbands = bitstream_read(bc, 4) + 1;
+ if (bitstream_read_bit(bc)) /* is high band gain data replication on? */
+ ctx->channels[ch_num].num_gain_subbands = bitstream_read(bc, 4) + 1;
else
ctx->channels[ch_num].num_gain_subbands = coded_subbands;
- if ((ret = decode_gainc_npoints(gb, ctx, ch_num, coded_subbands)) < 0 ||
- (ret = decode_gainc_levels(gb, ctx, ch_num, coded_subbands)) < 0 ||
- (ret = decode_gainc_loc_codes(gb, ctx, ch_num, coded_subbands, avctx)) < 0)
+ if ((ret = decode_gainc_npoints(bc, ctx, ch_num, coded_subbands)) < 0 ||
+ (ret = decode_gainc_levels(bc, ctx, ch_num, coded_subbands)) < 0 ||
+ (ret = decode_gainc_loc_codes(bc, ctx, ch_num, coded_subbands, avctx)) < 0)
return ret;
if (coded_subbands > 0) { /* propagate gain data if requested */
@@ -1396,29 +1397,29 @@ static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode envelope for all tones of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] band_has_tones ptr to an array of per-band-flags:
* 1 - tone data present
*/
-static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static void decode_tones_envelope(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int band_has_tones[])
{
int sb;
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
Atrac3pWavesData *ref = ctx->channels[0].tones_info;
- if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */
+ if (!ch_num || !bitstream_read_bit(bc)) { /* mode 0: fixed-length coding */
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
if (!band_has_tones[sb])
continue;
- dst[sb].pend_env.has_start_point = get_bits1(gb);
+ dst[sb].pend_env.has_start_point = bitstream_read_bit(bc);
dst[sb].pend_env.start_pos = dst[sb].pend_env.has_start_point
- ? get_bits(gb, 5) : -1;
- dst[sb].pend_env.has_stop_point = get_bits1(gb);
+ ? bitstream_read(bc, 5) : -1;
+ dst[sb].pend_env.has_stop_point = bitstream_read_bit(bc);
dst[sb].pend_env.stop_pos = dst[sb].pend_env.has_stop_point
- ? get_bits(gb, 5) : 32;
+ ? bitstream_read(bc, 5) : 32;
}
} else { /* mode 1(slave only): copy master */
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
@@ -1435,7 +1436,7 @@ static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode number of tones for each subband of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] band_has_tones ptr to an array of per-band-flags:
@@ -1443,7 +1444,7 @@ static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_band_numwavs(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int band_has_tones[],
AVCodecContext *avctx)
{
@@ -1451,25 +1452,25 @@ static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
Atrac3pWavesData *ref = ctx->channels[0].tones_info;
- mode = get_bits(gb, ch_num + 1);
+ mode = bitstream_read(bc, ch_num + 1);
switch (mode) {
case 0: /** fixed-length coding */
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
if (band_has_tones[sb])
- dst[sb].num_wavs = get_bits(gb, 4);
+ dst[sb].num_wavs = bitstream_read(bc, 4);
break;
case 1: /** variable-length coding */
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
if (band_has_tones[sb])
dst[sb].num_wavs =
- get_vlc2(gb, tone_vlc_tabs[1].table,
- tone_vlc_tabs[1].bits, 1);
+ bitstream_read_vlc(bc, tone_vlc_tabs[1].table,
+ tone_vlc_tabs[1].bits, 1);
break;
case 2: /** VLC modulo delta to master (slave only) */
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
if (band_has_tones[sb]) {
- delta = get_vlc2(gb, tone_vlc_tabs[2].table,
- tone_vlc_tabs[2].bits, 1);
+ delta = bitstream_read_vlc(bc, tone_vlc_tabs[2].table,
+ tone_vlc_tabs[2].bits, 1);
delta = sign_extend(delta, 3);
dst[sb].num_wavs = (ref[sb].num_wavs + delta) & 0xF;
}
@@ -1501,13 +1502,13 @@ static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode frequency information for each subband of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] band_has_tones ptr to an array of per-band-flags:
* 1 - tone data present
*/
-static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static void decode_tones_frequency(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int band_has_tones[])
{
int sb, i, direction, nbits, pred, delta;
@@ -1515,26 +1516,26 @@ static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
Atrac3pWavesData *ref = ctx->channels[0].tones_info;
- if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */
+ if (!ch_num || !bitstream_read_bit(bc)) { /* mode 0: fixed-length coding */
for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
if (!band_has_tones[sb] || !dst[sb].num_wavs)
continue;
iwav = &ctx->waves_info->waves[dst[sb].start_index];
- direction = (dst[sb].num_wavs > 1) ? get_bits1(gb) : 0;
+ direction = (dst[sb].num_wavs > 1) ? bitstream_read_bit(bc) : 0;
if (direction) { /** packed numbers in descending order */
if (dst[sb].num_wavs)
- iwav[dst[sb].num_wavs - 1].freq_index = get_bits(gb, 10);
+ iwav[dst[sb].num_wavs - 1].freq_index = bitstream_read(bc, 10);
for (i = dst[sb].num_wavs - 2; i >= 0 ; i--) {
nbits = av_log2(iwav[i+1].freq_index) + 1;
- iwav[i].freq_index = get_bits(gb, nbits);
+ iwav[i].freq_index = bitstream_read(bc, nbits);
}
} else { /** packed numbers in ascending order */
for (i = 0; i < dst[sb].num_wavs; i++) {
if (!i || iwav[i - 1].freq_index < 512)
- iwav[i].freq_index = get_bits(gb, 10);
+ iwav[i].freq_index = bitstream_read(bc, 10);
else {
nbits = av_log2(1023 - iwav[i - 1].freq_index) + 1;
- iwav[i].freq_index = get_bits(gb, nbits) +
+ iwav[i].freq_index = bitstream_read(bc, nbits) +
1024 - (1 << nbits);
}
}
@@ -1547,8 +1548,8 @@ static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
iwav = &ctx->waves_info->waves[ref[sb].start_index];
owav = &ctx->waves_info->waves[dst[sb].start_index];
for (i = 0; i < dst[sb].num_wavs; i++) {
- delta = get_vlc2(gb, tone_vlc_tabs[6].table,
- tone_vlc_tabs[6].bits, 1);
+ delta = bitstream_read_vlc(bc, tone_vlc_tabs[6].table,
+ tone_vlc_tabs[6].bits, 1);
delta = sign_extend(delta, 8);
pred = (i < ref[sb].num_wavs) ? iwav[i].freq_index :
(ref[sb].num_wavs ? iwav[ref[sb].num_wavs - 1].freq_index : 0);
@@ -1561,13 +1562,13 @@ static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode amplitude information for each subband of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] band_has_tones ptr to an array of per-band-flags:
* 1 - tone data present
*/
-static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static void decode_tones_amplitude(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int band_has_tones[])
{
int mode, sb, j, i, diff, maxdiff, fi, delta, pred;
@@ -1601,7 +1602,7 @@ static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
}
}
- mode = get_bits(gb, ch_num + 1);
+ mode = bitstream_read(bc, ch_num + 1);
switch (mode) {
case 0: /** fixed-length coding */
@@ -1610,9 +1611,9 @@ static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
continue;
if (ctx->waves_info->amplitude_mode)
for (i = 0; i < dst[sb].num_wavs; i++)
- ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = get_bits(gb, 6);
+ ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = bitstream_read(bc, 6);
else
- ctx->waves_info->waves[dst[sb].start_index].amp_sf = get_bits(gb, 6);
+ ctx->waves_info->waves[dst[sb].start_index].amp_sf = bitstream_read(bc, 6);
}
break;
case 1: /** min + VLC delta */
@@ -1622,12 +1623,12 @@ static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (ctx->waves_info->amplitude_mode)
for (i = 0; i < dst[sb].num_wavs; i++)
ctx->waves_info->waves[dst[sb].start_index + i].amp_sf =
- get_vlc2(gb, tone_vlc_tabs[3].table,
- tone_vlc_tabs[3].bits, 1) + 20;
+ bitstream_read_vlc(bc, tone_vlc_tabs[3].table,
+ tone_vlc_tabs[3].bits, 1) + 20;
else
ctx->waves_info->waves[dst[sb].start_index].amp_sf =
- get_vlc2(gb, tone_vlc_tabs[4].table,
- tone_vlc_tabs[4].bits, 1) + 24;
+ bitstream_read_vlc(bc, tone_vlc_tabs[4].table,
+ tone_vlc_tabs[4].bits, 1) + 24;
}
break;
case 2: /** VLC modulo delta to master (slave only) */
@@ -1635,8 +1636,8 @@ static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
if (!band_has_tones[sb] || !dst[sb].num_wavs)
continue;
for (i = 0; i < dst[sb].num_wavs; i++) {
- delta = get_vlc2(gb, tone_vlc_tabs[5].table,
- tone_vlc_tabs[5].bits, 1);
+ delta = bitstream_read_vlc(bc, tone_vlc_tabs[5].table,
+ tone_vlc_tabs[5].bits, 1);
delta = sign_extend(delta, 5);
pred = refwaves[dst[sb].start_index + i] >= 0 ?
ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf : 34;
@@ -1661,13 +1662,13 @@ static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
/**
* Decode phase information for each subband of a channel.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] ch_num channel to process
* @param[in] band_has_tones ptr to an array of per-band-flags:
* 1 - tone data present
*/
-static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static void decode_tones_phase(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int ch_num, int band_has_tones[])
{
int sb, i;
@@ -1679,20 +1680,20 @@ static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
continue;
wparam = &ctx->waves_info->waves[dst[sb].start_index];
for (i = 0; i < dst[sb].num_wavs; i++)
- wparam[i].phase_index = get_bits(gb, 5);
+ wparam[i].phase_index = bitstream_read(bc, 5);
}
}
/**
* Decode tones info for all channels.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+static int decode_tones_info(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int ch_num, i, ret;
@@ -1702,26 +1703,26 @@ static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
memset(ctx->channels[ch_num].tones_info, 0,
sizeof(*ctx->channels[ch_num].tones_info) * ATRAC3P_SUBBANDS);
- ctx->waves_info->tones_present = get_bits1(gb);
+ ctx->waves_info->tones_present = bitstream_read_bit(bc);
if (!ctx->waves_info->tones_present)
return 0;
memset(ctx->waves_info->waves, 0, sizeof(ctx->waves_info->waves));
- ctx->waves_info->amplitude_mode = get_bits1(gb);
+ ctx->waves_info->amplitude_mode = bitstream_read_bit(bc);
if (!ctx->waves_info->amplitude_mode) {
avpriv_report_missing_feature(avctx, "GHA amplitude mode 0");
return AVERROR_PATCHWELCOME;
}
ctx->waves_info->num_tone_bands =
- get_vlc2(gb, tone_vlc_tabs[0].table,
- tone_vlc_tabs[0].bits, 1) + 1;
+ bitstream_read_vlc(bc, tone_vlc_tabs[0].table,
+ tone_vlc_tabs[0].bits, 1) + 1;
if (num_channels == 2) {
- get_subband_flags(gb, ctx->waves_info->tone_sharing, ctx->waves_info->num_tone_bands);
- get_subband_flags(gb, ctx->waves_info->tone_master, ctx->waves_info->num_tone_bands);
- if (get_subband_flags(gb, ctx->waves_info->phase_shift,
+ get_subband_flags(bc, ctx->waves_info->tone_sharing, ctx->waves_info->num_tone_bands);
+ get_subband_flags(bc, ctx->waves_info->tone_master, ctx->waves_info->num_tone_bands);
+ if (get_subband_flags(bc, ctx->waves_info->phase_shift,
ctx->waves_info->num_tone_bands)) {
avpriv_report_missing_feature(avctx, "GHA Phase shifting");
return AVERROR_PATCHWELCOME;
@@ -1734,14 +1735,14 @@ static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
for (i = 0; i < ctx->waves_info->num_tone_bands; i++)
band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i];
- decode_tones_envelope(gb, ctx, ch_num, band_has_tones);
- if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones,
+ decode_tones_envelope(bc, ctx, ch_num, band_has_tones);
+ if ((ret = decode_band_numwavs(bc, ctx, ch_num, band_has_tones,
avctx)) < 0)
return ret;
- decode_tones_frequency(gb, ctx, ch_num, band_has_tones);
- decode_tones_amplitude(gb, ctx, ch_num, band_has_tones);
- decode_tones_phase(gb, ctx, ch_num, band_has_tones);
+ decode_tones_frequency(bc, ctx, ch_num, band_has_tones);
+ decode_tones_amplitude(bc, ctx, ch_num, band_has_tones);
+ decode_tones_phase(bc, ctx, ch_num, band_has_tones);
}
if (num_channels == 2) {
@@ -1758,13 +1759,13 @@ static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
return 0;
}
-int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+int ff_atrac3p_decode_channel_unit(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx)
{
int ret;
/* parse sound header */
- ctx->num_quant_units = get_bits(gb, 5) + 1;
+ ctx->num_quant_units = bitstream_read(bc, 5) + 1;
if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) {
av_log(avctx, AV_LOG_ERROR,
"Invalid number of quantization units: %d!\n",
@@ -1772,10 +1773,10 @@ int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
return AVERROR_INVALIDDATA;
}
- ctx->mute_flag = get_bits1(gb);
+ ctx->mute_flag = bitstream_read_bit(bc);
/* decode various sound parameters */
- if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0)
+ if ((ret = decode_quant_wordlen(bc, ctx, num_channels, avctx)) < 0)
return ret;
ctx->num_subbands = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1;
@@ -1783,32 +1784,32 @@ int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1
: 0;
- if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0)
+ if ((ret = decode_scale_factors(bc, ctx, num_channels, avctx)) < 0)
return ret;
- if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0)
+ if ((ret = decode_code_table_indexes(bc, ctx, num_channels, avctx)) < 0)
return ret;
- decode_spectrum(gb, ctx, num_channels, avctx);
+ decode_spectrum(bc, ctx, num_channels, avctx);
if (num_channels == 2) {
- get_subband_flags(gb, ctx->swap_channels, ctx->num_coded_subbands);
- get_subband_flags(gb, ctx->negate_coeffs, ctx->num_coded_subbands);
+ get_subband_flags(bc, ctx->swap_channels, ctx->num_coded_subbands);
+ get_subband_flags(bc, ctx->negate_coeffs, ctx->num_coded_subbands);
}
- decode_window_shape(gb, ctx, num_channels);
+ decode_window_shape(bc, ctx, num_channels);
- if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0)
+ if ((ret = decode_gainc_data(bc, ctx, num_channels, avctx)) < 0)
return ret;
- if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0)
+ if ((ret = decode_tones_info(bc, ctx, num_channels, avctx)) < 0)
return ret;
/* decode global noise info */
- ctx->noise_present = get_bits1(gb);
+ ctx->noise_present = bitstream_read_bit(bc);
if (ctx->noise_present) {
- ctx->noise_level_index = get_bits(gb, 4);
- ctx->noise_table_index = get_bits(gb, 4);
+ ctx->noise_level_index = bitstream_read(bc, 4);
+ ctx->noise_table_index = bitstream_read(bc, 4);
}
return 0;
diff --git a/libavcodec/atrac3plus.h b/libavcodec/atrac3plus.h
index e56c444..cca399a 100644
--- a/libavcodec/atrac3plus.h
+++ b/libavcodec/atrac3plus.h
@@ -31,10 +31,11 @@
#include <stdint.h>
#include "libavutil/float_dsp.h"
+
#include "atrac.h"
+#include "bitstream.h"
#include "avcodec.h"
#include "fft.h"
-#include "get_bits.h"
/** Global unit sizes */
#define ATRAC3P_SUBBANDS 16 ///< number of PQF subbands
@@ -163,13 +164,13 @@ void ff_atrac3p_init_vlcs(AVCodec *codec);
/**
* Decode bitstream data of a channel unit.
*
- * @param[in] gb the GetBit context
+ * @param[in] bc the Bitstream context
* @param[in,out] ctx ptr to the channel unit context
* @param[in] num_channels number of channels to process
* @param[in] avctx ptr to the AVCodecContext
* @return result code: 0 = OK, otherwise - error code
*/
-int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
+int ff_atrac3p_decode_channel_unit(BitstreamContext *bc, Atrac3pChanUnitCtx *ctx,
int num_channels, AVCodecContext *avctx);
/**
diff --git a/libavcodec/atrac3plusdec.c b/libavcodec/atrac3plusdec.c
index 4a742c1..17774d5 100644
--- a/libavcodec/atrac3plusdec.c
+++ b/libavcodec/atrac3plusdec.c
@@ -39,14 +39,15 @@
#include "libavutil/channel_layout.h"
#include "libavutil/float_dsp.h"
+
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "internal.h"
#include "atrac.h"
#include "atrac3plus.h"
typedef struct ATRAC3PContext {
- GetBitContext gb;
+ BitstreamContext bc;
AVFloatDSPContext fdsp;
DECLARE_ALIGNED(32, float, samples)[2][ATRAC3P_FRAME_SAMPLES]; ///< quantized MDCT spectrum
@@ -334,16 +335,16 @@ static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
return ret;
}
- if ((ret = init_get_bits8(&ctx->gb, avpkt->data, avpkt->size)) < 0)
+ if ((ret = bitstream_init8(&ctx->bc, avpkt->data, avpkt->size)) < 0)
return ret;
- if (get_bits1(&ctx->gb)) {
+ if (bitstream_read_bit(&ctx->bc)) {
av_log(avctx, AV_LOG_ERROR, "Invalid start bit!\n");
return AVERROR_INVALIDDATA;
}
- while (get_bits_left(&ctx->gb) >= 2 &&
- (ch_unit_id = get_bits(&ctx->gb, 2)) != CH_UNIT_TERMINATOR) {
+ while (bitstream_bits_left(&ctx->bc) >= 2 &&
+ (ch_unit_id = bitstream_read(&ctx->bc, 2)) != CH_UNIT_TERMINATOR) {
if (ch_unit_id == CH_UNIT_EXTENSION) {
avpriv_report_missing_feature(avctx, "Channel unit extension");
return AVERROR_PATCHWELCOME;
@@ -358,7 +359,7 @@ static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
ctx->ch_units[ch_block].unit_type = ch_unit_id;
channels_to_process = ch_unit_id + 1;
- if ((ret = ff_atrac3p_decode_channel_unit(&ctx->gb,
+ if ((ret = ff_atrac3p_decode_channel_unit(&ctx->bc,
&ctx->ch_units[ch_block],
channels_to_process,
avctx)) < 0)
More information about the ffmpeg-cvslog
mailing list