Skip to content

Instantly share code, notes, and snippets.

@lu-zero

lu-zero/mpegaudio.diff

Forked from anonymous/mpegaudio.diff
Created April 18, 2016 14:10
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save lu-zero/b9dc5b6b43ebef73a9d06f8b7d062dfb to your computer and use it in GitHub Desktop.
Save lu-zero/b9dc5b6b43ebef73a9d06f8b7d062dfb to your computer and use it in GitHub Desktop.
Download ZIP
Raw
mpegaudio.diff
diff --git a/libavcodec/mpegaudiodec_template.c b/libavcodec/mpegaudiodec_template.c
index 820a7ae..51a1943 100644
--- a/libavcodec/mpegaudiodec_template.c
+++ b/libavcodec/mpegaudiodec_template.c
@@ -33,6 +33,7 @@
#include "internal.h"
#include "mathops.h"
#include "mpegaudiodsp.h"
+#include "bitstream_debug.h"
/*
* TODO:
@@ -72,8 +73,8 @@ typedef struct MPADecodeContext {
int last_buf_size;
/* next header (used in free format parsing) */
uint32_t free_format_next_header;
- GetBitContext gb;
- GetBitContext in_gb;
+ BitstreamContext bc;
+ BitstreamContext in_bc;
DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
int synth_buf_offset[MPA_MAX_CHANNELS];
DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
@@ -491,23 +492,23 @@ static int mp_decode_layer1(MPADecodeContext *s)
/* allocation bits */
for (i = 0; i < bound; i++) {
for (ch = 0; ch < s->nb_channels; ch++) {
- allocation[ch][i] = get_bits(&s->gb, 4);
+ allocation[ch][i] = bitstream_read_32(&s->bc, 4);
}
}
for (i = bound; i < SBLIMIT; i++)
- allocation[0][i] = get_bits(&s->gb, 4);
+ allocation[0][i] = bitstream_read_32(&s->bc, 4);
/* scale factors */
for (i = 0; i < bound; i++) {
for (ch = 0; ch < s->nb_channels; ch++) {
if (allocation[ch][i])
- scale_factors[ch][i] = get_bits(&s->gb, 6);
+ scale_factors[ch][i] = bitstream_read_32(&s->bc, 6);
}
}
for (i = bound; i < SBLIMIT; i++) {
if (allocation[0][i]) {
- scale_factors[0][i] = get_bits(&s->gb, 6);
- scale_factors[1][i] = get_bits(&s->gb, 6);
+ scale_factors[0][i] = bitstream_read_32(&s->bc, 6);
+ scale_factors[1][i] = bitstream_read_32(&s->bc, 6);
}
}
@@ -517,7 +518,7 @@ static int mp_decode_layer1(MPADecodeContext *s)
for (ch = 0; ch < s->nb_channels; ch++) {
n = allocation[ch][i];
if (n) {
- mant = get_bits(&s->gb, n + 1);
+ mant = bitstream_read_32(&s->bc, n + 1);
v = l1_unscale(n, mant, scale_factors[ch][i]);
} else {
v = 0;
@@ -528,7 +529,7 @@ static int mp_decode_layer1(MPADecodeContext *s)
for (i = bound; i < SBLIMIT; i++) {
n = allocation[0][i];
if (n) {
- mant = get_bits(&s->gb, n + 1);
+ mant = bitstream_read_32(&s->bc, n + 1);
v = l1_unscale(n, mant, scale_factors[0][i]);
s->sb_samples[0][j][i] = v;
v = l1_unscale(n, mant, scale_factors[1][i]);
@@ -574,12 +575,12 @@ static int mp_decode_layer2(MPADecodeContext *s)
for (i = 0; i < bound; i++) {
bit_alloc_bits = alloc_table[j];
for (ch = 0; ch < s->nb_channels; ch++)
- bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
+ bit_alloc[ch][i] = bitstream_read_32(&s->bc, bit_alloc_bits);
j += 1 << bit_alloc_bits;
}
for (i = bound; i < sblimit; i++) {
bit_alloc_bits = alloc_table[j];
- v = get_bits(&s->gb, bit_alloc_bits);
+ v = bitstream_read_32(&s->bc, bit_alloc_bits);
bit_alloc[0][i] = v;
bit_alloc[1][i] = v;
j += 1 << bit_alloc_bits;
@@ -589,7 +590,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
for (i = 0; i < sblimit; i++) {
for (ch = 0; ch < s->nb_channels; ch++) {
if (bit_alloc[ch][i])
- scale_code[ch][i] = get_bits(&s->gb, 2);
+ scale_code[ch][i] = bitstream_read_32(&s->bc, 2);
}
}
@@ -601,23 +602,23 @@ static int mp_decode_layer2(MPADecodeContext *s)
switch (scale_code[ch][i]) {
default:
case 0:
- sf[0] = get_bits(&s->gb, 6);
- sf[1] = get_bits(&s->gb, 6);
- sf[2] = get_bits(&s->gb, 6);
+ sf[0] = bitstream_read_32(&s->bc, 6);
+ sf[1] = bitstream_read_32(&s->bc, 6);
+ sf[2] = bitstream_read_32(&s->bc, 6);
break;
case 2:
- sf[0] = get_bits(&s->gb, 6);
+ sf[0] = bitstream_read_32(&s->bc, 6);
sf[1] = sf[0];
sf[2] = sf[0];
break;
case 1:
- sf[0] = get_bits(&s->gb, 6);
- sf[2] = get_bits(&s->gb, 6);
+ sf[0] = bitstream_read_32(&s->bc, 6);
+ sf[2] = bitstream_read_32(&s->bc, 6);
sf[1] = sf[0];
break;
case 3:
- sf[0] = get_bits(&s->gb, 6);
- sf[2] = get_bits(&s->gb, 6);
+ sf[0] = bitstream_read_32(&s->bc, 6);
+ sf[2] = bitstream_read_32(&s->bc, 6);
sf[1] = sf[2];
break;
}
@@ -640,7 +641,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
if (bits < 0) {
int v2;
/* 3 values at the same time */
- v = get_bits(&s->gb, -bits);
+ v = bitstream_read_32(&s->bc, -bits);
v2 = division_tabs[qindex][v];
steps = ff_mpa_quant_steps[qindex];
@@ -652,7 +653,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
l2_unscale_group(steps, v2 >> 8 , scale);
} else {
for (m = 0; m < 3; m++) {
- v = get_bits(&s->gb, bits);
+ v = bitstream_read_32(&s->bc, bits);
v = l1_unscale(bits - 1, v, scale);
s->sb_samples[ch][k * 12 + l + m][i] = v;
}
@@ -678,7 +679,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
bits = ff_mpa_quant_bits[qindex];
if (bits < 0) {
/* 3 values at the same time */
- v = get_bits(&s->gb, -bits);
+ v = bitstream_read_32(&s->bc, -bits);
steps = ff_mpa_quant_steps[qindex];
mant = v % steps;
v = v / steps;
@@ -698,7 +699,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
l2_unscale_group(steps, v, scale1);
} else {
for (m = 0; m < 3; m++) {
- mant = get_bits(&s->gb, bits);
+ mant = bitstream_read_32(&s->bc, bits);
s->sb_samples[0][k * 12 + l + m][i] =
l1_unscale(bits - 1, mant, scale0);
s->sb_samples[1][k * 12 + l + m][i] =
@@ -798,30 +799,33 @@ static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
int *end_pos2)
{
- if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
- s->gb = s->in_gb;
- s->in_gb.buffer = NULL;
- assert((get_bits_count(&s->gb) & 7) == 0);
- skip_bits_long(&s->gb, *pos - *end_pos);
+ if (s->in_bc.buffer && *pos >= (bitstream_read_count(&s->bc) + bitstream_show_left(&s->bc))) {
+ s->bc = s->in_bc;
+ s->in_bc.buffer = NULL;
+ assert((bitstream_read_count(&s->bc) & 7) == 0);
+ printf("skip %d, show_32 %X\n", *pos - *end_pos, bitstream_show_32(&s->bc, 32));
+ bitstream_skip(&s->bc, *pos - *end_pos);
+ printf("show_32 %X\n", bitstream_show_32(&s->bc, 32));
*end_pos2 =
- *end_pos = *end_pos2 + get_bits_count(&s->gb) - *pos;
- *pos = get_bits_count(&s->gb);
+ *end_pos = *end_pos2 + bitstream_read_count(&s->bc) - *pos;
+ *pos = bitstream_read_count(&s->bc);
+ printf("*pos %d\n", *pos);
}
}
/* Following is a optimized code for
INTFLOAT v = *src
- if(get_bits1(&s->gb))
+ if(bitstream_read_bit(&s->bc))
v = -v;
*dst = v;
*/
#if CONFIG_FLOAT
#define READ_FLIP_SIGN(dst,src) \
- v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31); \
+ v = AV_RN32A(src) ^ (bitstream_read_bit(&s->bc) << 31); \
AV_WN32A(dst, v);
#else
#define READ_FLIP_SIGN(dst,src) \
- v = -get_bits1(&s->gb); \
+ v = -bitstream_read_bit(&s->bc); \
*(dst) = (*(src) ^ v) - v;
#endif
@@ -832,7 +836,7 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
int i;
int last_pos, bits_left;
VLC *vlc;
- int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);
+ int end_pos = FFMIN(end_pos2, bitstream_read_count(&s->bc) + bitstream_show_left(&s->bc));
/* low frequencies (called big values) */
s_index = 0;
@@ -857,14 +861,14 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
for (; j > 0; j--) {
int exponent, x, y;
int v;
- int pos = get_bits_count(&s->gb);
+ int pos = bitstream_read_count(&s->bc);
if (pos >= end_pos){
switch_buffer(s, &pos, &end_pos, &end_pos2);
if (pos >= end_pos)
break;
}
- y = get_vlc2(&s->gb, vlc->table, 7, 3);
+ y = bitstream_read_vlc(&s->bc, vlc->table, 7, 3);
if (!y) {
g->sb_hybrid[s_index ] =
@@ -883,18 +887,20 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
if (x < 15) {
READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
} else {
- x += get_bitsz(&s->gb, linbits);
+ x += bitstream_read_32(&s->bc, linbits);
v = l3_unscale(x, exponent);
- if (get_bits1(&s->gb))
+ if (bitstream_read_count(&s->bc) == 220 && bitstream_show_left(&s->bc) == -12)
+ printf("break: show_32 %X\n", bitstream_show_32(&s->bc, 32));
+ if (bitstream_read_bit(&s->bc))
v = -v;
g->sb_hybrid[s_index] = v;
}
if (y < 15) {
READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
} else {
- y += get_bitsz(&s->gb, linbits);
+ y += bitstream_read_32(&s->bc, linbits);
v = l3_unscale(y, exponent);
- if (get_bits1(&s->gb))
+ if (bitstream_read_bit(&s->bc))
v = -v;
g->sb_hybrid[s_index+1] = v;
}
@@ -905,9 +911,9 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
if (x < 15) {
READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
} else {
- x += get_bitsz(&s->gb, linbits);
+ x += bitstream_read_32(&s->bc, linbits);
v = l3_unscale(x, exponent);
- if (get_bits1(&s->gb))
+ if (bitstream_read_bit(&s->bc))
v = -v;
g->sb_hybrid[s_index+!!y] = v;
}
@@ -922,13 +928,13 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
last_pos = 0;
while (s_index <= 572) {
int pos, code;
- pos = get_bits_count(&s->gb);
+ pos = bitstream_read_count(&s->bc);
if (pos >= end_pos) {
if (pos > end_pos2 && last_pos) {
/* some encoders generate an incorrect size for this
part. We must go back into the data */
s_index -= 4;
- skip_bits_long(&s->gb, last_pos - pos);
+ bitstream_skip(&s->bc, last_pos - pos);
av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
if(s->err_recognition & AV_EF_BITSTREAM)
s_index=0;
@@ -940,7 +946,7 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
}
last_pos = pos;
- code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
+ code = bitstream_read_vlc(&s->bc, vlc->table, vlc->bits, 1);
ff_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
g->sb_hybrid[s_index+0] =
g->sb_hybrid[s_index+1] =
@@ -956,7 +962,7 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
s_index += 4;
}
/* skip extension bits */
- bits_left = end_pos2 - get_bits_count(&s->gb);
+ bits_left = end_pos2 - bitstream_read_count(&s->bc);
if (bits_left < 0 && (s->err_recognition & AV_EF_BUFFER)) {
av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
s_index=0;
@@ -965,9 +971,9 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
s_index = 0;
}
memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
- skip_bits_long(&s->gb, bits_left);
+ bitstream_skip(&s->bc, bits_left);
- i = get_bits_count(&s->gb);
+ i = bitstream_read_count(&s->bc);
switch_buffer(s, &i, &end_pos, &end_pos2);
return 0;
@@ -1275,19 +1281,19 @@ static int mp_decode_layer3(MPADecodeContext *s)
/* read side info */
if (s->lsf) {
- main_data_begin = get_bits(&s->gb, 8);
- skip_bits(&s->gb, s->nb_channels);
+ main_data_begin = bitstream_read_32(&s->bc, 8);
+ bitstream_skip(&s->bc, s->nb_channels);
nb_granules = 1;
} else {
- main_data_begin = get_bits(&s->gb, 9);
+ main_data_begin = bitstream_read_32(&s->bc, 9);
if (s->nb_channels == 2)
- skip_bits(&s->gb, 3);
+ bitstream_skip(&s->bc, 3);
else
- skip_bits(&s->gb, 5);
+ bitstream_skip(&s->bc, 5);
nb_granules = 2;
for (ch = 0; ch < s->nb_channels; ch++) {
s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
- s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
+ s->granules[ch][1].scfsi = bitstream_read_32(&s->bc, 4);
}
}
@@ -1295,45 +1301,45 @@ static int mp_decode_layer3(MPADecodeContext *s)
for (ch = 0; ch < s->nb_channels; ch++) {
ff_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
g = &s->granules[ch][gr];
- g->part2_3_length = get_bits(&s->gb, 12);
- g->big_values = get_bits(&s->gb, 9);
+ g->part2_3_length = bitstream_read_32(&s->bc, 12);
+ g->big_values = bitstream_read_32(&s->bc, 9);
if (g->big_values > 288) {
av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
return AVERROR_INVALIDDATA;
}
- g->global_gain = get_bits(&s->gb, 8);
+ g->global_gain = bitstream_read_32(&s->bc, 8);
/* if MS stereo only is selected, we precompute the
1/sqrt(2) renormalization factor */
if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
MODE_EXT_MS_STEREO)
g->global_gain -= 2;
if (s->lsf)
- g->scalefac_compress = get_bits(&s->gb, 9);
+ g->scalefac_compress = bitstream_read_32(&s->bc, 9);
else
- g->scalefac_compress = get_bits(&s->gb, 4);
- blocksplit_flag = get_bits1(&s->gb);
+ g->scalefac_compress = bitstream_read_32(&s->bc, 4);
+ blocksplit_flag = bitstream_read_bit(&s->bc);
if (blocksplit_flag) {
- g->block_type = get_bits(&s->gb, 2);
+ g->block_type = bitstream_read_32(&s->bc, 2);
if (g->block_type == 0) {
av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
return AVERROR_INVALIDDATA;
}
- g->switch_point = get_bits1(&s->gb);
+ g->switch_point = bitstream_read_bit(&s->bc);
for (i = 0; i < 2; i++)
- g->table_select[i] = get_bits(&s->gb, 5);
+ g->table_select[i] = bitstream_read_32(&s->bc, 5);
for (i = 0; i < 3; i++)
- g->subblock_gain[i] = get_bits(&s->gb, 3);
+ g->subblock_gain[i] = bitstream_read_32(&s->bc, 3);
init_short_region(s, g);
} else {
int region_address1, region_address2;
g->block_type = 0;
g->switch_point = 0;
for (i = 0; i < 3; i++)
- g->table_select[i] = get_bits(&s->gb, 5);
+ g->table_select[i] = bitstream_read_32(&s->bc, 5);
/* compute huffman coded region sizes */
- region_address1 = get_bits(&s->gb, 4);
- region_address2 = get_bits(&s->gb, 3);
+ region_address1 = bitstream_read_32(&s->bc, 4);
+ region_address2 = bitstream_read_32(&s->bc, 3);
ff_dlog(s->avctx, "region1=%d region2=%d\n",
region_address1, region_address2);
init_long_region(s, g, region_address1, region_address2);
@@ -1343,9 +1349,9 @@ static int mp_decode_layer3(MPADecodeContext *s)
g->preflag = 0;
if (!s->lsf)
- g->preflag = get_bits1(&s->gb);
- g->scalefac_scale = get_bits1(&s->gb);
- g->count1table_select = get_bits1(&s->gb);
+ g->preflag = bitstream_read_bit(&s->bc);
+ g->scalefac_scale = bitstream_read_bit(&s->bc);
+ g->count1table_select = bitstream_read_bit(&s->bc);
ff_dlog(s->avctx, "block_type=%d switch_point=%d\n",
g->block_type, g->switch_point);
}
@@ -1353,20 +1359,17 @@ static int mp_decode_layer3(MPADecodeContext *s)
if (!s->adu_mode) {
int skip;
- const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
- int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0,
+ const uint8_t *ptr = s->bc.buffer + (bitstream_read_count(&s->bc) >> 3);
+ int extrasize = av_clip(bitstream_show_left(&s->bc) >> 3, 0,
FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
- assert((get_bits_count(&s->gb) & 7) == 0);
+ assert((bitstream_read_count(&s->bc) & 7) == 0);
/* now we get bits from the main_data_begin offset */
ff_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
main_data_begin, s->last_buf_size);
memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
- s->in_gb = s->gb;
- init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
-#if !UNCHECKED_BITSTREAM_READER
- s->gb.size_in_bits_plus8 += extrasize * 8;
-#endif
+ s->in_bc = s->bc;
+ bitstream_init(&s->bc, s->last_buf, s->last_buf_size * 8);
s->last_buf_size <<= 3;
for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
for (ch = 0; ch < s->nb_channels; ch++) {
@@ -1377,12 +1380,12 @@ static int mp_decode_layer3(MPADecodeContext *s)
}
}
skip = s->last_buf_size - 8 * main_data_begin;
- if (skip >= s->gb.size_in_bits && s->in_gb.buffer) {
- skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits);
- s->gb = s->in_gb;
- s->in_gb.buffer = NULL;
+ if (skip >= (bitstream_read_count(&s->bc) + bitstream_show_left(&s->bc)) && s->in_bc.buffer) {
+ bitstream_skip(&s->in_bc, skip - bitstream_read_count(&s->bc) - bitstream_show_left(&s->bc));
+ s->bc = s->in_bc;
+ s->in_bc.buffer = NULL;
} else {
- skip_bits_long(&s->gb, skip);
+ bitstream_skip(&s->bc, skip);
}
} else {
gr = 0;
@@ -1391,7 +1394,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
for (; gr < nb_granules; gr++) {
for (ch = 0; ch < s->nb_channels; ch++) {
g = &s->granules[ch][gr];
- bits_pos = get_bits_count(&s->gb);
+ bits_pos = bitstream_read_count(&s->bc);
if (!s->lsf) {
uint8_t *sc;
@@ -1406,14 +1409,14 @@ static int mp_decode_layer3(MPADecodeContext *s)
j = 0;
if (slen1) {
for (i = 0; i < n; i++)
- g->scale_factors[j++] = get_bits(&s->gb, slen1);
+ g->scale_factors[j++] = bitstream_read_32(&s->bc, slen1);
} else {
for (i = 0; i < n; i++)
g->scale_factors[j++] = 0;
}
if (slen2) {
for (i = 0; i < 18; i++)
- g->scale_factors[j++] = get_bits(&s->gb, slen2);
+ g->scale_factors[j++] = bitstream_read_32(&s->bc, slen2);
for (i = 0; i < 3; i++)
g->scale_factors[j++] = 0;
} else {
@@ -1429,7 +1432,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
slen = (k < 2) ? slen1 : slen2;
if (slen) {
for (i = 0; i < n; i++)
- g->scale_factors[j++] = get_bits(&s->gb, slen);
+ g->scale_factors[j++] = bitstream_read_32(&s->bc, slen);
} else {
for (i = 0; i < n; i++)
g->scale_factors[j++] = 0;
@@ -1488,7 +1491,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
sl = slen[k];
if (sl) {
for (i = 0; i < n; i++)
- g->scale_factors[j++] = get_bits(&s->gb, sl);
+ g->scale_factors[j++] = bitstream_read_32(&s->bc, sl);
} else {
for (i = 0; i < n; i++)
g->scale_factors[j++] = 0;
@@ -1516,8 +1519,8 @@ static int mp_decode_layer3(MPADecodeContext *s)
compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
}
} /* gr */
- if (get_bits_count(&s->gb) < 0)
- skip_bits_long(&s->gb, -get_bits_count(&s->gb));
+ if (bitstream_read_count(&s->bc) < 0)
+ bitstream_skip(&s->bc, -bitstream_read_count(&s->bc));
return nb_granules * 18;
}
@@ -1527,11 +1530,11 @@ static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
int i, nb_frames, ch, ret;
OUT_INT *samples_ptr;
- init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
+ bitstream_init(&s->bc, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
/* skip error protection field */
if (s->error_protection)
- skip_bits(&s->gb, 16);
+ bitstream_skip(&s->bc, 16);
switch(s->layer) {
case 1:
@@ -1551,21 +1554,21 @@ static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
return nb_frames;
s->last_buf_size=0;
- if (s->in_gb.buffer) {
- align_get_bits(&s->gb);
- i = get_bits_left(&s->gb)>>3;
+ if (s->in_bc.buffer) {
+ bitstream_align(&s->bc);
+ i = bitstream_show_left(&s->bc) >> 3;
if (i >= 0 && i <= BACKSTEP_SIZE) {
- memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
+ memmove(s->last_buf, s->bc.buffer + (bitstream_read_count(&s->bc) >> 3), i);
s->last_buf_size=i;
} else
av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
- s->gb = s->in_gb;
- s->in_gb.buffer = NULL;
+ s->bc = s->in_bc;
+ s->in_bc.buffer = NULL;
}
- align_get_bits(&s->gb);
- assert((get_bits_count(&s->gb) & 7) == 0);
- i = get_bits_left(&s->gb) >> 3;
+ bitstream_align(&s->bc);
+ assert((bitstream_read_count(&s->bc) & 7) == 0);
+ i = bitstream_show_left(&s->bc) >> 3;
if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
if (i < 0)
@@ -1573,7 +1576,7 @@ static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
}
assert(i <= buf_size - HEADER_SIZE && i >= 0);
- memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
+ memcpy(s->last_buf + s->last_buf_size, s->bc.buffer + buf_size - HEADER_SIZE - i, i);
s->last_buf_size += i;
}
diff --git a/libavcodec/xsubdec.c b/libavcodec/xsubdec.c
index 7e25787..50acb84 100644
--- a/libavcodec/xsubdec.c
+++ b/libavcodec/xsubdec.c
@@ -55,7 +55,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
uint8_t *bitmap;
int w, h, x, y, i;
int64_t packet_time = 0;
- GetBitContext gb;
+ BitstreamContext bc;
int has_alpha = avctx->codec_tag == MKTAG('D','X','S','A');
AVSubtitleRect *rect;
int j;
@@ -144,15 +144,15 @@ FF_ENABLE_DEPRECATION_WARNINGS
#endif
// process RLE-compressed data
- init_get_bits(&gb, buf, (buf_end - buf) * 8);
+ bitstream_init(&bc, buf, (buf_end - buf) * 8);
bitmap = sub->rects[0]->data[0];
for (y = 0; y < h; y++) {
// interlaced: do odd lines
if (y == (h + 1) / 2) bitmap = sub->rects[0]->data[0] + w;
for (x = 0; x < w; ) {
- int log2 = ff_log2_tab[show_bits(&gb, 8)];
- int run = get_bits(&gb, 14 - 4 * (log2 >> 1));
- int color = get_bits(&gb, 2);
+ int log2 = ff_log2_tab[bitstream_show_32(&bc, 8)];
+ int run = bitstream_read_32(&bc, 14 - 4 * (log2 >> 1));
+ int color = bitstream_read_32(&bc, 2);
run = FFMIN(run, w - x);
// run length 0 means till end of row
if (!run) run = w - x;
@@ -162,7 +162,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
}
// interlaced, skip every second line
bitmap += w;
- align_get_bits(&gb);
+ bitstream_align(&bc);
}
*data_size = 1;
return buf_size;
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment