[FFmpeg-cvslog] tak: Convert to the new bitstream reader
Alexandra Hájková
git at videolan.org
Fri May 19 12:53:22 EEST 2017
ffmpeg | branch: master | Alexandra Hájková <alexandra at khirnov.net> | Wed Apr 13 21:00:34 2016 +0200| [381a4e31a6b801a046e38b0e2b08fb61499157a7] | committer: Diego Biurrun
tak: Convert to the new bitstream reader
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=381a4e31a6b801a046e38b0e2b08fb61499157a7
---
libavcodec/tak.c | 49 +++++++--------
libavcodec/tak.h | 10 +--
libavcodec/tak_parser.c | 15 ++---
libavcodec/takdec.c | 158 ++++++++++++++++++++++++------------------------
libavformat/takdec.c | 13 ++--
5 files changed, 125 insertions(+), 120 deletions(-)
diff --git a/libavcodec/tak.c b/libavcodec/tak.c
index bd82c3d193..c90e55ad6a 100644
--- a/libavcodec/tak.c
+++ b/libavcodec/tak.c
@@ -24,6 +24,7 @@
#include "libavutil/intreadwrite.h"
#define BITSTREAM_READER_LE
+#include "bitstream.h"
#include "tak.h"
static const uint16_t frame_duration_type_quants[] = {
@@ -85,30 +86,30 @@ int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size)
return 0;
}
-void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s)
+void avpriv_tak_parse_streaminfo(BitstreamContext *bc, TAKStreamInfo *s)
{
uint64_t channel_mask = 0;
int frame_type, i;
- s->codec = get_bits(gb, TAK_ENCODER_CODEC_BITS);
- skip_bits(gb, TAK_ENCODER_PROFILE_BITS);
+ s->codec = bitstream_read(bc, TAK_ENCODER_CODEC_BITS);
+ bitstream_skip(bc, TAK_ENCODER_PROFILE_BITS);
- frame_type = get_bits(gb, TAK_SIZE_FRAME_DURATION_BITS);
- s->samples = get_bits64(gb, TAK_SIZE_SAMPLES_NUM_BITS);
+ frame_type = bitstream_read(bc, TAK_SIZE_FRAME_DURATION_BITS);
+ s->samples = bitstream_read_63(bc, TAK_SIZE_SAMPLES_NUM_BITS);
- s->data_type = get_bits(gb, TAK_FORMAT_DATA_TYPE_BITS);
- s->sample_rate = get_bits(gb, TAK_FORMAT_SAMPLE_RATE_BITS) +
+ s->data_type = bitstream_read(bc, TAK_FORMAT_DATA_TYPE_BITS);
+ s->sample_rate = bitstream_read(bc, TAK_FORMAT_SAMPLE_RATE_BITS) +
TAK_SAMPLE_RATE_MIN;
- s->bps = get_bits(gb, TAK_FORMAT_BPS_BITS) +
+ s->bps = bitstream_read(bc, TAK_FORMAT_BPS_BITS) +
TAK_BPS_MIN;
- s->channels = get_bits(gb, TAK_FORMAT_CHANNEL_BITS) +
+ s->channels = bitstream_read(bc, TAK_FORMAT_CHANNEL_BITS) +
TAK_CHANNELS_MIN;
- if (get_bits1(gb)) {
- skip_bits(gb, TAK_FORMAT_VALID_BITS);
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
+ bitstream_skip(bc, TAK_FORMAT_VALID_BITS);
+ if (bitstream_read_bit(bc)) {
for (i = 0; i < s->channels; i++) {
- int value = get_bits(gb, TAK_FORMAT_CH_LAYOUT_BITS);
+ int value = bitstream_read(bc, TAK_FORMAT_CH_LAYOUT_BITS);
if (value > 0 && value <= 18)
channel_mask |= 1 << (value - 1);
@@ -120,33 +121,33 @@ void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s)
s->frame_samples = tak_get_nb_samples(s->sample_rate, frame_type);
}
-int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
+int ff_tak_decode_frame_header(AVCodecContext *avctx, BitstreamContext *bc,
TAKStreamInfo *ti, int log_level_offset)
{
- if (get_bits(gb, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) {
+ if (bitstream_read(bc, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) {
av_log(avctx, AV_LOG_ERROR + log_level_offset, "missing sync id\n");
return AVERROR_INVALIDDATA;
}
- ti->flags = get_bits(gb, TAK_FRAME_HEADER_FLAGS_BITS);
- ti->frame_num = get_bits(gb, TAK_FRAME_HEADER_NO_BITS);
+ ti->flags = bitstream_read(bc, TAK_FRAME_HEADER_FLAGS_BITS);
+ ti->frame_num = bitstream_read(bc, TAK_FRAME_HEADER_NO_BITS);
if (ti->flags & TAK_FRAME_FLAG_IS_LAST) {
- ti->last_frame_samples = get_bits(gb, TAK_FRAME_HEADER_SAMPLE_COUNT_BITS) + 1;
- skip_bits(gb, 2);
+ ti->last_frame_samples = bitstream_read(bc, TAK_FRAME_HEADER_SAMPLE_COUNT_BITS) + 1;
+ bitstream_skip(bc, 2);
} else {
ti->last_frame_samples = 0;
}
if (ti->flags & TAK_FRAME_FLAG_HAS_INFO) {
- avpriv_tak_parse_streaminfo(gb, ti);
+ avpriv_tak_parse_streaminfo(bc, ti);
- if (get_bits(gb, 6))
- skip_bits(gb, 25);
- align_get_bits(gb);
+ if (bitstream_read(bc, 6))
+ bitstream_skip(bc, 25);
+ bitstream_align(bc);
}
- skip_bits(gb, 24);
+ bitstream_skip(bc, 24);
return 0;
}
diff --git a/libavcodec/tak.h b/libavcodec/tak.h
index 19b1c47521..c752062521 100644
--- a/libavcodec/tak.h
+++ b/libavcodec/tak.h
@@ -30,7 +30,7 @@
#include <stdint.h>
#include "avcodec.h"
-#include "get_bits.h"
+#include "bitstream.h"
#define TAK_FORMAT_DATA_TYPE_BITS 3
#define TAK_FORMAT_SAMPLE_RATE_BITS 18
@@ -145,21 +145,21 @@ int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size);
/**
* Parse the Streaminfo metadata block.
- * @param[in] gb pointer to GetBitContext
+ * @param[in] bc pointer to BitstreamContext
* @param[out] s storage for parsed information
*/
-void avpriv_tak_parse_streaminfo(GetBitContext *gb, TAKStreamInfo *s);
+void avpriv_tak_parse_streaminfo(BitstreamContext *bc, TAKStreamInfo *s);
/**
* Validate and decode a frame header.
* @param avctx AVCodecContext to use as av_log() context
- * @param[in] gb GetBitContext from which to read frame header
+ * @param[in] bc BitstreamContext from which to read frame header
* @param[out] s frame information
* @param log_level_offset log level offset, can be used to silence
* error messages.
* @return non-zero on error, 0 if OK
*/
-int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
+int ff_tak_decode_frame_header(AVCodecContext *avctx, BitstreamContext *bc,
TAKStreamInfo *s, int log_level_offset);
#endif /* AVCODEC_TAK_H */
diff --git a/libavcodec/tak_parser.c b/libavcodec/tak_parser.c
index 9ac1deb9f7..82fb7e8c6b 100644
--- a/libavcodec/tak_parser.c
+++ b/libavcodec/tak_parser.c
@@ -25,6 +25,7 @@
**/
#define BITSTREAM_READER_LE
+#include "bitstream.h"
#include "parser.h"
#include "tak.h"
@@ -47,14 +48,14 @@ static int tak_parse(AVCodecParserContext *s, AVCodecContext *avctx,
TAKParseContext *t = s->priv_data;
ParseContext *pc = &t->pc;
int next = END_NOT_FOUND;
- GetBitContext gb;
+ BitstreamContext bc;
int consumed = 0;
int needed = buf_size ? TAK_MAX_FRAME_HEADER_BYTES : 8;
if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
TAKStreamInfo ti;
- init_get_bits(&gb, buf, buf_size);
- if (!ff_tak_decode_frame_header(avctx, &gb, &ti, 127))
+ bitstream_init(&bc, buf, buf_size);
+ if (!ff_tak_decode_frame_header(avctx, &bc, &ti, 127))
s->duration = t->ti.last_frame_samples ? t->ti.last_frame_samples
: t->ti.frame_samples;
*poutbuf = buf;
@@ -79,14 +80,14 @@ static int tak_parse(AVCodecParserContext *s, AVCodecContext *avctx,
pc->buffer[t->index + 1] == 0xA0) {
TAKStreamInfo ti;
- init_get_bits(&gb, pc->buffer + t->index,
- 8 * (pc->index - t->index));
- if (!ff_tak_decode_frame_header(avctx, &gb,
+ bitstream_init8(&bc, pc->buffer + t->index,
+ pc->index - t->index);
+ if (!ff_tak_decode_frame_header(avctx, &bc,
pc->frame_start_found ? &ti
: &t->ti,
127) &&
!ff_tak_check_crc(pc->buffer + t->index,
- get_bits_count(&gb) / 8)) {
+ bitstream_tell(&bc) / 8)) {
if (!pc->frame_start_found) {
pc->frame_start_found = 1;
s->duration = t->ti.last_frame_samples ?
diff --git a/libavcodec/takdec.c b/libavcodec/takdec.c
index e7320c66d4..11c04f4ff4 100644
--- a/libavcodec/takdec.c
+++ b/libavcodec/takdec.c
@@ -31,8 +31,9 @@
#define BITSTREAM_READER_LE
#include "audiodsp.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "internal.h"
-#include "unary_legacy.h"
+#include "unary.h"
#include "tak.h"
#define MAX_SUBFRAMES 8 // max number of subframes per channel
@@ -49,7 +50,7 @@ typedef struct TAKDecContext {
AVCodecContext *avctx; // parent AVCodecContext
AudioDSPContext adsp;
TAKStreamInfo ti;
- GetBitContext gb; // bitstream reader initialized to start at the current frame
+ BitstreamContext bc; // bitstream reader initialized to start at the current frame
int uval;
int nb_samples; // number of samples in the current frame
@@ -238,7 +239,7 @@ static void decode_lpc(int32_t *coeffs, int mode, int length)
}
}
-static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded,
+static int decode_segment(BitstreamContext *bc, int mode, int32_t *decoded,
int len)
{
struct CParam code;
@@ -254,20 +255,20 @@ static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded,
code = xcodes[mode - 1];
for (i = 0; i < len; i++) {
- int x = get_bits_long(gb, code.init);
- if (x >= code.escape && get_bits1(gb)) {
+ int x = bitstream_read(bc, code.init);
+ if (x >= code.escape && bitstream_read_bit(bc)) {
x |= 1 << code.init;
if (x >= code.aescape) {
- int scale = get_unary(gb, 1, 9);
+ int scale = get_unary(bc, 1, 9);
if (scale == 9) {
- int scale_bits = get_bits(gb, 3);
+ int scale_bits = bitstream_read(bc, 3);
if (scale_bits > 0) {
if (scale_bits == 7) {
- scale_bits += get_bits(gb, 5);
+ scale_bits += bitstream_read(bc, 5);
if (scale_bits > 29)
return AVERROR_INVALIDDATA;
}
- scale = get_bits_long(gb, scale_bits) + 1;
+ scale = bitstream_read(bc, scale_bits) + 1;
x += code.scale * scale;
}
x += code.bias;
@@ -284,13 +285,13 @@ static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded,
static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
{
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, mode, ret;
if (length > s->nb_samples)
return AVERROR_INVALIDDATA;
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
int wlength, rval;
int coding_mode[128];
@@ -306,20 +307,21 @@ static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
if (wlength <= 1 || wlength > 128)
return AVERROR_INVALIDDATA;
- coding_mode[0] = mode = get_bits(gb, 6);
+ coding_mode[0] =
+ mode = bitstream_read(bc, 6);
for (i = 1; i < wlength; i++) {
- int c = get_unary(gb, 1, 6);
+ int c = get_unary(bc, 1, 6);
switch (c) {
case 6:
- mode = get_bits(gb, 6);
+ mode = bitstream_read(bc, 6);
break;
case 5:
case 4:
case 3: {
/* mode += sign ? (1 - c) : (c - 1) */
- int sign = get_bits1(gb);
+ int sign = bitstream_read_bit(bc);
mode += (-sign ^ (c - 1)) + sign;
break;
}
@@ -349,23 +351,23 @@ static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
break;
} while (coding_mode[i] == mode);
- if ((ret = decode_segment(gb, mode, decoded, len)) < 0)
+ if ((ret = decode_segment(bc, mode, decoded, len)) < 0)
return ret;
decoded += len;
}
} else {
- mode = get_bits(gb, 6);
- if ((ret = decode_segment(gb, mode, decoded, length)) < 0)
+ mode = bitstream_read(bc, 6);
+ if ((ret = decode_segment(bc, mode, decoded, length)) < 0)
return ret;
}
return 0;
}
-static int get_bits_esc4(GetBitContext *gb)
+static int bits_esc4(BitstreamContext *bc)
{
- if (get_bits1(gb))
- return get_bits(gb, 4) + 1;
+ if (bitstream_read_bit(bc))
+ return bitstream_read(bc, 4) + 1;
else
return 0;
}
@@ -373,23 +375,23 @@ static int get_bits_esc4(GetBitContext *gb)
static void decode_filter_coeffs(TAKDecContext *s, int filter_order, int size,
int filter_quant, int16_t *filter)
{
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, j, a, b;
int filter_tmp[MAX_PREDICTORS];
int16_t predictors[MAX_PREDICTORS];
- predictors[0] = get_sbits(gb, 10);
- predictors[1] = get_sbits(gb, 10);
- predictors[2] = get_sbits(gb, size) << (10 - size);
- predictors[3] = get_sbits(gb, size) << (10 - size);
+ predictors[0] = bitstream_read_signed(bc, 10);
+ predictors[1] = bitstream_read_signed(bc, 10);
+ predictors[2] = bitstream_read_signed(bc, size) << (10 - size);
+ predictors[3] = bitstream_read_signed(bc, size) << (10 - size);
if (filter_order > 4) {
int av_uninit(code_size);
- int code_size_base = size - get_bits1(gb);
+ int code_size_base = size - bitstream_read_bit(bc);
for (i = 4; i < filter_order; i++) {
if (!(i & 3))
- code_size = code_size_base - get_bits(gb, 2);
- predictors[i] = get_sbits(gb, code_size) << (10 - size);
+ code_size = code_size_base - bitstream_read(bc, 2);
+ predictors[i] = bitstream_read_signed(bc, code_size) << (10 - size);
}
}
@@ -421,18 +423,18 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded,
int subframe_size, int prev_subframe_size)
{
LOCAL_ALIGNED_16(int16_t, filter, [MAX_PREDICTORS]);
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int i, ret;
int dshift, size, filter_quant, filter_order;
memset(filter, 0, MAX_PREDICTORS * sizeof(*filter));
- if (!get_bits1(gb))
+ if (!bitstream_read_bit(bc))
return decode_residues(s, decoded, subframe_size);
- filter_order = predictor_sizes[get_bits(gb, 4)];
+ filter_order = predictor_sizes[bitstream_read(bc, 4)];
- if (prev_subframe_size > 0 && get_bits1(gb)) {
+ if (prev_subframe_size > 0 && bitstream_read_bit(bc)) {
if (filter_order > prev_subframe_size)
return AVERROR_INVALIDDATA;
@@ -447,7 +449,7 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded,
if (filter_order > subframe_size)
return AVERROR_INVALIDDATA;
- lpc_mode = get_bits(gb, 2);
+ lpc_mode = bitstream_read(bc, 2);
if (lpc_mode > 2)
return AVERROR_INVALIDDATA;
@@ -458,12 +460,12 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded,
decode_lpc(decoded, lpc_mode, filter_order);
}
- dshift = get_bits_esc4(gb);
- size = get_bits1(gb) + 6;
+ dshift = bits_esc4(bc);
+ size = bitstream_read_bit(bc) + 6;
filter_quant = 10;
- if (get_bits1(gb)) {
- filter_quant -= get_bits(gb, 3) + 1;
+ if (bitstream_read_bit(bc)) {
+ filter_quant -= bitstream_read(bc, 3) + 1;
if (filter_quant < 3)
return AVERROR_INVALIDDATA;
}
@@ -502,35 +504,35 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded,
static int decode_channel(TAKDecContext *s, int chan)
{
AVCodecContext *avctx = s->avctx;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int32_t *decoded = s->decoded[chan];
int left = s->nb_samples - 1;
int i, prev, ret, nb_subframes;
int subframe_len[MAX_SUBFRAMES];
- s->sample_shift[chan] = get_bits_esc4(gb);
+ s->sample_shift[chan] = bits_esc4(bc);
if (s->sample_shift[chan] >= avctx->bits_per_coded_sample)
return AVERROR_INVALIDDATA;
/* NOTE: TAK 2.2.0 appears to set the sample value to 0 if
* bits_per_coded_sample - sample_shift is 1, but this produces
- * non-bit-exact output. Reading the 1 bit using get_sbits() instead
- * of skipping it produces bit-exact output. This has been reported
- * to the TAK author. */
- *decoded++ = get_sbits(gb,
- avctx->bits_per_coded_sample -
- s->sample_shift[chan]);
- s->lpc_mode[chan] = get_bits(gb, 2);
- nb_subframes = get_bits(gb, 3) + 1;
+ * non-bit-exact output. Reading the 1 bit using bitstream_read_signed()
+ * instead of skipping it produces bit-exact output. This has been
+ * reported to the TAK author. */
+ *decoded++ = bitstream_read_signed(bc,
+ avctx->bits_per_coded_sample -
+ s->sample_shift[chan]);
+ s->lpc_mode[chan] = bitstream_read(bc, 2);
+ nb_subframes = bitstream_read(bc, 3) + 1;
i = 0;
if (nb_subframes > 1) {
- if (get_bits_left(gb) < (nb_subframes - 1) * 6)
+ if (bitstream_bits_left(bc) < (nb_subframes - 1) * 6)
return AVERROR_INVALIDDATA;
prev = 0;
for (; i < nb_subframes - 1; i++) {
- int subframe_end = get_bits(gb, 6) * s->subframe_scale;
+ int subframe_end = bitstream_read(bc, 6) * s->subframe_scale;
if (subframe_end <= prev)
return AVERROR_INVALIDDATA;
subframe_len[i] = subframe_end - prev;
@@ -556,7 +558,7 @@ static int decode_channel(TAKDecContext *s, int chan)
static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
{
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int32_t *p1 = s->decoded[c1] + 1;
int32_t *p2 = s->decoded[c2] + 1;
int i;
@@ -589,8 +591,8 @@ static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
case 4: /* side/left with scale factor */
FFSWAP(int32_t*, p1, p2);
case 5: /* side/right with scale factor */
- dshift = get_bits_esc4(gb);
- dfactor = get_sbits(gb, 10);
+ dshift = bits_esc4(bc);
+ dfactor = bitstream_read_signed(bc, 10);
for (i = 0; i < length; i++) {
int32_t a = p1[i];
int32_t b = p2[i];
@@ -610,15 +612,15 @@ static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
if (length < 256)
return AVERROR_INVALIDDATA;
- dshift = get_bits_esc4(gb);
- filter_order = 8 << get_bits1(gb);
- dval1 = get_bits1(gb);
- dval2 = get_bits1(gb);
+ dshift = bits_esc4(bc);
+ filter_order = 8 << bitstream_read_bit(bc);
+ dval1 = bitstream_read_bit(bc);
+ dval2 = bitstream_read_bit(bc);
for (i = 0; i < filter_order; i++) {
if (!(i & 3))
- code_size = 14 - get_bits(gb, 3);
- filter[i] = get_sbits(gb, code_size);
+ code_size = 14 - bitstream_read(bc, 3);
+ filter[i] = bitstream_read_signed(bc, code_size);
}
order_half = filter_order / 2;
@@ -675,15 +677,15 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
{
TAKDecContext *s = avctx->priv_data;
AVFrame *frame = data;
- GetBitContext *gb = &s->gb;
+ BitstreamContext *bc = &s->bc;
int chan, i, ret, hsize;
if (pkt->size < TAK_MIN_FRAME_HEADER_BYTES)
return AVERROR_INVALIDDATA;
- init_get_bits(gb, pkt->data, pkt->size * 8);
+ bitstream_init8(bc, pkt->data, pkt->size);
- if ((ret = ff_tak_decode_frame_header(avctx, gb, &s->ti, 0)) < 0)
+ if ((ret = ff_tak_decode_frame_header(avctx, bc, &s->ti, 0)) < 0)
return ret;
if (s->ti.flags & TAK_FRAME_FLAG_HAS_METADATA) {
@@ -691,7 +693,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
return AVERROR_PATCHWELCOME;
}
- hsize = get_bits_count(gb) / 8;
+ hsize = bitstream_tell(bc) / 8;
if (avctx->err_recognition & AV_EF_CRCCHECK) {
if (ff_tak_check_crc(pkt->data, hsize)) {
av_log(avctx, AV_LOG_ERROR, "CRC error\n");
@@ -769,7 +771,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
for (chan = 0; chan < avctx->channels; chan++) {
int32_t *decoded = s->decoded[chan];
for (i = 0; i < s->nb_samples; i++)
- decoded[i] = get_sbits(gb, avctx->bits_per_coded_sample);
+ decoded[i] = bitstream_read_signed(bc, avctx->bits_per_coded_sample);
}
} else {
if (s->ti.codec == TAK_CODEC_MONO_STEREO) {
@@ -778,25 +780,25 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
return ret;
if (avctx->channels == 2) {
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
// some kind of subframe length, but it seems to be unused
- skip_bits(gb, 6);
+ bitstream_skip(bc, 6);
}
- s->dmode = get_bits(gb, 3);
+ s->dmode = bitstream_read(bc, 3);
if (ret = decorrelate(s, 0, 1, s->nb_samples - 1))
return ret;
}
} else if (s->ti.codec == TAK_CODEC_MULTICHANNEL) {
- if (get_bits1(gb)) {
+ if (bitstream_read_bit(bc)) {
int ch_mask = 0;
- chan = get_bits(gb, 4) + 1;
+ chan = bitstream_read(bc, 4) + 1;
if (chan > avctx->channels)
return AVERROR_INVALIDDATA;
for (i = 0; i < chan; i++) {
- int nbit = get_bits(gb, 4);
+ int nbit = bitstream_read(bc, 4);
if (nbit >= avctx->channels)
return AVERROR_INVALIDDATA;
@@ -804,10 +806,10 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
if (ch_mask & 1 << nbit)
return AVERROR_INVALIDDATA;
- s->mcdparams[i].present = get_bits1(gb);
+ s->mcdparams[i].present = bitstream_read_bit(bc);
if (s->mcdparams[i].present) {
- s->mcdparams[i].index = get_bits(gb, 2);
- s->mcdparams[i].chan2 = get_bits(gb, 4);
+ s->mcdparams[i].index = bitstream_read(bc, 2);
+ s->mcdparams[i].chan2 = bitstream_read(bc, 4);
if (s->mcdparams[i].chan2 >= avctx->channels) {
av_log(avctx, AV_LOG_ERROR,
"invalid channel 2 (%d) for %d channel(s)\n",
@@ -867,16 +869,16 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
}
}
- align_get_bits(gb);
- skip_bits(gb, 24);
- if (get_bits_left(gb) < 0)
+ bitstream_align(bc);
+ bitstream_skip(bc, 24);
+ if (bitstream_bits_left(bc) < 0)
av_log(avctx, AV_LOG_DEBUG, "overread\n");
- else if (get_bits_left(gb) > 0)
+ else if (bitstream_bits_left(bc) > 0)
av_log(avctx, AV_LOG_DEBUG, "underread\n");
if (avctx->err_recognition & AV_EF_CRCCHECK) {
if (ff_tak_check_crc(pkt->data + hsize,
- get_bits_count(gb) / 8 - hsize)) {
+ bitstream_tell(bc) / 8 - hsize)) {
av_log(avctx, AV_LOG_ERROR, "CRC error\n");
if (avctx->err_recognition & AV_EF_EXPLODE)
return AVERROR_INVALIDDATA;
diff --git a/libavformat/takdec.c b/libavformat/takdec.c
index 19e0e69a5e..4b3037d9ca 100644
--- a/libavformat/takdec.c
+++ b/libavformat/takdec.c
@@ -20,6 +20,7 @@
*/
#define BITSTREAM_READER_LE
+#include "libavcodec/bitstream.h"
#include "libavcodec/tak.h"
#include "apetag.h"
@@ -43,7 +44,7 @@ static int tak_read_header(AVFormatContext *s)
{
TAKDemuxContext *tc = s->priv_data;
AVIOContext *pb = s->pb;
- GetBitContext gb;
+ BitstreamContext bc;
AVStream *st;
uint8_t *buffer = NULL;
int ret;
@@ -82,7 +83,7 @@ static int tak_read_header(AVFormatContext *s)
return AVERROR(EIO);
}
- init_get_bits(&gb, buffer, size * 8);
+ bitstream_init8(&bc, buffer, size);
break;
case TAK_METADATA_MD5: {
uint8_t md5[16];
@@ -118,7 +119,7 @@ static int tak_read_header(AVFormatContext *s)
if (type == TAK_METADATA_STREAMINFO) {
TAKStreamInfo ti;
- avpriv_tak_parse_streaminfo(&gb, &ti);
+ avpriv_tak_parse_streaminfo(&bc, &ti);
if (ti.samples > 0)
st->duration = ti.samples;
st->codecpar->bits_per_coded_sample = ti.bps;
@@ -135,12 +136,12 @@ static int tak_read_header(AVFormatContext *s)
if (size != 11)
return AVERROR_INVALIDDATA;
tc->mlast_frame = 1;
- tc->data_end = get_bits64(&gb, TAK_LAST_FRAME_POS_BITS) +
- get_bits(&gb, TAK_LAST_FRAME_SIZE_BITS);
+ tc->data_end = bitstream_read_63(&bc, TAK_LAST_FRAME_POS_BITS) +
+ bitstream_read(&bc, TAK_LAST_FRAME_SIZE_BITS);
av_freep(&buffer);
} else if (type == TAK_METADATA_ENCODER) {
av_log(s, AV_LOG_VERBOSE, "encoder version: %0X\n",
- get_bits_long(&gb, TAK_ENCODER_VERSION_BITS));
+ bitstream_read(&bc, TAK_ENCODER_VERSION_BITS));
av_freep(&buffer);
}
}
More information about the ffmpeg-cvslog
mailing list