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