From: Alexandra Hájková <[email protected]>
---
libavcodec/dca.h | 6 +-
libavcodec/dca_exss.c | 166 ++++++++++++++++++------------------
libavcodec/dca_parser.c | 16 ++--
libavcodec/dca_xll.c | 160 +++++++++++++++++------------------
libavcodec/dcadec.c | 219 ++++++++++++++++++++++++------------------------
5 files changed, 284 insertions(+), 283 deletions(-)
diff --git a/libavcodec/dca.h b/libavcodec/dca.h
index 787a9c7..04d4487 100644
--- a/libavcodec/dca.h
+++ b/libavcodec/dca.h
@@ -31,9 +31,9 @@
#include "libavutil/internal.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "dcadsp.h"
#include "fmtconvert.h"
-#include "get_bits.h"
#define DCA_PRIM_CHANNELS_MAX (7)
#define DCA_ABITS_MAX (32) /* Should be 28 */
@@ -117,7 +117,7 @@ typedef struct XllChSetSubHeader {
} XllChSetSubHeader;
typedef struct XllNavi {
- GetBitContext gb; // Context for parsing the data segments
+ BitstreamContext bc; // Context for parsing the data segments
unsigned band_size[DCA_XLL_FBANDS_MAX];
unsigned segment_size[DCA_XLL_FBANDS_MAX][DCA_XLL_SEGMENTS_MAX];
unsigned
chset_size[DCA_XLL_FBANDS_MAX][DCA_XLL_SEGMENTS_MAX][DCA_XLL_CHSETS_MAX];
@@ -239,7 +239,7 @@ typedef struct DCAContext {
int dca_buffer_size; ///< how much data is in the dca_buffer
const int8_t *channel_order_tab; ///< channel reordering table, lfe and
non lfe
- GetBitContext gb;
+ BitstreamContext bc;
/* Current position in DCA frame */
int current_subframe;
int current_subsubframe;
diff --git a/libavcodec/dca_exss.c b/libavcodec/dca_exss.c
index 2895e20..846be41 100644
--- a/libavcodec/dca_exss.c
+++ b/libavcodec/dca_exss.c
@@ -21,9 +21,9 @@
#include "libavutil/common.h"
#include "libavutil/log.h"
+#include "bitstream.h"
#include "dca.h"
#include "dca_syncwords.h"
-#include "get_bits.h"
/* extensions that reside in core substream */
#define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
@@ -69,14 +69,14 @@ static int dca_exss_mask2count(int mask)
/**
* Skip mixing coefficients of a single mix out configuration (HD)
*/
-static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int
out_ch)
+static void dca_exss_skip_mix_coeffs(BitstreamContext *bc, int channels, int
out_ch)
{
int i;
for (i = 0; i < channels; i++) {
- int mix_map_mask = get_bits(gb, out_ch);
+ int mix_map_mask = bitstream_read(bc, out_ch);
int num_coeffs = av_popcount(mix_map_mask);
- skip_bits_long(gb, num_coeffs * 6);
+ bitstream_skip(bc, num_coeffs * 6);
}
}
@@ -85,7 +85,7 @@ static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int
channels, int out_ch
*/
static int dca_exss_parse_asset_header(DCAContext *s)
{
- int header_pos = get_bits_count(&s->gb);
+ int header_pos = bitstream_tell(&s->bc);
int header_size;
int channels = 0;
int embedded_stereo = 0;
@@ -94,112 +94,112 @@ static int dca_exss_parse_asset_header(DCAContext *s)
int extensions_mask = 0;
int i, j;
- if (get_bits_left(&s->gb) < 16)
+ if (bitstream_bits_left(&s->bc) < 16)
return AVERROR_INVALIDDATA;
/* We will parse just enough to get to the extensions bitmask with which
* we can set the profile value. */
- header_size = get_bits(&s->gb, 9) + 1;
- skip_bits(&s->gb, 3); // asset index
+ header_size = bitstream_read(&s->bc, 9) + 1;
+ bitstream_skip(&s->bc, 3); // asset index
if (s->static_fields) {
- if (get_bits1(&s->gb))
- skip_bits(&s->gb, 4); // asset type descriptor
- if (get_bits1(&s->gb))
- skip_bits_long(&s->gb, 24); // language descriptor
+ if (bitstream_read_bit(&s->bc))
+ bitstream_skip(&s->bc, 4); // asset type descriptor
+ if (bitstream_read_bit(&s->bc))
+ bitstream_skip(&s->bc, 24); // language descriptor
- if (get_bits1(&s->gb)) {
+ if (bitstream_read_bit(&s->bc)) {
/* How can one fit 1024 bytes of text here if the maximum value
* for the asset header size field above was 512 bytes? */
- int text_length = get_bits(&s->gb, 10) + 1;
- if (get_bits_left(&s->gb) < text_length * 8)
+ int text_length = bitstream_read(&s->bc, 10) + 1;
+ if (bitstream_bits_left(&s->bc) < text_length * 8)
return AVERROR_INVALIDDATA;
- skip_bits_long(&s->gb, text_length * 8); // info text
+ bitstream_skip(&s->bc, text_length * 8); // info text
}
- skip_bits(&s->gb, 5); // bit resolution - 1
- skip_bits(&s->gb, 4); // max sample rate code
- channels = get_bits(&s->gb, 8) + 1;
+ bitstream_skip(&s->bc, 5); // bit resolution - 1
+ bitstream_skip(&s->bc, 4); // max sample rate code
+ channels = bitstream_read(&s->bc, 8) + 1;
- s->one2one_map_chtospkr = get_bits1(&s->gb);
+ s->one2one_map_chtospkr = bitstream_read_bit(&s->bc);
if (s->one2one_map_chtospkr) {
int spkr_remap_sets;
int spkr_mask_size = 16;
int num_spkrs[7];
if (channels > 2)
- embedded_stereo = get_bits1(&s->gb);
+ embedded_stereo = bitstream_read_bit(&s->bc);
if (channels > 6)
- embedded_6ch = get_bits1(&s->gb);
+ embedded_6ch = bitstream_read_bit(&s->bc);
- if (get_bits1(&s->gb)) {
- spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
- skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
+ if (bitstream_read_bit(&s->bc)) {
+ spkr_mask_size = (bitstream_read(&s->bc, 2) + 1) << 2;
+ bitstream_skip(&s->bc, spkr_mask_size); // spkr activity mask
}
- spkr_remap_sets = get_bits(&s->gb, 3);
+ spkr_remap_sets = bitstream_read(&s->bc, 3);
for (i = 0; i < spkr_remap_sets; i++) {
/* std layout mask for each remap set */
- num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb,
spkr_mask_size));
+ num_spkrs[i] = dca_exss_mask2count(bitstream_read(&s->bc,
spkr_mask_size));
}
for (i = 0; i < spkr_remap_sets; i++) {
- int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
- if (get_bits_left(&s->gb) < 0)
+ int num_dec_ch_remaps = bitstream_read(&s->bc, 5) + 1;
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
for (j = 0; j < num_spkrs[i]; j++) {
- int remap_dec_ch_mask = get_bits_long(&s->gb,
num_dec_ch_remaps);
+ int remap_dec_ch_mask = bitstream_read(&s->bc,
num_dec_ch_remaps);
int num_dec_ch = av_popcount(remap_dec_ch_mask);
- skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
+ bitstream_skip(&s->bc, num_dec_ch * 5); // remap codes
}
}
} else {
- skip_bits(&s->gb, 3); // representation type
+ bitstream_skip(&s->bc, 3); // representation type
}
}
- drc_code_present = get_bits1(&s->gb);
+ drc_code_present = bitstream_read_bit(&s->bc);
if (drc_code_present)
- get_bits(&s->gb, 8); // drc code
+ bitstream_read(&s->bc, 8); // drc code
- if (get_bits1(&s->gb))
- skip_bits(&s->gb, 5); // dialog normalization code
+ if (bitstream_read_bit(&s->bc))
+ bitstream_skip(&s->bc, 5); // dialog normalization code
if (drc_code_present && embedded_stereo)
- get_bits(&s->gb, 8); // drc stereo code
+ bitstream_read(&s->bc, 8); // drc stereo code
- if (s->mix_metadata && get_bits1(&s->gb)) {
- skip_bits(&s->gb, 1); // external mix
- skip_bits(&s->gb, 6); // post mix gain code
+ if (s->mix_metadata && bitstream_read_bit(&s->bc)) {
+ bitstream_skip(&s->bc, 1); // external mix
+ bitstream_skip(&s->bc, 6); // post mix gain code
- if (get_bits(&s->gb, 2) != 3) // mixer drc code
- skip_bits(&s->gb, 3); // drc limit
+ if (bitstream_read(&s->bc, 2) != 3) // mixer drc code
+ bitstream_skip(&s->bc, 3); // drc limit
else
- skip_bits(&s->gb, 8); // custom drc code
+ bitstream_skip(&s->bc, 8); // custom drc code
- if (get_bits1(&s->gb)) // channel specific scaling
+ if (bitstream_read_bit(&s->bc)) // channel specific scaling
for (i = 0; i < s->num_mix_configs; i++)
- skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale
codes
+ bitstream_skip(&s->bc, s->mix_config_num_ch[i] * 6); // scale
codes
else
- skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
+ bitstream_skip(&s->bc, s->num_mix_configs * 6); // scale codes
for (i = 0; i < s->num_mix_configs; i++) {
- if (get_bits_left(&s->gb) < 0)
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
- dca_exss_skip_mix_coeffs(&s->gb, channels,
s->mix_config_num_ch[i]);
+ dca_exss_skip_mix_coeffs(&s->bc, channels,
s->mix_config_num_ch[i]);
if (embedded_6ch)
- dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
+ dca_exss_skip_mix_coeffs(&s->bc, 6, s->mix_config_num_ch[i]);
if (embedded_stereo)
- dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
+ dca_exss_skip_mix_coeffs(&s->bc, 2, s->mix_config_num_ch[i]);
}
}
- switch (get_bits(&s->gb, 2)) {
+ switch (bitstream_read(&s->bc, 2)) {
case 0:
- extensions_mask = get_bits(&s->gb, 12);
+ extensions_mask = bitstream_read(&s->bc, 12);
break;
case 1:
extensions_mask = DCA_EXT_EXSS_XLL;
@@ -214,14 +214,14 @@ static int dca_exss_parse_asset_header(DCAContext *s)
/* not parsed further, we were only interested in the extensions mask */
- if (get_bits_left(&s->gb) < 0)
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
- if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
+ if (bitstream_tell(&s->bc) - header_pos > header_size * 8) {
av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
return AVERROR_INVALIDDATA;
}
- skip_bits_long(&s->gb, header_pos + header_size * 8 -
get_bits_count(&s->gb));
+ bitstream_skip(&s->bc, header_pos + header_size * 8 -
bitstream_tell(&s->bc));
if (extensions_mask & DCA_EXT_EXSS_XLL)
s->profile = FF_PROFILE_DTS_HD_MA;
@@ -255,30 +255,30 @@ void ff_dca_exss_parse_header(DCAContext *s)
int hdrsize;
uint32_t mkr;
- if (get_bits_left(&s->gb) < 52)
+ if (bitstream_bits_left(&s->bc) < 52)
return;
- start_pos = get_bits_count(&s->gb) - 32;
+ start_pos = bitstream_tell(&s->bc) - 32;
- skip_bits(&s->gb, 8); // user data
- ss_index = get_bits(&s->gb, 2);
+ bitstream_skip(&s->bc, 8); // user data
+ ss_index = bitstream_read(&s->bc, 2);
- blownup = get_bits1(&s->gb);
- hdrsize = get_bits(&s->gb, 8 + 4 * blownup) + 1; // header_size
- skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
+ blownup = bitstream_read_bit(&s->bc);
+ hdrsize = bitstream_read(&s->bc, 8 + 4 * blownup) + 1; // header_size
+ bitstream_skip(&s->bc, 16 + 4 * blownup); // hd_size
- s->static_fields = get_bits1(&s->gb);
+ s->static_fields = bitstream_read_bit(&s->bc);
if (s->static_fields) {
- skip_bits(&s->gb, 2); // reference clock code
- skip_bits(&s->gb, 3); // frame duration code
+ bitstream_skip(&s->bc, 2); // reference clock code
+ bitstream_skip(&s->bc, 3); // frame duration code
- if (get_bits1(&s->gb))
- skip_bits_long(&s->gb, 36); // timestamp
+ if (bitstream_read_bit(&s->bc))
+ bitstream_skip(&s->bc, 36); // timestamp
/* a single stream can contain multiple audio assets that can be
* combined to form multiple audio presentations */
- num_audiop = get_bits(&s->gb, 3) + 1;
+ num_audiop = bitstream_read(&s->bc, 3) + 1;
if (num_audiop > 1) {
avpriv_request_sample(s->avctx,
"Multiple DTS-HD audio presentations");
@@ -286,7 +286,7 @@ void ff_dca_exss_parse_header(DCAContext *s)
return;
}
- num_assets = get_bits(&s->gb, 3) + 1;
+ num_assets = bitstream_read(&s->bc, 3) + 1;
if (num_assets > 1) {
avpriv_request_sample(s->avctx, "Multiple DTS-HD audio assets");
/* ignore such streams for now */
@@ -294,30 +294,30 @@ void ff_dca_exss_parse_header(DCAContext *s)
}
for (i = 0; i < num_audiop; i++)
- active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
+ active_ss_mask[i] = bitstream_read(&s->bc, ss_index + 1);
for (i = 0; i < num_audiop; i++)
for (j = 0; j <= ss_index; j++)
if (active_ss_mask[i] & (1 << j))
- skip_bits(&s->gb, 8); // active asset mask
+ bitstream_skip(&s->bc, 8); // active asset mask
- s->mix_metadata = get_bits1(&s->gb);
+ s->mix_metadata = bitstream_read_bit(&s->bc);
if (s->mix_metadata) {
int mix_out_mask_size;
- skip_bits(&s->gb, 2); // adjustment level
- mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
- s->num_mix_configs = get_bits(&s->gb, 2) + 1;
+ bitstream_skip(&s->bc, 2); // adjustment level
+ mix_out_mask_size = (bitstream_read(&s->bc, 2) + 1) << 2;
+ s->num_mix_configs = bitstream_read(&s->bc, 2) + 1;
for (i = 0; i < s->num_mix_configs; i++) {
- int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
+ int mix_out_mask = bitstream_read(&s->bc,
mix_out_mask_size);
s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
}
}
}
for (i = 0; i < num_assets; i++)
- asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
+ asset_size[i] = bitstream_read(&s->bc, 16 + 4 * blownup) + 1;
for (i = 0; i < num_assets; i++) {
if (dca_exss_parse_asset_header(s))
@@ -325,15 +325,15 @@ void ff_dca_exss_parse_header(DCAContext *s)
}
if (num_assets > 0) {
- j = get_bits_count(&s->gb);
+ j = bitstream_tell(&s->bc);
if (start_pos + hdrsize * 8 > j)
- skip_bits_long(&s->gb, start_pos + hdrsize * 8 - j);
+ bitstream_skip(&s->bc, start_pos + hdrsize * 8 - j);
for (i = 0; i < num_assets; i++) {
int end_pos;
- start_pos = get_bits_count(&s->gb);
+ start_pos = bitstream_tell(&s->bc);
end_pos = start_pos + asset_size[i] * 8;
- mkr = get_bits_long(&s->gb, 32);
+ mkr = bitstream_read(&s->bc, 32);
/* parse extensions that we know about */
switch (mkr) {
@@ -357,12 +357,12 @@ void ff_dca_exss_parse_header(DCAContext *s)
}
/* skip to end of block */
- j = get_bits_count(&s->gb);
+ j = bitstream_tell(&s->bc);
if (j > end_pos)
av_log(s->avctx, AV_LOG_ERROR,
"DTS-ExSS: Processed asset too long.\n");
if (j < end_pos)
- skip_bits_long(&s->gb, end_pos - j);
+ bitstream_skip(&s->bc, end_pos - j);
}
}
}
diff --git a/libavcodec/dca_parser.c b/libavcodec/dca_parser.c
index c33cc9a..9773792 100644
--- a/libavcodec/dca_parser.c
+++ b/libavcodec/dca_parser.c
@@ -22,9 +22,9 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "bitstream.h"
#include "dca.h"
#include "dca_syncwords.h"
-#include "get_bits.h"
#include "parser.h"
typedef struct DCAParseContext {
@@ -112,7 +112,7 @@ static av_cold int dca_parse_init(AVCodecParserContext *s)
static int dca_parse_params(const uint8_t *buf, int buf_size, int *duration,
int *sample_rate, int *framesize)
{
- GetBitContext gb;
+ BitstreamContext bc;
uint8_t hdr[12 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
int ret, sample_blocks, sr_code;
@@ -122,20 +122,20 @@ static int dca_parse_params(const uint8_t *buf, int
buf_size, int *duration,
if ((ret = ff_dca_convert_bitstream(buf, 12, hdr, 12)) < 0)
return ret;
- init_get_bits(&gb, hdr, 96);
+ bitstream_init(&bc, hdr, 96);
- skip_bits_long(&gb, 39);
- sample_blocks = get_bits(&gb, 7) + 1;
+ bitstream_skip(&bc, 39);
+ sample_blocks = bitstream_read(&bc, 7) + 1;
if (sample_blocks < 8)
return AVERROR_INVALIDDATA;
*duration = 256 * (sample_blocks / 8);
- *framesize = get_bits(&gb, 14) + 1;
+ *framesize = bitstream_read(&bc, 14) + 1;
if (*framesize < 95)
return AVERROR_INVALIDDATA;
- skip_bits(&gb, 6);
- sr_code = get_bits(&gb, 4);
+ bitstream_skip(&bc, 6);
+ sr_code = bitstream_read(&bc, 4);
*sample_rate = avpriv_dca_sample_rates[sr_code];
if (*sample_rate == 0)
return AVERROR_INVALIDDATA;
diff --git a/libavcodec/dca_xll.c b/libavcodec/dca_xll.c
index 5d76793..9141136 100644
--- a/libavcodec/dca_xll.c
+++ b/libavcodec/dca_xll.c
@@ -26,15 +26,15 @@
#include "libavutil/internal.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "dca.h"
#include "dcadata.h"
-#include "get_bits.h"
-#include "unary_legacy.h"
+#include "unary.h"
/* Sign as bit 0 */
-static inline int get_bits_sm(GetBitContext *s, unsigned n)
+static inline int get_bits_sm(BitstreamContext *bc, unsigned n)
{
- int x = get_bits(s, n);
+ int x = bitstream_read(bc, n);
if (x & 1)
return -(x >> 1) - 1;
else
@@ -44,7 +44,7 @@ static inline int get_bits_sm(GetBitContext *s, unsigned n)
/* Return -1 on error. */
static int32_t get_dmix_coeff(DCAContext *s, int inverse)
{
- unsigned code = get_bits(&s->gb, 9);
+ unsigned code = bitstream_read(&s->bc, 9);
int32_t sign = (int32_t) (code >> 8) - 1;
unsigned idx = code & 0xff;
int inv_offset = FF_DCA_DMIXTABLE_SIZE -FF_DCA_INV_DMIXTABLE_SIZE;
@@ -81,58 +81,58 @@ int ff_dca_xll_decode_header(DCAContext *s)
int i, chset_index;
/* get bit position of sync header */
- hdr_pos = get_bits_count(&s->gb) - 32;
+ hdr_pos = bitstream_tell(&s->bc) - 32;
- version = get_bits(&s->gb, 4) + 1;
- hdr_size = get_bits(&s->gb, 8) + 1;
+ version = bitstream_read(&s->bc, 4) + 1;
+ hdr_size = bitstream_read(&s->bc, 8) + 1;
- frame_size = get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1) + 1;
+ frame_size = bitstream_read(&s->bc, bitstream_read(&s->bc, 5) + 1) + 1;
s->xll_channels =
s->xll_residual_channels = 0;
- s->xll_nch_sets = get_bits(&s->gb, 4) + 1;
- s->xll_segments = 1 << get_bits(&s->gb, 4);
- s->xll_log_smpl_in_seg = get_bits(&s->gb, 4);
+ s->xll_nch_sets = bitstream_read(&s->bc, 4) + 1;
+ s->xll_segments = 1 << bitstream_read(&s->bc, 4);
+ s->xll_log_smpl_in_seg = bitstream_read(&s->bc, 4);
s->xll_smpl_in_seg = 1 << s->xll_log_smpl_in_seg;
- s->xll_bits4seg_size = get_bits(&s->gb, 5) + 1;
- s->xll_banddata_crc = get_bits(&s->gb, 2);
- s->xll_scalable_lsb = get_bits1(&s->gb);
- s->xll_bits4ch_mask = get_bits(&s->gb, 5) + 1;
+ s->xll_bits4seg_size = bitstream_read(&s->bc, 5) + 1;
+ s->xll_banddata_crc = bitstream_read(&s->bc, 2);
+ s->xll_scalable_lsb = bitstream_read_bit(&s->bc);
+ s->xll_bits4ch_mask = bitstream_read(&s->bc, 5) + 1;
if (s->xll_scalable_lsb) {
- s->xll_fixed_lsb_width = get_bits(&s->gb, 4);
+ s->xll_fixed_lsb_width = bitstream_read(&s->bc, 4);
if (s->xll_fixed_lsb_width)
av_log(s->avctx, AV_LOG_WARNING,
"XLL: fixed lsb width = %d, non-zero not supported.\n",
s->xll_fixed_lsb_width);
}
/* skip to the end of the common header */
- i = get_bits_count(&s->gb);
+ i = bitstream_tell(&s->bc);
if (hdr_pos + hdr_size * 8 > i)
- skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
+ bitstream_skip(&s->bc, hdr_pos + hdr_size * 8 - i);
for (chset_index = 0; chset_index < s->xll_nch_sets; chset_index++) {
XllChSetSubHeader *chset = &s->xll_chsets[chset_index];
- hdr_pos = get_bits_count(&s->gb);
- hdr_size = get_bits(&s->gb, 10) + 1;
-
- chset->channels = get_bits(&s->gb, 4) + 1;
- chset->residual_encode = get_bits(&s->gb, chset->channels);
- chset->bit_resolution = get_bits(&s->gb, 5) + 1;
- chset->bit_width = get_bits(&s->gb, 5) + 1;
- chset->sampling_frequency = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];
- chset->samp_freq_interp = get_bits(&s->gb, 2);
- chset->replacement_set = get_bits(&s->gb, 2);
+ hdr_pos = bitstream_tell(&s->bc);
+ hdr_size = bitstream_read(&s->bc, 10) + 1;
+
+ chset->channels = bitstream_read(&s->bc, 4) + 1;
+ chset->residual_encode = bitstream_read(&s->bc, chset->channels);
+ chset->bit_resolution = bitstream_read(&s->bc, 5) + 1;
+ chset->bit_width = bitstream_read(&s->bc, 5) + 1;
+ chset->sampling_frequency =
ff_dca_sampling_freqs[bitstream_read(&s->bc, 4)];
+ chset->samp_freq_interp = bitstream_read(&s->bc, 2);
+ chset->replacement_set = bitstream_read(&s->bc, 2);
if (chset->replacement_set)
- chset->active_replace_set = get_bits(&s->gb, 1);
+ chset->active_replace_set = bitstream_read(&s->bc, 1);
if (s->one2one_map_chtospkr) {
- chset->primary_ch_set = get_bits(&s->gb, 1);
- chset->downmix_coeff_code_embedded = get_bits(&s->gb, 1);
+ chset->primary_ch_set = bitstream_read(&s->bc, 1);
+ chset->downmix_coeff_code_embedded = bitstream_read(&s->bc, 1);
if (chset->downmix_coeff_code_embedded) {
- chset->downmix_embedded = get_bits(&s->gb, 1);
+ chset->downmix_embedded = bitstream_read(&s->bc, 1);
if (chset->primary_ch_set) {
- chset->downmix_type = get_bits(&s->gb, 3);
+ chset->downmix_type = bitstream_read(&s->bc, 3);
if (chset->downmix_type > 6) {
av_log(s->avctx, AV_LOG_ERROR,
"XLL: Invalid channel set downmix type\n");
@@ -140,7 +140,7 @@ int ff_dca_xll_decode_header(DCAContext *s)
}
}
}
- chset->hier_chset = get_bits(&s->gb, 1);
+ chset->hier_chset = bitstream_read(&s->bc, 1);
if (chset->downmix_coeff_code_embedded) {
/* nDownmixCoeffs is specified as N * M. For a primary
@@ -182,24 +182,24 @@ int ff_dca_xll_decode_header(DCAContext *s)
}
}
}
- chset->ch_mask_enabled = get_bits(&s->gb, 1);
+ chset->ch_mask_enabled = bitstream_read(&s->bc, 1);
if (chset->ch_mask_enabled)
- chset->ch_mask = get_bits(&s->gb, s->xll_bits4ch_mask);
+ chset->ch_mask = bitstream_read(&s->bc, s->xll_bits4ch_mask);
else
/* Skip speaker configuration bits */
- skip_bits_long(&s->gb, 25 * chset->channels);
+ bitstream_skip(&s->bc, 25 * chset->channels);
} else {
chset->primary_ch_set = 1;
chset->downmix_coeff_code_embedded = 0;
/* Spec: NumChHierChSet = 0, NumDwnMixCodeCoeffs = 0, whatever
that means. */
- chset->mapping_coeffs_present = get_bits(&s->gb, 1);
+ chset->mapping_coeffs_present = bitstream_read(&s->bc, 1);
if (chset->mapping_coeffs_present) {
avpriv_report_missing_feature(s->avctx, "XLL: mapping
coefficients");
return AVERROR_PATCHWELCOME;
}
}
if (chset->sampling_frequency > 96000)
- chset->num_freq_bands = 2 * (1 + get_bits(&s->gb, 1));
+ chset->num_freq_bands = 2 * (1 + bitstream_read(&s->bc, 1));
else
chset->num_freq_bands = 1;
@@ -208,10 +208,10 @@ int ff_dca_xll_decode_header(DCAContext *s)
return AVERROR_PATCHWELCOME;
}
- if (get_bits(&s->gb, 1)) { /* pw_ch_decor_enabled */
+ if (bitstream_read(&s->bc, 1)) { /* pw_ch_decor_enabled */
int bits = av_ceil_log2(chset->channels);
for (i = 0; i < chset->channels; i++) {
- unsigned j = get_bits(&s->gb, bits);
+ unsigned j = bitstream_read(&s->bc, bits);
if (j >= chset->channels) {
av_log(s->avctx, AV_LOG_ERROR,
"Original channel order value %u too large, only %d
channels.\n",
@@ -222,8 +222,8 @@ int ff_dca_xll_decode_header(DCAContext *s)
chset->orig_chan_order_inv[0][j] = i;
}
for (i = 0; i < chset->channels / 2; i++) {
- if (get_bits(&s->gb, 1)) /* bChPFlag */
- chset->pw_ch_pairs_coeffs[0][i] = get_bits_sm(&s->gb, 7);
+ if (bitstream_read(&s->bc, 1)) /* bChPFlag */
+ chset->pw_ch_pairs_coeffs[0][i] = get_bits_sm(&s->bc, 7);
else
chset->pw_ch_pairs_coeffs[0][i] = 0;
}
@@ -237,7 +237,7 @@ int ff_dca_xll_decode_header(DCAContext *s)
/* Adaptive prediction order */
chset->adapt_order_max[0] = 0;
for (i = 0; i < chset->channels; i++) {
- chset->adapt_order[0][i] = get_bits(&s->gb, 4);
+ chset->adapt_order[0][i] = bitstream_read(&s->bc, 4);
if (chset->adapt_order_max[0] < chset->adapt_order[0][i])
chset->adapt_order_max[0] = chset->adapt_order[0][i];
}
@@ -245,21 +245,21 @@ int ff_dca_xll_decode_header(DCAContext *s)
* above is zero */
for (i = 0; i < chset->channels; i++)
chset->fixed_order[0][i] =
- chset->adapt_order[0][i] ? 0 : get_bits(&s->gb, 2);
+ chset->adapt_order[0][i] ? 0 : bitstream_read(&s->bc, 2);
for (i = 0; i < chset->channels; i++) {
unsigned j;
for (j = 0; j < chset->adapt_order[0][i]; j++)
- chset->lpc_refl_coeffs_q_ind[0][i][j] = get_bits(&s->gb, 8);
+ chset->lpc_refl_coeffs_q_ind[0][i][j] = bitstream_read(&s->bc,
8);
}
if (s->xll_scalable_lsb) {
- chset->lsb_fsize[0] = get_bits(&s->gb, s->xll_bits4seg_size);
+ chset->lsb_fsize[0] = bitstream_read(&s->bc, s->xll_bits4seg_size);
for (i = 0; i < chset->channels; i++)
- chset->scalable_lsbs[0][i] = get_bits(&s->gb, 4);
+ chset->scalable_lsbs[0][i] = bitstream_read(&s->bc, 4);
for (i = 0; i < chset->channels; i++)
- chset->bit_width_adj_per_ch[0][i] = get_bits(&s->gb, 4);
+ chset->bit_width_adj_per_ch[0][i] = bitstream_read(&s->bc, 4);
} else {
memset(chset->scalable_lsbs[0], 0,
chset->channels * sizeof(chset->scalable_lsbs[0][0]));
@@ -274,7 +274,7 @@ int ff_dca_xll_decode_header(DCAContext *s)
/* FIXME: Parse header data for extra frequency bands. */
/* Skip to end of channel set sub header. */
- i = get_bits_count(&s->gb);
+ i = bitstream_tell(&s->bc);
if (hdr_pos + 8 * hdr_size < i) {
av_log(s->avctx, AV_LOG_ERROR,
"chset header too large, %d bits, should be <= %d bits\n",
@@ -282,7 +282,7 @@ int ff_dca_xll_decode_header(DCAContext *s)
return AVERROR_INVALIDDATA;
}
if (hdr_pos + 8 * hdr_size > i)
- skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
+ bitstream_skip(&s->bc, hdr_pos + 8 * hdr_size - i);
}
return 0;
}
@@ -307,7 +307,7 @@ int ff_dca_xll_decode_navi(DCAContext *s, int asset_end)
for (chset = 0; chset < s->xll_nch_sets; chset++)
if (band < s->xll_chsets[chset].num_freq_bands) {
s->xll_navi.chset_size[band][seg][chset] =
- get_bits(&s->gb, s->xll_bits4seg_size) + 1;
+ bitstream_read(&s->bc, s->xll_bits4seg_size) + 1;
s->xll_navi.segment_size[band][seg] +=
s->xll_navi.chset_size[band][seg][chset];
}
@@ -315,9 +315,9 @@ int ff_dca_xll_decode_navi(DCAContext *s, int asset_end)
}
}
/* Align to 8 bits and skip 16-bit CRC. */
- skip_bits_long(&s->gb, 16 + ((-get_bits_count(&s->gb)) & 7));
+ bitstream_skip(&s->bc, 16 + ((-bitstream_tell(&s->bc)) & 7));
- data_start = get_bits_count(&s->gb);
+ data_start = bitstream_tell(&s->bc);
if (data_start + 8 * s->xll_navi.band_size[0] > asset_end) {
av_log(s->avctx, AV_LOG_ERROR,
"XLL: Data in NAVI table exceeds containing asset\n"
@@ -326,8 +326,8 @@ int ff_dca_xll_decode_navi(DCAContext *s, int asset_end)
data_start + 8 * s->xll_navi.band_size[0] - asset_end);
return AVERROR_INVALIDDATA;
}
- init_get_bits(&s->xll_navi.gb, s->gb.buffer + data_start / 8,
- 8 * s->xll_navi.band_size[0]);
+ bitstream_init8(&s->xll_navi.bc, s->bc.buffer + data_start / 8,
+ s->xll_navi.band_size[0]);
return 0;
}
@@ -421,7 +421,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
int nSamplPart0[16];
} param_state[16];
- GetBitContext *gb = &s->xll_navi.gb;
+ BitstreamContext *bc = &s->xll_navi.bc;
int *history;
/* Layout: First the sample buffer for one segment per channel,
@@ -440,7 +440,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
for (chset_i = in_channel = 0; chset_i < s->xll_nch_sets; chset_i++) {
/* The spec isn't very explicit, but I think the NAVI sizes are in
bytes. */
- int end_pos = get_bits_count(gb) +
+ int end_pos = bitstream_tell(bc) +
8 * s->xll_navi.chset_size[0][seg][chset_i];
int i, j;
struct coding_params *params = ¶m_state[chset_i];
@@ -459,7 +459,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
goto next_chset;
}
if (seg != 0)
- use_seg_state_code_param = get_bits(gb, 1);
+ use_seg_state_code_param = bitstream_read(bc, 1);
else
use_seg_state_code_param = 0;
@@ -467,7 +467,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
int num_param_sets, i;
unsigned bits4ABIT;
- params->seg_type = get_bits(gb, 1);
+ params->seg_type = bitstream_read(bc, 1);
num_param_sets = params->seg_type ? 1 : chset->channels;
if (chset->bit_width > 16) {
@@ -482,9 +482,9 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
}
for (i = 0; i < num_param_sets; i++) {
- params->rice_code_flag[i] = get_bits(gb, 1);
- if (!params->seg_type && params->rice_code_flag[i] &&
get_bits(gb, 1))
- params->pancAuxABIT[i] = get_bits(gb, bits4ABIT) + 1;
+ params->rice_code_flag[i] = bitstream_read(bc, 1);
+ if (!params->seg_type && params->rice_code_flag[i] &&
bitstream_read(bc, 1))
+ params->pancAuxABIT[i] = bitstream_read(bc, bits4ABIT)
+ 1;
else
params->pancAuxABIT[i] = 0;
}
@@ -492,7 +492,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
for (i = 0; i < num_param_sets; i++) {
if (!seg) {
/* Parameters for part 1 */
- params->pancABIT0[i] = get_bits(gb, bits4ABIT);
+ params->pancABIT0[i] = bitstream_read(bc, bits4ABIT);
if (params->rice_code_flag[i] == 0 &&
params->pancABIT0[i] > 0)
/* For linear code */
params->pancABIT0[i]++;
@@ -506,7 +506,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
params->nSamplPart0[i] = 0;
/* Parameters for part 2 */
- params->pancABIT[i] = get_bits(gb, bits4ABIT);
+ params->pancABIT[i] = bitstream_read(bc, bits4ABIT);
if (params->rice_code_flag[i] == 0 && params->pancABIT[i]
> 0)
/* For linear code */
params->pancABIT[i]++;
@@ -523,7 +523,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
/* Linear code */
if (bits)
for (j = 0; j < part0; j++)
- sample_buf[j] = get_bits_sm(gb, bits);
+ sample_buf[j] = get_bits_sm(bc, bits);
else
memset(sample_buf, 0, part0 * sizeof(sample_buf[0]));
@@ -531,7 +531,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
bits = params->pancABIT[param_index];
if (bits)
for (j = part0; j < s->xll_smpl_in_seg; j++)
- sample_buf[j] = get_bits_sm(gb, bits);
+ sample_buf[j] = get_bits_sm(bc, bits);
else
memset(sample_buf + part0, 0,
(s->xll_smpl_in_seg - part0) *
sizeof(sample_buf[0]));
@@ -540,10 +540,10 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
for (j = 0; j < part0; j++) {
/* FIXME: Is this identical to Golomb code? */
- int t = get_unary(gb, 1, 33) << bits;
+ int t = get_unary(bc, 1, 33) << bits;
/* FIXME: Could move this test outside of the loop,
for efficiency. */
if (bits)
- t |= get_bits(gb, bits);
+ t |= bitstream_read(bc, bits);
sample_buf[j] = (t & 1) ? -(t >> 1) - 1 : (t >> 1);
}
@@ -561,21 +561,21 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
* are used for each index, but this value is not
* defined. I guess we should use log2(xll_smpl_in_seg)
* bits. */
- int count = get_bits(gb, s->xll_log_smpl_in_seg);
+ int count = bitstream_read(bc, s->xll_log_smpl_in_seg);
av_log(s->avctx, AV_LOG_DEBUG, "aux count %d (bits
%d)\n",
count, s->xll_log_smpl_in_seg);
for (j = 0; j < count; j++)
- sample_buf[get_bits(gb, s->xll_log_smpl_in_seg)] =
1;
+ sample_buf[bitstream_read(bc,
s->xll_log_smpl_in_seg)] = 1;
}
for (j = part0; j < s->xll_smpl_in_seg; j++) {
if (!sample_buf[j]) {
- int t = get_unary(gb, 1, 33);
+ int t = get_unary(bc, 1, 33);
if (bits)
- t = (t << bits) | get_bits(gb, bits);
+ t = (t << bits) | bitstream_read(bc, bits);
sample_buf[j] = (t & 1) ? -(t >> 1) - 1 : (t >> 1);
} else
- sample_buf[j] = get_bits_sm(gb, aux_bits);
+ sample_buf[j] = get_bits_sm(bc, aux_bits);
}
}
}
@@ -618,7 +618,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
int lsb_start = end_pos - 8 * chset->lsb_fsize[0] -
8 * (s->xll_banddata_crc & 2);
int done;
- i = get_bits_count(gb);
+ i = bitstream_tell(bc);
if (i > lsb_start) {
av_log(s->avctx, AV_LOG_ERROR,
"chset data lsb exceeds NAVI size, end_pos %d,
lsb_start %d, pos %d\n",
@@ -626,7 +626,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
return AVERROR_INVALIDDATA;
}
if (i < lsb_start)
- skip_bits_long(gb, lsb_start - i);
+ bitstream_skip(bc, lsb_start - i);
for (i = done = 0; i < chset->channels; i++) {
int bits = chset->scalable_lsbs[0][i];
@@ -646,7 +646,7 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
for (j = 0; j < s->xll_smpl_in_seg; j++)
sample_buf[j] = (sample_buf[j] << msb_shift) +
- (get_bits(gb, bits) << adj);
+ (bitstream_read(bc, bits) << adj);
done += bits * s->xll_smpl_in_seg;
}
@@ -733,14 +733,14 @@ int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame)
next_chset:
in_channel += chset->channels;
/* Skip to next channel set using the NAVI info. */
- i = get_bits_count(gb);
+ i = bitstream_tell(bc);
if (i > end_pos) {
av_log(s->avctx, AV_LOG_ERROR,
"chset data exceeds NAVI size\n");
return AVERROR_INVALIDDATA;
}
if (i < end_pos)
- skip_bits_long(gb, end_pos - i);
+ bitstream_skip(bc, end_pos - i);
}
}
return 0;
diff --git a/libavcodec/dcadec.c b/libavcodec/dcadec.c
index cd44323..dfa1944 100644
--- a/libavcodec/dcadec.c
+++ b/libavcodec/dcadec.c
@@ -39,6 +39,7 @@
#include "libavutil/samplefmt.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "dca.h"
#include "dca_syncwords.h"
#include "dcadata.h"
@@ -46,12 +47,12 @@
#include "dcahuff.h"
#include "fft.h"
#include "fmtconvert.h"
-#include "get_bits.h"
#include "internal.h"
#include "mathops.h"
#include "profiles.h"
#include "put_bits.h"
#include "synth_filter.h"
+#include "vlc.h"
#if ARCH_ARM
# include "arm/dca.h"
@@ -153,11 +154,11 @@ static BitAlloc dca_tmode; ///< transition
mode VLCs
static BitAlloc dca_scalefactor; ///< scalefactor VLCs
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
-static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
+static av_always_inline int get_bitalloc(BitstreamContext *bc, BitAlloc *ba,
int idx)
{
- return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
- ba->offset;
+ return bitstream_read_vlc(bc, ba->vlc[idx].table,
+ ba->vlc[idx].bits, ba->wrap) + ba->offset;
}
static av_cold void dca_init_vlcs(void)
@@ -215,10 +216,10 @@ static av_cold void dca_init_vlcs(void)
vlcs_initialized = 1;
}
-static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
+static inline void get_array(BitstreamContext *bc, int *dst, int len, int bits)
{
while (len--)
- *dst++ = get_bits(gb, bits);
+ *dst++ = bitstream_read(bc, bits);
}
static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
@@ -228,29 +229,29 @@ static int dca_parse_audio_coding_header(DCAContext *s,
int base_channel)
static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
- s->audio_header.total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
+ s->audio_header.total_channels = bitstream_read(&s->bc, 3) + 1 +
base_channel;
s->audio_header.prim_channels = s->audio_header.total_channels;
if (s->audio_header.prim_channels > DCA_PRIM_CHANNELS_MAX)
s->audio_header.prim_channels = DCA_PRIM_CHANNELS_MAX;
for (i = base_channel; i < s->audio_header.prim_channels; i++) {
- s->audio_header.subband_activity[i] = get_bits(&s->gb, 5) + 2;
+ s->audio_header.subband_activity[i] = bitstream_read(&s->bc, 5) + 2;
if (s->audio_header.subband_activity[i] > DCA_SUBBANDS)
s->audio_header.subband_activity[i] = DCA_SUBBANDS;
}
for (i = base_channel; i < s->audio_header.prim_channels; i++) {
- s->audio_header.vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
+ s->audio_header.vq_start_subband[i] = bitstream_read(&s->bc, 5) + 1;
if (s->audio_header.vq_start_subband[i] > DCA_SUBBANDS)
s->audio_header.vq_start_subband[i] = DCA_SUBBANDS;
}
- get_array(&s->gb, s->audio_header.joint_intensity + base_channel,
+ get_array(&s->bc, s->audio_header.joint_intensity + base_channel,
s->audio_header.prim_channels - base_channel, 3);
- get_array(&s->gb, s->audio_header.transient_huffman + base_channel,
+ get_array(&s->bc, s->audio_header.transient_huffman + base_channel,
s->audio_header.prim_channels - base_channel, 2);
- get_array(&s->gb, s->audio_header.scalefactor_huffman + base_channel,
+ get_array(&s->bc, s->audio_header.scalefactor_huffman + base_channel,
s->audio_header.prim_channels - base_channel, 3);
- get_array(&s->gb, s->audio_header.bitalloc_huffman + base_channel,
+ get_array(&s->bc, s->audio_header.bitalloc_huffman + base_channel,
s->audio_header.prim_channels - base_channel, 3);
/* Get codebooks quantization indexes */
@@ -258,7 +259,7 @@ static int dca_parse_audio_coding_header(DCAContext *s, int
base_channel)
memset(s->audio_header.quant_index_huffman, 0,
sizeof(s->audio_header.quant_index_huffman));
for (j = 1; j < 11; j++)
for (i = base_channel; i < s->audio_header.prim_channels; i++)
- s->audio_header.quant_index_huffman[i][j] = get_bits(&s->gb,
bitlen[j]);
+ s->audio_header.quant_index_huffman[i][j] = bitstream_read(&s->bc,
bitlen[j]);
/* Get scale factor adjustment */
for (j = 0; j < 11; j++)
@@ -268,11 +269,11 @@ static int dca_parse_audio_coding_header(DCAContext *s,
int base_channel)
for (j = 1; j < 11; j++)
for (i = base_channel; i < s->audio_header.prim_channels; i++)
if (s->audio_header.quant_index_huffman[i][j] < thr[j])
- s->audio_header.scalefactor_adj[i][j] =
adj_table[get_bits(&s->gb, 2)];
+ s->audio_header.scalefactor_adj[i][j] =
adj_table[bitstream_read(&s->bc, 2)];
if (s->crc_present) {
/* Audio header CRC check */
- get_bits(&s->gb, 16);
+ bitstream_read(&s->bc, 16);
}
s->current_subframe = 0;
@@ -283,38 +284,38 @@ static int dca_parse_audio_coding_header(DCAContext *s,
int base_channel)
static int dca_parse_frame_header(DCAContext *s)
{
- init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
+ bitstream_init8(&s->bc, s->dca_buffer, s->dca_buffer_size);
/* Sync code */
- skip_bits_long(&s->gb, 32);
+ bitstream_skip(&s->bc, 32);
/* Frame header */
- s->frame_type = get_bits(&s->gb, 1);
- s->samples_deficit = get_bits(&s->gb, 5) + 1;
- s->crc_present = get_bits(&s->gb, 1);
- s->sample_blocks = get_bits(&s->gb, 7) + 1;
- s->frame_size = get_bits(&s->gb, 14) + 1;
+ s->frame_type = bitstream_read(&s->bc, 1);
+ s->samples_deficit = bitstream_read(&s->bc, 5) + 1;
+ s->crc_present = bitstream_read(&s->bc, 1);
+ s->sample_blocks = bitstream_read(&s->bc, 7) + 1;
+ s->frame_size = bitstream_read(&s->bc, 14) + 1;
if (s->frame_size < 95)
return AVERROR_INVALIDDATA;
- s->amode = get_bits(&s->gb, 6);
- s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
+ s->amode = bitstream_read(&s->bc, 6);
+ s->sample_rate = avpriv_dca_sample_rates[bitstream_read(&s->bc, 4)];
if (!s->sample_rate)
return AVERROR_INVALIDDATA;
- s->bit_rate_index = get_bits(&s->gb, 5);
+ s->bit_rate_index = bitstream_read(&s->bc, 5);
s->bit_rate = ff_dca_bit_rates[s->bit_rate_index];
if (!s->bit_rate)
return AVERROR_INVALIDDATA;
- skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
- s->dynrange = get_bits(&s->gb, 1);
- s->timestamp = get_bits(&s->gb, 1);
- s->aux_data = get_bits(&s->gb, 1);
- s->hdcd = get_bits(&s->gb, 1);
- s->ext_descr = get_bits(&s->gb, 3);
- s->ext_coding = get_bits(&s->gb, 1);
- s->aspf = get_bits(&s->gb, 1);
- s->lfe = get_bits(&s->gb, 2);
- s->predictor_history = get_bits(&s->gb, 1);
+ bitstream_skip(&s->bc, 1); // always 0 (reserved, cf. ETSI TS 102 114
V1.4.1)
+ s->dynrange = bitstream_read(&s->bc, 1);
+ s->timestamp = bitstream_read(&s->bc, 1);
+ s->aux_data = bitstream_read(&s->bc, 1);
+ s->hdcd = bitstream_read(&s->bc, 1);
+ s->ext_descr = bitstream_read(&s->bc, 3);
+ s->ext_coding = bitstream_read(&s->bc, 1);
+ s->aspf = bitstream_read(&s->bc, 1);
+ s->lfe = bitstream_read(&s->bc, 2);
+ s->predictor_history = bitstream_read(&s->bc, 1);
if (s->lfe > 2) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
@@ -323,15 +324,15 @@ static int dca_parse_frame_header(DCAContext *s)
/* TODO: check CRC */
if (s->crc_present)
- s->header_crc = get_bits(&s->gb, 16);
+ s->header_crc = bitstream_read(&s->bc, 16);
- s->multirate_inter = get_bits(&s->gb, 1);
- s->version = get_bits(&s->gb, 4);
- s->copy_history = get_bits(&s->gb, 2);
- s->source_pcm_res = get_bits(&s->gb, 3);
- s->front_sum = get_bits(&s->gb, 1);
- s->surround_sum = get_bits(&s->gb, 1);
- s->dialog_norm = get_bits(&s->gb, 4);
+ s->multirate_inter = bitstream_read(&s->bc, 1);
+ s->version = bitstream_read(&s->bc, 4);
+ s->copy_history = bitstream_read(&s->bc, 2);
+ s->source_pcm_res = bitstream_read(&s->bc, 3);
+ s->front_sum = bitstream_read(&s->bc, 1);
+ s->surround_sum = bitstream_read(&s->bc, 1);
+ s->dialog_norm = bitstream_read(&s->bc, 4);
/* FIXME: channels mixing levels */
s->output = s->amode;
@@ -339,23 +340,23 @@ static int dca_parse_frame_header(DCAContext *s)
s->output |= DCA_LFE;
/* Primary audio coding header */
- s->audio_header.subframes = get_bits(&s->gb, 4) + 1;
+ s->audio_header.subframes = bitstream_read(&s->bc, 4) + 1;
return dca_parse_audio_coding_header(s, 0);
}
-static inline int get_scale(GetBitContext *gb, int level, int value, int
log2range)
+static inline int get_scale(BitstreamContext *bc, int level, int value, int
log2range)
{
if (level < 5) {
/* huffman encoded */
- value += get_bitalloc(gb, &dca_scalefactor, level);
+ value += get_bitalloc(bc, &dca_scalefactor, level);
value = av_clip(value, 0, (1 << log2range) - 1);
} else if (level < 8) {
if (level + 1 > log2range) {
- skip_bits(gb, level + 1 - log2range);
- value = get_bits(gb, log2range);
+ bitstream_skip(bc, level + 1 - log2range);
+ value = bitstream_read(bc, log2range);
} else {
- value = get_bits(gb, level + 1);
+ value = bitstream_read(bc, level + 1);
}
}
return value;
@@ -366,17 +367,17 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
/* Primary audio coding side information */
int j, k;
- if (get_bits_left(&s->gb) < 0)
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
if (!base_channel) {
- s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
- s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
+ s->subsubframes[s->current_subframe] = bitstream_read(&s->bc, 2) +
1;
+ s->partial_samples[s->current_subframe] = bitstream_read(&s->bc, 3);
}
for (j = base_channel; j < s->audio_header.prim_channels; j++) {
for (k = 0; k < s->audio_header.subband_activity[j]; k++)
- s->dca_chan[j].prediction_mode[k] = get_bits(&s->gb, 1);
+ s->dca_chan[j].prediction_mode[k] = bitstream_read(&s->bc, 1);
}
/* Get prediction codebook */
@@ -384,7 +385,7 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (k = 0; k < s->audio_header.subband_activity[j]; k++) {
if (s->dca_chan[j].prediction_mode[k] > 0) {
/* (Prediction coefficient VQ address) */
- s->dca_chan[j].prediction_vq[k] = get_bits(&s->gb, 12);
+ s->dca_chan[j].prediction_vq[k] = bitstream_read(&s->bc, 12);
}
}
}
@@ -393,16 +394,16 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (j = base_channel; j < s->audio_header.prim_channels; j++) {
for (k = 0; k < s->audio_header.vq_start_subband[j]; k++) {
if (s->audio_header.bitalloc_huffman[j] == 6)
- s->dca_chan[j].bitalloc[k] = get_bits(&s->gb, 5);
+ s->dca_chan[j].bitalloc[k] = bitstream_read(&s->bc, 5);
else if (s->audio_header.bitalloc_huffman[j] == 5)
- s->dca_chan[j].bitalloc[k] = get_bits(&s->gb, 4);
+ s->dca_chan[j].bitalloc[k] = bitstream_read(&s->bc, 4);
else if (s->audio_header.bitalloc_huffman[j] == 7) {
av_log(s->avctx, AV_LOG_ERROR,
"Invalid bit allocation index\n");
return AVERROR_INVALIDDATA;
} else {
s->dca_chan[j].bitalloc[k] =
- get_bitalloc(&s->gb, &dca_bitalloc_index,
s->audio_header.bitalloc_huffman[j]);
+ get_bitalloc(&s->bc, &dca_bitalloc_index,
s->audio_header.bitalloc_huffman[j]);
}
if (s->dca_chan[j].bitalloc[k] > 26) {
@@ -420,12 +421,12 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
if (s->subsubframes[s->current_subframe] > 1 &&
k < s->audio_header.vq_start_subband[j] &&
s->dca_chan[j].bitalloc[k] > 0) {
s->dca_chan[j].transition_mode[k] =
- get_bitalloc(&s->gb, &dca_tmode,
s->audio_header.transient_huffman[j]);
+ get_bitalloc(&s->bc, &dca_tmode,
s->audio_header.transient_huffman[j]);
}
}
}
- if (get_bits_left(&s->gb) < 0)
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
for (j = base_channel; j < s->audio_header.prim_channels; j++) {
@@ -448,13 +449,13 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (k = 0; k < s->audio_header.subband_activity[j]; k++) {
if (k >= s->audio_header.vq_start_subband[j] ||
s->dca_chan[j].bitalloc[k] > 0) {
- scale_sum = get_scale(&s->gb,
s->audio_header.scalefactor_huffman[j], scale_sum, log_size);
+ scale_sum = get_scale(&s->bc,
s->audio_header.scalefactor_huffman[j], scale_sum, log_size);
s->dca_chan[j].scale_factor[k][0] = scale_table[scale_sum];
}
if (k < s->audio_header.vq_start_subband[j] &&
s->dca_chan[j].transition_mode[k]) {
/* Get second scale factor */
- scale_sum = get_scale(&s->gb,
s->audio_header.scalefactor_huffman[j], scale_sum, log_size);
+ scale_sum = get_scale(&s->bc,
s->audio_header.scalefactor_huffman[j], scale_sum, log_size);
s->dca_chan[j].scale_factor[k][1] = scale_table[scale_sum];
}
}
@@ -464,10 +465,10 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (j = base_channel; j < s->audio_header.prim_channels; j++) {
/* Transmitted only if joint subband coding enabled */
if (s->audio_header.joint_intensity[j] > 0)
- s->dca_chan[j].joint_huff = get_bits(&s->gb, 3);
+ s->dca_chan[j].joint_huff = bitstream_read(&s->bc, 3);
}
- if (get_bits_left(&s->gb) < 0)
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
/* Scale factors for joint subband coding */
@@ -484,7 +485,7 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (k = s->audio_header.subband_activity[j];
k < s->audio_header.subband_activity[source_channel]; k++) {
- scale = get_scale(&s->gb, s->dca_chan[j].joint_huff, 64 /*
bias */, 7);
+ scale = get_scale(&s->bc, s->dca_chan[j].joint_huff, 64 /*
bias */, 7);
s->dca_chan[j].joint_scale_factor[k] = scale;
/*joint_scale_table[scale]; */
}
@@ -498,11 +499,11 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
/* Dynamic range coefficient */
if (!base_channel && s->dynrange)
- s->dynrange_coef = get_bits(&s->gb, 8);
+ s->dynrange_coef = bitstream_read(&s->bc, 8);
/* Side information CRC check word */
if (s->crc_present) {
- get_bits(&s->gb, 16);
+ bitstream_read(&s->bc, 16);
}
/*
@@ -513,7 +514,7 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (j = base_channel; j < s->audio_header.prim_channels; j++)
for (k = s->audio_header.vq_start_subband[j]; k <
s->audio_header.subband_activity[j]; k++)
/* 1 vector -> 32 samples */
- s->dca_chan[j].high_freq_vq[k] = get_bits(&s->gb, 10);
+ s->dca_chan[j].high_freq_vq[k] = bitstream_read(&s->bc, 10);
/* Low frequency effect data */
if (!base_channel && s->lfe) {
@@ -524,12 +525,12 @@ static int dca_subframe_header(DCAContext *s, int
base_channel, int block_index)
for (j = lfe_samples; j < lfe_end_sample; j++) {
/* Signed 8 bits int */
- s->lfe_data[j] = get_sbits(&s->gb, 8);
+ s->lfe_data[j] = bitstream_read_signed(&s->bc, 8);
}
/* Scale factor index */
- skip_bits(&s->gb, 1);
- s->lfe_scale_factor = ff_dca_scale_factor_quant7[get_bits(&s->gb, 7)];
+ bitstream_skip(&s->bc, 1);
+ s->lfe_scale_factor =
ff_dca_scale_factor_quant7[bitstream_read(&s->bc, 7)];
/* Quantization step size * scale factor */
lfe_scale = 0.035 * s->lfe_scale_factor;
@@ -804,7 +805,7 @@ static int dca_subsubframe(DCAContext *s, int base_channel,
int block_index)
for (k = base_channel; k < s->audio_header.prim_channels; k++) {
int32_t (*subband_samples)[8] =
s->dca_chan[k].subband_samples[block_index];
- if (get_bits_left(&s->gb) < 0)
+ if (bitstream_bits_left(&s->bc) < 0)
return AVERROR_INVALIDDATA;
for (l = 0; l < s->audio_header.vq_start_subband[k]; l++) {
@@ -841,8 +842,8 @@ static int dca_subsubframe(DCAContext *s, int base_channel,
int block_index)
size = abits_sizes[abits - 1];
levels = abits_levels[abits - 1];
- block_code1 = get_bits(&s->gb, size);
- block_code2 = get_bits(&s->gb, size);
+ block_code1 = bitstream_read(&s->bc, size);
+ block_code2 = bitstream_read(&s->bc, size);
err = decode_blockcodes(block_code1,
block_code2,
levels,
subband_samples[l]);
if (err) {
@@ -853,12 +854,12 @@ static int dca_subsubframe(DCAContext *s, int
base_channel, int block_index)
} else {
/* no coding */
for (m = 0; m < SAMPLES_PER_SUBBAND; m++)
- subband_samples[l][m] = get_sbits(&s->gb, abits -
3);
+ subband_samples[l][m] =
bitstream_read_signed(&s->bc, abits - 3);
}
} else {
/* Huffman coded */
for (m = 0; m < SAMPLES_PER_SUBBAND; m++)
- subband_samples[l][m] = get_bitalloc(&s->gb,
+ subband_samples[l][m] = get_bitalloc(&s->bc,
&dca_smpl_bitalloc[abits], sel);
}
s->dcadsp.dequantize(subband_samples[l], quant_step_size,
rscale);
@@ -923,7 +924,7 @@ static int dca_subsubframe(DCAContext *s, int base_channel,
int block_index)
/* Check for DSYNC after subsubframe */
if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
- if (get_bits(&s->gb, 16) != 0xFFFF) {
+ if (bitstream_read(&s->bc, 16) != 0xFFFF) {
av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
return AVERROR_INVALIDDATA;
}
@@ -1019,33 +1020,33 @@ static int dca_subframe_footer(DCAContext *s, int
base_channel)
/* presumably optional information only appears in the core? */
if (!base_channel) {
if (s->timestamp)
- skip_bits_long(&s->gb, 32);
+ bitstream_skip(&s->bc, 32);
if (s->aux_data) {
- aux_data_count = get_bits(&s->gb, 6);
+ aux_data_count = bitstream_read(&s->bc, 6);
// align (32-bit)
- skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
+ bitstream_skip(&s->bc, (-bitstream_tell(&s->bc)) & 31);
- aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
+ aux_data_end = 8 * aux_data_count + bitstream_tell(&s->bc);
- if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
+ if ((nsyncaux = bitstream_read(&s->bc, 32)) != DCA_NSYNCAUX) {
av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch
%#"PRIx32"\n",
nsyncaux);
return AVERROR_INVALIDDATA;
}
- if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
+ if (bitstream_read_bit(&s->bc)) { // bAUXTimeStampFlag
avpriv_request_sample(s->avctx,
"Auxiliary Decode Time Stamp Flag");
// align (4-bit)
- skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
+ bitstream_skip(&s->bc, (-bitstream_tell(&s->bc)) & 4);
// 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
- skip_bits_long(&s->gb, 44);
+ bitstream_skip(&s->bc, 44);
}
- if ((s->core_downmix = get_bits1(&s->gb))) {
- int am = get_bits(&s->gb, 3);
+ if ((s->core_downmix = bitstream_read_bit(&s->bc))) {
+ int am = bitstream_read(&s->bc, 3);
switch (am) {
case 0:
s->core_downmix_amode = DCA_MONO;
@@ -1076,7 +1077,7 @@ static int dca_subframe_footer(DCAContext *s, int
base_channel)
}
for (out = 0; out < ff_dca_channels[s->core_downmix_amode];
out++) {
for (in = 0; in < s->audio_header.prim_channels +
!!s->lfe; in++) {
- uint16_t tmp = get_bits(&s->gb, 9);
+ uint16_t tmp = bitstream_read(&s->bc, 9);
if ((tmp & 0xFF) > 241) {
av_log(s->avctx, AV_LOG_ERROR,
"Invalid downmix coefficient code
%"PRIu16"\n",
@@ -1088,23 +1089,23 @@ static int dca_subframe_footer(DCAContext *s, int
base_channel)
}
}
- align_get_bits(&s->gb); // byte align
- skip_bits(&s->gb, 16); // nAUXCRC16
+ bitstream_align(&s->bc); // byte align
+ bitstream_skip(&s->bc, 16); // nAUXCRC16
/*
* additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
*
* Note: don't check for overreads, aux_data_count can't be
trusted.
*/
- if ((reserved = (aux_data_end - get_bits_count(&s->gb))) > 0) {
+ if ((reserved = (aux_data_end - bitstream_tell(&s->bc))) > 0) {
avpriv_request_sample(s->avctx,
"Core auxiliary data reserved content");
- skip_bits_long(&s->gb, reserved);
+ bitstream_skip(&s->bc, reserved);
}
}
if (s->crc_present && s->dynrange)
- get_bits(&s->gb, 16);
+ bitstream_read(&s->bc, 16);
}
return 0;
@@ -1174,10 +1175,10 @@ static int scan_for_extensions(AVCodecContext *avctx)
s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
/* extensions start at 32-bit boundaries into bitstream */
- skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
+ bitstream_skip(&s->bc, (-bitstream_tell(&s->bc)) & 31);
- while (core_ss_end - get_bits_count(&s->gb) >= 32) {
- uint32_t bits = get_bits_long(&s->gb, 32);
+ while (core_ss_end - bitstream_tell(&s->bc) >= 32) {
+ uint32_t bits = bitstream_read(&s->bc, 32);
int i;
switch (bits) {
@@ -1187,19 +1188,19 @@ static int scan_for_extensions(AVCodecContext *avctx)
s->xch_base_channel = s->audio_header.prim_channels;
/* validate sync word using XCHFSIZE field */
- xch_fsize = show_bits(&s->gb, 10);
- if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 +
xch_fsize) &&
- (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 +
xch_fsize + 1))
+ xch_fsize = bitstream_peek(&s->bc, 10);
+ if ((s->frame_size != (bitstream_tell(&s->bc) >> 3) - 4 +
xch_fsize) &&
+ (s->frame_size != (bitstream_tell(&s->bc) >> 3) - 4 +
xch_fsize + 1))
continue;
/* skip length-to-end-of-frame field for the moment */
- skip_bits(&s->gb, 10);
+ bitstream_skip(&s->bc, 10);
s->core_ext_mask |= DCA_EXT_XCH;
/* extension amode(number of channels in extension) should be
1 */
/* AFAIK XCh is not used for more channels */
- if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
+ if ((ext_amode = bitstream_read(&s->bc, 4)) != 1) {
av_log(avctx, AV_LOG_ERROR,
"XCh extension amode %d not supported!\n",
ext_amode);
@@ -1226,26 +1227,26 @@ static int scan_for_extensions(AVCodecContext *avctx)
break;
case 0x1d95f262: {
- int fsize96 = show_bits(&s->gb, 12) + 1;
- if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 +
fsize96)
+ int fsize96 = bitstream_peek(&s->bc, 12) + 1;
+ if (s->frame_size != (bitstream_tell(&s->bc) >> 3) - 4 +
fsize96)
continue;
av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
- get_bits_count(&s->gb));
- skip_bits(&s->gb, 12);
+ bitstream_tell(&s->bc));
+ bitstream_skip(&s->bc, 12);
av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
- av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb,
4));
+ av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n",
bitstream_read(&s->bc, 4));
s->core_ext_mask |= DCA_EXT_X96;
break;
}
}
- skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
+ bitstream_skip(&s->bc, (-bitstream_tell(&s->bc)) & 31);
}
} else {
/* no supported extensions, skip the rest of the core substream */
- skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
+ bitstream_skip(&s->bc, core_ss_end - bitstream_tell(&s->bc));
}
if (s->core_ext_mask & DCA_EXT_X96)
@@ -1255,7 +1256,7 @@ static int scan_for_extensions(AVCodecContext *avctx)
/* check for ExSS (HD part) */
if (s->dca_buffer_size - s->frame_size > 32 &&
- get_bits_long(&s->gb, 32) == DCA_SYNCWORD_SUBSTREAM)
+ bitstream_read(&s->bc, 32) == DCA_SYNCWORD_SUBSTREAM)
ff_dca_exss_parse_header(s);
return ret;
--
2.7.3
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
