From: Alexandra Hájková <alexan...@khirnov.net>
---
libavcodec/vorbis_parser.c | 32 +++---
libavcodec/vorbisdec.c | 237 +++++++++++++++++++++++----------------------
2 files changed, 135 insertions(+), 134 deletions(-)
diff --git a/libavcodec/vorbis_parser.c b/libavcodec/vorbis_parser.c
index 054635d..881afd1 100644
--- a/libavcodec/vorbis_parser.c
+++ b/libavcodec/vorbis_parser.c
@@ -27,7 +27,7 @@
#include "libavutil/log.h"
-#include "get_bits.h"
+#include "bitstream.h"
#include "parser.h"
#include "xiph.h"
#include "vorbis_parser_internal.h"
@@ -73,7 +73,7 @@ static int parse_id_header(AVVorbisParseContext *s,
static int parse_setup_header(AVVorbisParseContext *s,
const uint8_t *buf, int buf_size)
{
- GetBitContext gb, gb0;
+ BitstreamContext bc, bc0;
uint8_t *rev_buf;
int i, ret = 0;
int got_framing_bit, mode_count, got_mode_header, last_mode_count = 0;
@@ -96,19 +96,19 @@ static int parse_setup_header(AVVorbisParseContext *s,
return AVERROR_INVALIDDATA;
}
- /* reverse bytes so we can easily read backwards with get_bits() */
+ /* reverse bytes so we can easily read backwards with bitstream_read() */
if (!(rev_buf = av_malloc(buf_size))) {
av_log(s, AV_LOG_ERROR, "Out of memory\n");
return AVERROR(ENOMEM);
}
for (i = 0; i < buf_size; i++)
rev_buf[i] = buf[buf_size - 1 - i];
- init_get_bits(&gb, rev_buf, buf_size * 8);
+ bitstream_init(&bc, rev_buf, buf_size * 8);
got_framing_bit = 0;
- while (get_bits_left(&gb) > 97) {
- if (get_bits1(&gb)) {
- got_framing_bit = get_bits_count(&gb);
+ while (bitstream_bits_left(&bc) > 97) {
+ if (bitstream_read_bit(&bc)) {
+ got_framing_bit = bitstream_tell(&bc);
break;
}
}
@@ -126,15 +126,15 @@ static int parse_setup_header(AVVorbisParseContext *s,
* liboggz. */
mode_count = 0;
got_mode_header = 0;
- while (get_bits_left(&gb) >= 97) {
- if (get_bits(&gb, 8) > 63 || get_bits(&gb, 16) || get_bits(&gb, 16))
+ while (bitstream_bits_left(&bc) >= 97) {
+ if (bitstream_read(&bc, 8) > 63 || bitstream_read(&bc, 16) ||
bitstream_read(&bc, 16))
break;
- skip_bits(&gb, 1);
+ bitstream_skip(&bc, 1);
mode_count++;
if (mode_count > 64)
break;
- gb0 = gb;
- if (get_bits(&gb0, 6) + 1 == mode_count) {
+ bc0 = bc;
+ if (bitstream_read(&bc0, 6) + 1 == mode_count) {
got_mode_header = 1;
last_mode_count = mode_count;
}
@@ -169,11 +169,11 @@ static int parse_setup_header(AVVorbisParseContext *s,
/* The previous window flag is the next bit after the mode */
s->prev_mask = (s->mode_mask | 0x1) + 1;
- init_get_bits(&gb, rev_buf, buf_size * 8);
- skip_bits_long(&gb, got_framing_bit);
+ bitstream_init(&bc, rev_buf, buf_size * 8);
+ bitstream_skip(&bc, got_framing_bit);
for (i = mode_count - 1; i >= 0; i--) {
- skip_bits_long(&gb, 40);
- s->mode_blocksize[i] = s->blocksize[get_bits1(&gb)];
+ bitstream_skip(&bc, 40);
+ s->mode_blocksize[i] = s->blocksize[bitstream_read_bit(&bc)];
}
bad_header:
diff --git a/libavcodec/vorbisdec.c b/libavcodec/vorbisdec.c
index 8b800fd..3fff3fc 100644
--- a/libavcodec/vorbisdec.c
+++ b/libavcodec/vorbisdec.c
@@ -29,8 +29,8 @@
#define BITSTREAM_READER_LE
#include "avcodec.h"
+#include "bitstream.h"
#include "fft.h"
-#include "get_bits.h"
#include "internal.h"
#include "vorbis.h"
#include "vorbisdsp.h"
@@ -119,7 +119,7 @@ typedef struct vorbis_mode {
typedef struct vorbis_context_s {
AVCodecContext *avctx;
- GetBitContext gb;
+ BitstreamContext bc;
VorbisDSPContext dsp;
AVFloatDSPContext fdsp;
@@ -164,7 +164,7 @@ static const char idx_err_str[] = "Index value %d out of
range (0 - %d) for %s a
}
#define GET_VALIDATED_INDEX(idx, bits, limit) \
{\
- idx = get_bits(gb, bits);\
+ idx = bitstream_read(bc, bits);\
VALIDATE_INDEX(idx, limit)\
}
@@ -230,11 +230,11 @@ static int
vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
unsigned cb;
uint8_t *tmp_vlc_bits = NULL;
uint32_t *tmp_vlc_codes = NULL;
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
uint16_t *codebook_multiplicands = NULL;
int ret = 0;
- vc->codebook_count = get_bits(gb, 8) + 1;
+ vc->codebook_count = bitstream_read(bc, 8) + 1;
ff_dlog(NULL, " Codebooks: %d \n", vc->codebook_count);
@@ -254,14 +254,14 @@ static int
vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
ff_dlog(NULL, " %u. Codebook\n", cb);
- if (get_bits(gb, 24) != 0x564342) {
+ if (bitstream_read(bc, 24) != 0x564342) {
av_log(vc->avctx, AV_LOG_ERROR,
" %u. Codebook setup data corrupt.\n", cb);
ret = AVERROR_INVALIDDATA;
goto error;
}
- codebook_setup->dimensions=get_bits(gb, 16);
+ codebook_setup->dimensions = bitstream_read(bc, 16);
if (codebook_setup->dimensions > 16 || codebook_setup->dimensions ==
0) {
av_log(vc->avctx, AV_LOG_ERROR,
" %u. Codebook's dimension is invalid (%d).\n",
@@ -269,7 +269,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc)
ret = AVERROR_INVALIDDATA;
goto error;
}
- entries = get_bits(gb, 24);
+ entries = bitstream_read(bc, 24);
if (entries > V_MAX_VLCS) {
av_log(vc->avctx, AV_LOG_ERROR,
" %u. Codebook has too many entries (%u).\n",
@@ -278,14 +278,14 @@ static int
vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
goto error;
}
- ordered = get_bits1(gb);
+ ordered = bitstream_read_bit(bc);
ff_dlog(NULL, " codebook_dimensions %d, codebook_entries %u\n",
codebook_setup->dimensions, entries);
if (!ordered) {
unsigned ce, flag;
- unsigned sparse = get_bits1(gb);
+ unsigned sparse = bitstream_read_bit(bc);
ff_dlog(NULL, " not ordered \n");
@@ -294,9 +294,9 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc)
used_entries = 0;
for (ce = 0; ce < entries; ++ce) {
- flag = get_bits1(gb);
+ flag = bitstream_read_bit(bc);
if (flag) {
- tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
+ tmp_vlc_bits[ce] = bitstream_read(bc, 5) + 1;
++used_entries;
} else
tmp_vlc_bits[ce] = 0;
@@ -306,11 +306,11 @@ static int
vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
used_entries = entries;
for (ce = 0; ce < entries; ++ce)
- tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
+ tmp_vlc_bits[ce] = bitstream_read(bc, 5) + 1;
}
} else {
unsigned current_entry = 0;
- unsigned current_length = get_bits(gb, 5) + 1;
+ unsigned current_length = bitstream_read(bc, 5) + 1;
ff_dlog(NULL, " ordered, current length: %u\n", current_length);
//FIXME
@@ -320,7 +320,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc)
ff_dlog(NULL, " number bits: %u ", ilog(entries -
current_entry));
- number = get_bits(gb, ilog(entries - current_entry));
+ number = bitstream_read(bc, ilog(entries - current_entry));
ff_dlog(NULL, " number: %u\n", number);
@@ -337,7 +337,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc)
}
}
- codebook_setup->lookup_type = get_bits(gb, 4);
+ codebook_setup->lookup_type = bitstream_read(bc, 4);
ff_dlog(NULL, " lookup type: %d : %s \n", codebook_setup->lookup_type,
codebook_setup->lookup_type ? "vq" : "no lookup");
@@ -348,10 +348,10 @@ static int
vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
unsigned i, j, k;
unsigned codebook_lookup_values = ff_vorbis_nth_root(entries,
codebook_setup->dimensions);
- float codebook_minimum_value = vorbisfloat2float(get_bits_long(gb,
32));
- float codebook_delta_value = vorbisfloat2float(get_bits_long(gb,
32));
- unsigned codebook_value_bits = get_bits(gb, 4) + 1;
- unsigned codebook_sequence_p = get_bits1(gb);
+ float codebook_minimum_value =
vorbisfloat2float(bitstream_read(bc, 32));
+ float codebook_delta_value =
vorbisfloat2float(bitstream_read(bc, 32));
+ unsigned codebook_value_bits = bitstream_read(bc, 4) + 1;
+ unsigned codebook_sequence_p = bitstream_read_bit(bc);
ff_dlog(NULL, " We expect %d numbers for building the codevectors.
\n",
codebook_lookup_values);
@@ -359,7 +359,7 @@ static int vorbis_parse_setup_hdr_codebooks(vorbis_context
*vc)
codebook_delta_value, codebook_minimum_value);
for (i = 0; i < codebook_lookup_values; ++i) {
- codebook_multiplicands[i] = get_bits(gb, codebook_value_bits);
+ codebook_multiplicands[i] = bitstream_read(bc,
codebook_value_bits);
ff_dlog(NULL, " multiplicands*delta+minmum : %e \n",
(float)codebook_multiplicands[i] *
codebook_delta_value + codebook_minimum_value);
@@ -460,11 +460,11 @@ error:
static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
- unsigned i, vorbis_time_count = get_bits(gb, 6) + 1;
+ BitstreamContext *bc = &vc->bc;
+ unsigned i, vorbis_time_count = bitstream_read(bc, 6) + 1;
for (i = 0; i < vorbis_time_count; ++i) {
- unsigned vorbis_tdtransform = get_bits(gb, 16);
+ unsigned vorbis_tdtransform = bitstream_read(bc, 16);
ff_dlog(NULL, " Vorbis time domain transform %u: %u\n",
vorbis_time_count, vorbis_tdtransform);
@@ -486,10 +486,10 @@ static int vorbis_floor1_decode(vorbis_context *vc,
vorbis_floor_data *vfu, float *vec);
static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
int i, j, k, ret;
- vc->floor_count = get_bits(gb, 6) + 1;
+ vc->floor_count = bitstream_read(bc, 6) + 1;
vc->floors = av_mallocz(vc->floor_count * sizeof(*vc->floors));
if (!vc->floors)
@@ -498,7 +498,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
for (i = 0; i < vc->floor_count; ++i) {
vorbis_floor *floor_setup = &vc->floors[i];
- floor_setup->floor_type = get_bits(gb, 16);
+ floor_setup->floor_type = bitstream_read(bc, 16);
ff_dlog(NULL, " %d. floor type %d \n", i, floor_setup->floor_type);
@@ -508,13 +508,13 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc)
floor_setup->decode = vorbis_floor1_decode;
- floor_setup->data.t1.partitions = get_bits(gb, 5);
+ floor_setup->data.t1.partitions = bitstream_read(bc, 5);
ff_dlog(NULL, " %d.floor: %d partitions \n",
i, floor_setup->data.t1.partitions);
for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
- floor_setup->data.t1.partition_class[j] = get_bits(gb, 4);
+ floor_setup->data.t1.partition_class[j] = bitstream_read(bc,
4);
if (floor_setup->data.t1.partition_class[j] > maximum_class)
maximum_class = floor_setup->data.t1.partition_class[j];
@@ -526,8 +526,8 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
ff_dlog(NULL, " maximum class %d \n", maximum_class);
for (j = 0; j <= maximum_class; ++j) {
- floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1;
- floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2);
+ floor_setup->data.t1.class_dimensions[j] = bitstream_read(bc,
3) + 1;
+ floor_setup->data.t1.class_subclasses[j] = bitstream_read(bc,
2);
ff_dlog(NULL, " %d floor %d class dim: %d subclasses %d \n",
i, j,
floor_setup->data.t1.class_dimensions[j],
@@ -540,7 +540,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
}
for (k = 0; k < (1 <<
floor_setup->data.t1.class_subclasses[j]); ++k) {
- int16_t bits = get_bits(gb, 8) - 1;
+ int16_t bits = bitstream_read(bc, 8) - 1;
if (bits != -1)
VALIDATE_INDEX(bits, vc->codebook_count)
floor_setup->data.t1.subclass_books[j][k] = bits;
@@ -549,7 +549,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
}
}
- floor_setup->data.t1.multiplier = get_bits(gb, 2) + 1;
+ floor_setup->data.t1.multiplier = bitstream_read(bc, 2) + 1;
floor_setup->data.t1.x_list_dim = 2;
for (j = 0; j < floor_setup->data.t1.partitions; ++j)
@@ -560,7 +560,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
if (!floor_setup->data.t1.list)
return AVERROR(ENOMEM);
- rangebits = get_bits(gb, 4);
+ rangebits = bitstream_read(bc, 4);
rangemax = (1 << rangebits);
if (rangemax > vc->blocksize[1] / 2) {
av_log(vc->avctx, AV_LOG_ERROR,
@@ -573,7 +573,7 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
for (k = 0; k <
floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];
++k, ++floor1_values) {
- floor_setup->data.t1.list[floor1_values].x = get_bits(gb,
rangebits);
+ floor_setup->data.t1.list[floor1_values].x =
bitstream_read(bc, rangebits);
ff_dlog(NULL, " %u. floor1 Y coord. %d\n", floor1_values,
floor_setup->data.t1.list[floor1_values].x);
@@ -591,25 +591,25 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc)
floor_setup->decode = vorbis_floor0_decode;
- floor_setup->data.t0.order = get_bits(gb, 8);
+ floor_setup->data.t0.order = bitstream_read(bc, 8);
if (!floor_setup->data.t0.order) {
av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 order is 0.\n");
return AVERROR_INVALIDDATA;
}
- floor_setup->data.t0.rate = get_bits(gb, 16);
+ floor_setup->data.t0.rate = bitstream_read(bc, 16);
if (!floor_setup->data.t0.rate) {
av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 rate is 0.\n");
return AVERROR_INVALIDDATA;
}
- floor_setup->data.t0.bark_map_size = get_bits(gb, 16);
+ floor_setup->data.t0.bark_map_size = bitstream_read(bc, 16);
if (!floor_setup->data.t0.bark_map_size) {
av_log(vc->avctx, AV_LOG_ERROR,
"Floor 0 bark map size is 0.\n");
return AVERROR_INVALIDDATA;
}
- floor_setup->data.t0.amplitude_bits = get_bits(gb, 6);
- floor_setup->data.t0.amplitude_offset = get_bits(gb, 8);
- floor_setup->data.t0.num_books = get_bits(gb, 4) + 1;
+ floor_setup->data.t0.amplitude_bits = bitstream_read(bc, 6);
+ floor_setup->data.t0.amplitude_offset = bitstream_read(bc, 8);
+ floor_setup->data.t0.num_books = bitstream_read(bc, 4) + 1;
/* allocate mem for booklist */
floor_setup->data.t0.book_list =
@@ -671,10 +671,10 @@ static int vorbis_parse_setup_hdr_floors(vorbis_context
*vc)
static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
unsigned i, j, k;
- vc->residue_count = get_bits(gb, 6)+1;
+ vc->residue_count = bitstream_read(bc, 6) + 1;
vc->residues = av_mallocz(vc->residue_count * sizeof(*vc->residues));
if (!vc->residues)
return AVERROR(ENOMEM);
@@ -686,13 +686,13 @@ static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc)
uint8_t cascade[64];
unsigned high_bits, low_bits;
- res_setup->type = get_bits(gb, 16);
+ res_setup->type = bitstream_read(bc, 16);
ff_dlog(NULL, " %u. residue type %d\n", i, res_setup->type);
- res_setup->begin = get_bits(gb, 24);
- res_setup->end = get_bits(gb, 24);
- res_setup->partition_size = get_bits(gb, 24) + 1;
+ res_setup->begin = bitstream_read(bc, 24);
+ res_setup->end = bitstream_read(bc, 24);
+ res_setup->partition_size = bitstream_read(bc, 24) + 1;
/* Validations to prevent a buffer overflow later. */
if (res_setup->begin>res_setup->end ||
res_setup->end > (res_setup->type == 2 ? vc->avctx->channels : 1)
* vc->blocksize[1] / 2 ||
@@ -704,7 +704,7 @@ static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc)
return AVERROR_INVALIDDATA;
}
- res_setup->classifications = get_bits(gb, 6) + 1;
+ res_setup->classifications = bitstream_read(bc, 6) + 1;
GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count)
res_setup->ptns_to_read =
@@ -721,9 +721,9 @@ static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc)
for (j = 0; j < res_setup->classifications; ++j) {
high_bits = 0;
- low_bits = get_bits(gb, 3);
- if (get_bits1(gb))
- high_bits = get_bits(gb, 5);
+ low_bits = bitstream_read(bc, 3);
+ if (bitstream_read_bit(bc))
+ high_bits = bitstream_read(bc, 5);
cascade[j] = (high_bits << 3) + low_bits;
ff_dlog(NULL, " %u class cascade depth: %d\n", j,
ilog(cascade[j]));
@@ -753,10 +753,10 @@ static int vorbis_parse_setup_hdr_residues(vorbis_context
*vc)
static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
unsigned i, j;
- vc->mapping_count = get_bits(gb, 6)+1;
+ vc->mapping_count = bitstream_read(bc, 6) + 1;
vc->mappings = av_mallocz(vc->mapping_count * sizeof(*vc->mappings));
if (!vc->mappings)
return AVERROR(ENOMEM);
@@ -766,18 +766,18 @@ static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc)
for (i = 0; i < vc->mapping_count; ++i) {
vorbis_mapping *mapping_setup = &vc->mappings[i];
- if (get_bits(gb, 16)) {
+ if (bitstream_read(bc, 16)) {
av_log(vc->avctx, AV_LOG_ERROR, "Other mappings than type 0 are
not compliant with the Vorbis I specification. \n");
return AVERROR_INVALIDDATA;
}
- if (get_bits1(gb)) {
- mapping_setup->submaps = get_bits(gb, 4) + 1;
+ if (bitstream_read_bit(bc)) {
+ mapping_setup->submaps = bitstream_read(bc, 4) + 1;
} else {
mapping_setup->submaps = 1;
}
- if (get_bits1(gb)) {
- mapping_setup->coupling_steps = get_bits(gb, 8) + 1;
+ if (bitstream_read_bit(bc)) {
+ mapping_setup->coupling_steps = bitstream_read(bc, 8) + 1;
mapping_setup->magnitude =
av_mallocz(mapping_setup->coupling_steps *
sizeof(*mapping_setup->magnitude));
mapping_setup->angle =
av_mallocz(mapping_setup->coupling_steps *
@@ -796,7 +796,7 @@ static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc)
ff_dlog(NULL, " %u mapping coupling steps: %d\n",
i, mapping_setup->coupling_steps);
- if (get_bits(gb, 2)) {
+ if (bitstream_read(bc, 2)) {
av_log(vc->avctx, AV_LOG_ERROR, "%u. mapping setup data
invalid.\n", i);
return AVERROR_INVALIDDATA; // following spec.
}
@@ -808,11 +808,11 @@ static int vorbis_parse_setup_hdr_mappings(vorbis_context
*vc)
return AVERROR(ENOMEM);
for (j = 0; j < vc->audio_channels; ++j)
- mapping_setup->mux[j] = get_bits(gb, 4);
+ mapping_setup->mux[j] = bitstream_read(bc, 4);
}
for (j = 0; j < mapping_setup->submaps; ++j) {
- skip_bits(gb, 8); // FIXME check?
+ bitstream_skip(bc, 8); // FIXME check?
GET_VALIDATED_INDEX(mapping_setup->submap_floor[j], 8,
vc->floor_count)
GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8,
vc->residue_count)
@@ -863,10 +863,10 @@ static int create_map(vorbis_context *vc, unsigned
floor_number)
static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
unsigned i;
- vc->mode_count = get_bits(gb, 6) + 1;
+ vc->mode_count = bitstream_read(bc, 6) + 1;
vc->modes = av_mallocz(vc->mode_count * sizeof(*vc->modes));
if (!vc->modes)
return AVERROR(ENOMEM);
@@ -876,9 +876,9 @@ static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
for (i = 0; i < vc->mode_count; ++i) {
vorbis_mode *mode_setup = &vc->modes[i];
- mode_setup->blockflag = get_bits1(gb);
- mode_setup->windowtype = get_bits(gb, 16); //FIXME check
- mode_setup->transformtype = get_bits(gb, 16); //FIXME check
+ mode_setup->blockflag = bitstream_read_bit(bc);
+ mode_setup->windowtype = bitstream_read(bc, 16); // FIXME check
+ mode_setup->transformtype = bitstream_read(bc, 16); // FIXME check
GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);
ff_dlog(NULL, " %u mode: blockflag %d, windowtype %d, transformtype
%d, mapping %d\n",
@@ -892,12 +892,12 @@ static int vorbis_parse_setup_hdr_modes(vorbis_context
*vc)
static int vorbis_parse_setup_hdr(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
int ret;
- if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
- (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
- (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
+ if ((bitstream_read(bc, 8) != 'v') || (bitstream_read(bc, 8) != 'o') ||
+ (bitstream_read(bc, 8) != 'r') || (bitstream_read(bc, 8) != 'b') ||
+ (bitstream_read(bc, 8) != 'i') || (bitstream_read(bc, 8) != 's')) {
av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt
(no vorbis signature). \n");
return AVERROR_INVALIDDATA;
}
@@ -926,7 +926,7 @@ static int vorbis_parse_setup_hdr(vorbis_context *vc)
av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt
(modes). \n");
return ret;
}
- if (!get_bits1(gb)) {
+ if (!bitstream_read_bit(bc)) {
av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt
(framing flag). \n");
return AVERROR_INVALIDDATA; // framing flag bit unset error
}
@@ -938,32 +938,32 @@ static int vorbis_parse_setup_hdr(vorbis_context *vc)
static int vorbis_parse_id_hdr(vorbis_context *vc)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
unsigned bl0, bl1;
- if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
- (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
- (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
+ if ((bitstream_read(bc, 8) != 'v') || (bitstream_read(bc, 8) != 'o') ||
+ (bitstream_read(bc, 8) != 'r') || (bitstream_read(bc, 8) != 'b') ||
+ (bitstream_read(bc, 8) != 'i') || (bitstream_read(bc, 8) != 's')) {
av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (no
vorbis signature). \n");
return AVERROR_INVALIDDATA;
}
- vc->version = get_bits_long(gb, 32); //FIXME check 0
- vc->audio_channels = get_bits(gb, 8);
+ vc->version = bitstream_read(bc, 32); // FIXME check 0
+ vc->audio_channels = bitstream_read(bc, 8);
if (vc->audio_channels <= 0) {
av_log(vc->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
return AVERROR_INVALIDDATA;
}
- vc->audio_samplerate = get_bits_long(gb, 32);
+ vc->audio_samplerate = bitstream_read(bc, 32);
if (vc->audio_samplerate <= 0) {
av_log(vc->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
return AVERROR_INVALIDDATA;
}
- vc->bitrate_maximum = get_bits_long(gb, 32);
- vc->bitrate_nominal = get_bits_long(gb, 32);
- vc->bitrate_minimum = get_bits_long(gb, 32);
- bl0 = get_bits(gb, 4);
- bl1 = get_bits(gb, 4);
+ vc->bitrate_maximum = bitstream_read(bc, 32);
+ vc->bitrate_nominal = bitstream_read(bc, 32);
+ vc->bitrate_minimum = bitstream_read(bc, 32);
+ bl0 = bitstream_read(bc, 4);
+ bl1 = bitstream_read(bc, 4);
vc->blocksize[0] = (1 << bl0);
vc->blocksize[1] = (1 << bl1);
if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
@@ -973,7 +973,7 @@ static int vorbis_parse_id_hdr(vorbis_context *vc)
vc->win[0] = ff_vorbis_vwin[bl0 - 6];
vc->win[1] = ff_vorbis_vwin[bl1 - 6];
- if ((get_bits1(gb)) == 0) {
+ if ((bitstream_read_bit(bc)) == 0) {
av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt
(framing flag not set). \n");
return AVERROR_INVALIDDATA;
}
@@ -1010,7 +1010,7 @@ static av_cold int vorbis_decode_init(AVCodecContext
*avctx)
int headers_len = avctx->extradata_size;
uint8_t *header_start[3];
int header_len[3];
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
int hdr_type, ret;
vc->avctx = avctx;
@@ -1029,8 +1029,8 @@ static av_cold int vorbis_decode_init(AVCodecContext
*avctx)
return ret;
}
- init_get_bits(gb, header_start[0], header_len[0]*8);
- hdr_type = get_bits(gb, 8);
+ bitstream_init(bc, header_start[0], header_len[0] * 8);
+ hdr_type = bitstream_read(bc, 8);
if (hdr_type != 1) {
av_log(avctx, AV_LOG_ERROR, "First header is not the id header.\n");
return AVERROR_INVALIDDATA;
@@ -1041,8 +1041,8 @@ static av_cold int vorbis_decode_init(AVCodecContext
*avctx)
return ret;
}
- init_get_bits(gb, header_start[2], header_len[2]*8);
- hdr_type = get_bits(gb, 8);
+ bitstream_init(bc, header_start[2], header_len[2] * 8);
+ hdr_type = bitstream_read(bc, 8);
if (hdr_type != 5) {
av_log(avctx, AV_LOG_ERROR, "Third header is not the setup header.\n");
vorbis_free(vc);
@@ -1080,13 +1080,13 @@ static int vorbis_floor0_decode(vorbis_context *vc,
if (!vf->amplitude_bits)
return 1;
- amplitude = get_bits(&vc->gb, vf->amplitude_bits);
+ amplitude = bitstream_read(&vc->bc, vf->amplitude_bits);
if (amplitude > 0) {
float last = 0;
unsigned idx, lsp_len = 0;
vorbis_codebook codebook;
- book_idx = get_bits(&vc->gb, ilog(vf->num_books));
+ book_idx = bitstream_read(&vc->bc, ilog(vf->num_books));
if (book_idx >= vf->num_books) {
av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too
high!\n");
book_idx = 0;
@@ -1103,8 +1103,8 @@ static int vorbis_floor0_decode(vorbis_context *vc,
ff_dlog(NULL, "floor0 dec: book dimension: %d\n",
codebook.dimensions);
ff_dlog(NULL, "floor0 dec: maximum depth: %d\n",
codebook.maxdepth);
/* read temp vector */
- vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
- codebook.nb_bits, codebook.maxdepth)
+ vec_off = bitstream_read_vlc(&vc->bc, codebook.vlc.table,
+ codebook.nb_bits, codebook.maxdepth)
* codebook.dimensions;
ff_dlog(NULL, "floor0 dec: vector offset: %d\n", vec_off);
/* copy each vector component and add last to it */
@@ -1181,7 +1181,7 @@ static int vorbis_floor1_decode(vorbis_context *vc,
vorbis_floor_data *vfu, float *vec)
{
vorbis_floor1 *vf = &vfu->t1;
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
uint16_t range_v[4] = { 256, 128, 86, 64 };
unsigned range = range_v[vf->multiplier - 1];
uint16_t floor1_Y[258];
@@ -1191,13 +1191,13 @@ static int vorbis_floor1_decode(vorbis_context *vc,
int book, adx, ady, dy, off, predicted, err;
- if (!get_bits1(gb)) // silence
+ if (!bitstream_read_bit(bc)) // silence
return 1;
// Read values (or differences) for the floor's points
- floor1_Y[0] = get_bits(gb, ilog(range - 1));
- floor1_Y[1] = get_bits(gb, ilog(range - 1));
+ floor1_Y[0] = bitstream_read(bc, ilog(range - 1));
+ floor1_Y[1] = bitstream_read(bc, ilog(range - 1));
ff_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
@@ -1212,19 +1212,20 @@ static int vorbis_floor1_decode(vorbis_context *vc,
ff_dlog(NULL, "Cbits %u\n", cbits);
if (cbits) // this reads all subclasses for this partition's class
- cval = get_vlc2(gb,
vc->codebooks[vf->class_masterbook[class]].vlc.table,
-
vc->codebooks[vf->class_masterbook[class]].nb_bits, 3);
+ cval = bitstream_read_vlc(bc,
vc->codebooks[vf->class_masterbook[class]].vlc.table,
+
vc->codebooks[vf->class_masterbook[class]].nb_bits, 3);
for (j = 0; j < cdim; ++j) {
book = vf->subclass_books[class][cval & csub];
ff_dlog(NULL, "book %d Cbits %u cval %u bits:%d\n",
- book, cbits, cval, get_bits_count(gb));
+ book, cbits, cval, bitstream_tell(bc));
cval = cval >> cbits;
if (book > -1) {
- floor1_Y[offset+j] = get_vlc2(gb,
vc->codebooks[book].vlc.table,
- vc->codebooks[book].nb_bits, 3);
+ floor1_Y[offset + j] =
+ bitstream_read_vlc(bc, vc->codebooks[book].vlc.table,
+ vc->codebooks[book].nb_bits, 3);
} else {
floor1_Y[offset+j] = 0;
}
@@ -1314,8 +1315,8 @@ static av_always_inline int setup_classifs(vorbis_context
*vc,
int temp, temp2;
for (p = 0, j = 0; j < ch_used; ++j) {
if (!do_not_decode[j]) {
- temp = get_vlc2(&vc->gb, codebook->vlc.table,
- codebook->nb_bits, 3);
+ temp = bitstream_read_vlc(&vc->bc, codebook->vlc.table,
+ codebook->nb_bits, 3);
ff_dlog(NULL, "Classword: %u\n", temp);
@@ -1348,7 +1349,7 @@ static av_always_inline int
vorbis_residue_decode_internal(vorbis_context *vc,
unsigned ch_left,
int vr_type)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
unsigned c_p_c = vc->codebooks[vr->classbook].dimensions;
uint8_t *classifs = vr->classifs;
unsigned pass, ch_used, i, j, k, l;
@@ -1402,14 +1403,14 @@ static av_always_inline int
vorbis_residue_decode_internal(vorbis_context *vc,
voffs = voffset+j*vlen;
for (k = 0; k < step; ++k) {
- coffs = get_vlc2(gb, codebook.vlc.table,
codebook.nb_bits, 3) * dim;
+ coffs = bitstream_read_vlc(bc,
codebook.vlc.table, codebook.nb_bits, 3) * dim;
for (l = 0; l < dim; ++l)
vec[voffs + k + l * step] +=
codebook.codevectors[coffs + l];
}
} else if (vr_type == 1) {
voffs = voffset + j * vlen;
for (k = 0; k < step; ++k) {
- coffs = get_vlc2(gb, codebook.vlc.table,
codebook.nb_bits, 3) * dim;
+ coffs = bitstream_read_vlc(bc,
codebook.vlc.table, codebook.nb_bits, 3) * dim;
for (l = 0; l < dim; ++l, ++voffs) {
vec[voffs]+=codebook.codevectors[coffs+l];
@@ -1422,13 +1423,13 @@ static av_always_inline int
vorbis_residue_decode_internal(vorbis_context *vc,
if (dim == 2) {
for (k = 0; k < step; ++k) {
- coffs = get_vlc2(gb,
codebook.vlc.table, codebook.nb_bits, 3) * 2;
+ coffs = bitstream_read_vlc(bc,
codebook.vlc.table, codebook.nb_bits, 3) * 2;
vec[voffs + k ] +=
codebook.codevectors[coffs ];
vec[voffs + k + vlen] +=
codebook.codevectors[coffs + 1];
}
} else if (dim == 4) {
for (k = 0; k < step; ++k, voffs += 2) {
- coffs = get_vlc2(gb,
codebook.vlc.table, codebook.nb_bits, 3) * 4;
+ coffs = bitstream_read_vlc(bc,
codebook.vlc.table, codebook.nb_bits, 3) * 4;
vec[voffs ] +=
codebook.codevectors[coffs ];
vec[voffs + 1 ] +=
codebook.codevectors[coffs + 2];
vec[voffs + vlen ] +=
codebook.codevectors[coffs + 1];
@@ -1436,7 +1437,7 @@ static av_always_inline int
vorbis_residue_decode_internal(vorbis_context *vc,
}
} else
for (k = 0; k < step; ++k) {
- coffs = get_vlc2(gb, codebook.vlc.table,
codebook.nb_bits, 3) * dim;
+ coffs = bitstream_read_vlc(bc,
codebook.vlc.table, codebook.nb_bits, 3) * dim;
for (l = 0; l < dim; l += 2, voffs++) {
vec[voffs ] +=
codebook.codevectors[coffs + l ];
vec[voffs + vlen] +=
codebook.codevectors[coffs + l + 1];
@@ -1453,7 +1454,7 @@ static av_always_inline int
vorbis_residue_decode_internal(vorbis_context *vc,
unsigned voffs_mod = voffset - voffs_div * ch;
for (k = 0; k < step; ++k) {
- coffs = get_vlc2(gb, codebook.vlc.table,
codebook.nb_bits, 3) * dim;
+ coffs = bitstream_read_vlc(bc,
codebook.vlc.table, codebook.nb_bits, 3) * dim;
for (l = 0; l < dim; ++l) {
vec[voffs_div + voffs_mod * vlen] +=
codebook.codevectors[coffs + l];
@@ -1528,7 +1529,7 @@ void ff_vorbis_inverse_coupling(float *mag, float *ang,
intptr_t blocksize)
static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
{
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
FFTContext *mdct;
unsigned previous_window = vc->previous_window;
unsigned mode_number, blockflag, blocksize;
@@ -1543,7 +1544,7 @@ static int vorbis_parse_audio_packet(vorbis_context *vc,
float **floor_ptr)
unsigned ch_left = vc->audio_channels;
unsigned vlen;
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
return AVERROR_INVALIDDATA; // packet type not audio
}
@@ -1563,8 +1564,8 @@ static int vorbis_parse_audio_packet(vorbis_context *vc,
float **floor_ptr)
blocksize = vc->blocksize[blockflag];
vlen = blocksize / 2;
if (blockflag) {
- previous_window = get_bits(gb, 1);
- skip_bits1(gb); // next_window
+ previous_window = bitstream_read(bc, 1);
+ bitstream_skip(bc, 1); // next_window
}
memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * vlen);
//FIXME can this be removed ?
@@ -1694,7 +1695,7 @@ static int vorbis_decode_frame(AVCodecContext *avctx,
void *data,
int buf_size = avpkt->size;
vorbis_context *vc = avctx->priv_data;
AVFrame *frame = data;
- GetBitContext *gb = &vc->gb;
+ BitstreamContext *bc = &vc->bc;
float *channel_ptrs[255];
int i, len, ret;
@@ -1717,7 +1718,7 @@ static int vorbis_decode_frame(AVCodecContext *avctx,
void *data,
}
}
- init_get_bits(gb, buf, buf_size*8);
+ bitstream_init(bc, buf, buf_size * 8);
if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)
return len;
@@ -1730,7 +1731,7 @@ static int vorbis_decode_frame(AVCodecContext *avctx,
void *data,
}
ff_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
- get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
+ bitstream_tell(bc) / 8, bitstream_tell(bc) % 8, len);
frame->nb_samples = len;
*got_frame_ptr = 1;
--
2.7.3
_______________________________________________
libav-devel mailing list
libav-devel@libav.org
https://lists.libav.org/mailman/listinfo/libav-devel
