har0ke/FFmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use get_bits1(..) instead get_bits(.., 1)

Browse Source 
Originally committed as revision 9999 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Alex Beregszaszi 2007-08-09 00:13:31 +00:00
parent b6c748edba
commit 5fc32c275e
16 changed files with 103 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libavcodec/alac.c
View File

@ -489,12 +489,12 @@ static int alac_decode_frame(AVCodecContext *avctx,
get_bits(&alac->gb, 12); /* unknown, skip 12 bits */ get_bits(&alac->gb, 12); /* unknown, skip 12 bits */
/* the output sample size is stored soon */ /* the output sample size is stored soon */
hassize = get_bits(&alac->gb, 1); hassize = get_bits1(&alac->gb);
wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */ wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */
/* whether the frame is compressed */ /* whether the frame is compressed */
isnotcompressed = get_bits(&alac->gb, 1); isnotcompressed = get_bits1(&alac->gb);
if (hassize) { if (hassize) {
/* now read the number of samples as a 32bit integer */ /* now read the number of samples as a 32bit integer */

4
libavcodec/atrac3.c
View File

@ -363,7 +363,7 @@ static int decodeSpectrum (GetBitContext *gb, float *pOut)
float SF; float SF;
numSubbands = get_bits(gb, 5); // number of coded subbands numSubbands = get_bits(gb, 5); // number of coded subbands
codingMode = get_bits(gb, 1); // coding Mode: 0 - VLC/ 1-CLC codingMode = get_bits1(gb); // coding Mode: 0 - VLC/ 1-CLC
/* Get the VLC selector table for the subbands, 0 means not coded. */ /* Get the VLC selector table for the subbands, 0 means not coded. */
for (cnt = 0; cnt <= numSubbands; cnt++) for (cnt = 0; cnt <= numSubbands; cnt++)
@ -811,7 +811,7 @@ static int decodeFrame(ATRAC3Context *q, uint8_t* databuf)
/* Fill the Weighting coeffs delay buffer */ /* Fill the Weighting coeffs delay buffer */
memmove(q->weighting_delay,&(q->weighting_delay[2]),4*sizeof(int)); memmove(q->weighting_delay,&(q->weighting_delay[2]),4*sizeof(int));
q->weighting_delay[4] = get_bits(&q->gb,1); q->weighting_delay[4] = get_bits1(&q->gb);
q->weighting_delay[5] = get_bits(&q->gb,3); q->weighting_delay[5] = get_bits(&q->gb,3);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {

8
libavcodec/dvbsubdec.c
View File

@ -455,7 +455,7 @@ static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
} }
pixels_read++; pixels_read++;
} else { } else {
bits = get_bits(&gb, 1); bits = get_bits1(&gb);
if (bits == 1) { if (bits == 1) {
run_length = get_bits(&gb, 3) + 3; run_length = get_bits(&gb, 3) + 3;
bits = get_bits(&gb, 2); bits = get_bits(&gb, 2);
@ -471,7 +471,7 @@ static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
} }
} }
} else { } else {
bits = get_bits(&gb, 1); bits = get_bits1(&gb);
if (bits == 0) { if (bits == 0) {
bits = get_bits(&gb, 2); bits = get_bits(&gb, 2);
if (bits == 2) { if (bits == 2) {
@ -560,7 +560,7 @@ static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
} }
pixels_read++; pixels_read++;
} else { } else {
bits = get_bits(&gb, 1); bits = get_bits1(&gb);
if (bits == 0) { if (bits == 0) {
run_length = get_bits(&gb, 3); run_length = get_bits(&gb, 3);
@ -581,7 +581,7 @@ static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
pixels_read++; pixels_read++;
} }
} else { } else {
bits = get_bits(&gb, 1); bits = get_bits1(&gb);
if (bits == 0) { if (bits == 0) {
run_length = get_bits(&gb, 2) + 4; run_length = get_bits(&gb, 2) + 4;
bits = get_bits(&gb, 4); bits = get_bits(&gb, 4);

2
libavcodec/flac.c
View File

@ -183,7 +183,7 @@ static int metadata_parse(FLACContext *s)
av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n"); av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
do { do {
metadata_last = get_bits(&s->gb, 1); metadata_last = get_bits1(&s->gb);
metadata_type = get_bits(&s->gb, 7); metadata_type = get_bits(&s->gb, 7);
metadata_size = get_bits_long(&s->gb, 24); metadata_size = get_bits_long(&s->gb, 24);

2
libavcodec/h263.c
View File

@ -5077,7 +5077,7 @@ int h263_decode_picture_header(MpegEncContext *s)
format = get_bits(&s->gb, 3); format = get_bits(&s->gb, 3);
dprintf(s->avctx, "ufep=1, format: %d\n", format); dprintf(s->avctx, "ufep=1, format: %d\n", format);
s->custom_pcf= get_bits1(&s->gb); s->custom_pcf= get_bits1(&s->gb);
s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
if (get_bits1(&s->gb) != 0) { if (get_bits1(&s->gb) != 0) {
av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
} }

4
libavcodec/imc.c
View File

@ -454,7 +454,7 @@ static void imc_get_skip_coeff(IMCContext* q) {
q->skipFlagBits[i] = band_tab[i+1] - band_tab[i]; q->skipFlagBits[i] = band_tab[i+1] - band_tab[i];
for(j = band_tab[i]; j < band_tab[i+1]; j++) { for(j = band_tab[i]; j < band_tab[i+1]; j++) {
if ((q->skipFlags[j] = get_bits(&q->gb,1))) if ((q->skipFlags[j] = get_bits1(&q->gb)))
q->skipFlagCount[i]++; q->skipFlagCount[i]++;
} }
} else { } else {
@ -485,7 +485,7 @@ static void imc_get_skip_coeff(IMCContext* q) {
if (j < band_tab[i+1]) { if (j < band_tab[i+1]) {
q->skipFlagBits[i]++; q->skipFlagBits[i]++;
if ((q->skipFlags[j] = get_bits(&q->gb,1))) if ((q->skipFlags[j] = get_bits1(&q->gb)))
q->skipFlagCount[i]++; q->skipFlagCount[i]++;
} }
} }

10
libavcodec/mpegaudiodec.c
View File

@ -2002,14 +2002,14 @@ static int mp_decode_layer3(MPADecodeContext *s)
g->scalefac_compress = get_bits(&s->gb, 9); g->scalefac_compress = get_bits(&s->gb, 9);
else else
g->scalefac_compress = get_bits(&s->gb, 4); g->scalefac_compress = get_bits(&s->gb, 4);
blocksplit_flag = get_bits(&s->gb, 1); blocksplit_flag = get_bits1(&s->gb);
if (blocksplit_flag) { if (blocksplit_flag) {
g->block_type = get_bits(&s->gb, 2); g->block_type = get_bits(&s->gb, 2);
if (g->block_type == 0){ if (g->block_type == 0){
av_log(NULL, AV_LOG_ERROR, "invalid block type\n"); av_log(NULL, AV_LOG_ERROR, "invalid block type\n");
return -1; return -1;
} }
g->switch_point = get_bits(&s->gb, 1); g->switch_point = get_bits1(&s->gb);
for(i=0;i<2;i++) for(i=0;i<2;i++)
g->table_select[i] = get_bits(&s->gb, 5); g->table_select[i] = get_bits(&s->gb, 5);
for(i=0;i<3;i++) for(i=0;i<3;i++)
@ -2081,9 +2081,9 @@ static int mp_decode_layer3(MPADecodeContext *s)
g->preflag = 0; g->preflag = 0;
if (!s->lsf) if (!s->lsf)
g->preflag = get_bits(&s->gb, 1); g->preflag = get_bits1(&s->gb);
g->scalefac_scale = get_bits(&s->gb, 1); g->scalefac_scale = get_bits1(&s->gb);
g->count1table_select = get_bits(&s->gb, 1); g->count1table_select = get_bits1(&s->gb);
dprintf(s->avctx, "block_type=%d switch_point=%d\n", dprintf(s->avctx, "block_type=%d switch_point=%d\n",
g->block_type, g->switch_point); g->block_type, g->switch_point);
} }

14
libavcodec/rv10.c
View File

@ -195,7 +195,7 @@ int rv_decode_dc(MpegEncContext *s, int n)
} else if (code == 0x7d) { } else if (code == 0x7d) {
code = -128 + get_bits(&s->gb, 7); code = -128 + get_bits(&s->gb, 7);
} else if (code == 0x7e) { } else if (code == 0x7e) {
if (get_bits(&s->gb, 1) == 0) if (get_bits1(&s->gb) == 0)
code = (int8_t)(get_bits(&s->gb, 8) + 1); code = (int8_t)(get_bits(&s->gb, 8) + 1);
else else
code = (int8_t)(get_bits(&s->gb, 8)); code = (int8_t)(get_bits(&s->gb, 8));
@ -312,15 +312,15 @@ static int rv10_decode_picture_header(MpegEncContext *s)
int mb_count, pb_frame, marker, unk, mb_xy; int mb_count, pb_frame, marker, unk, mb_xy;
//printf("ff:%d\n", full_frame); //printf("ff:%d\n", full_frame);
marker = get_bits(&s->gb, 1); marker = get_bits1(&s->gb);
if (get_bits(&s->gb, 1)) if (get_bits1(&s->gb))
s->pict_type = P_TYPE; s->pict_type = P_TYPE;
else else
s->pict_type = I_TYPE; s->pict_type = I_TYPE;
//printf("h:%X ver:%d\n",h,s->rv10_version); //printf("h:%X ver:%d\n",h,s->rv10_version);
if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n"); if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
pb_frame = get_bits(&s->gb, 1); pb_frame = get_bits1(&s->gb);
#ifdef DEBUG #ifdef DEBUG
av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame); av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
@ -416,7 +416,7 @@ static int rv20_decode_picture_header(MpegEncContext *s)
return -1; return -1;
} }
if (get_bits(&s->gb, 1)){ if (get_bits1(&s->gb)){
av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n"); av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
return -1; return -1;
} }
@ -427,7 +427,7 @@ static int rv20_decode_picture_header(MpegEncContext *s)
return -1; return -1;
} }
if(s->avctx->sub_id == 0x30203002){ if(s->avctx->sub_id == 0x30203002){
if (get_bits(&s->gb, 1)){ if (get_bits1(&s->gb)){
av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n"); av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
return -1; return -1;
} }
@ -437,7 +437,7 @@ static int rv20_decode_picture_header(MpegEncContext *s)
int f, new_w, new_h; int f, new_w, new_h;
int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0; int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
if (get_bits(&s->gb, 1)){ if (get_bits1(&s->gb)){
av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n"); av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
// return -1; // return -1;
} }

6
libavcodec/smacker.c
View File

@ -290,7 +290,7 @@ static int decode_header_trees(SmackVContext *smk) {
} else { } else {
smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size); smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
} }
if(!get_bits(&gb, 1)) { if(!get_bits1(&gb)) {
av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n"); av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
smk->mclr_tbl = av_malloc(sizeof(int) * 2); smk->mclr_tbl = av_malloc(sizeof(int) * 2);
smk->mclr_tbl[0] = 0; smk->mclr_tbl[0] = 0;
@ -298,7 +298,7 @@ static int decode_header_trees(SmackVContext *smk) {
} else { } else {
smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size); smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
} }
if(!get_bits(&gb, 1)) { if(!get_bits1(&gb)) {
av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n"); av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
smk->full_tbl = av_malloc(sizeof(int) * 2); smk->full_tbl = av_malloc(sizeof(int) * 2);
smk->full_tbl[0] = 0; smk->full_tbl[0] = 0;
@ -306,7 +306,7 @@ static int decode_header_trees(SmackVContext *smk) {
} else { } else {
smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size); smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
} }
if(!get_bits(&gb, 1)) { if(!get_bits1(&gb)) {
av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n"); av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
smk->type_tbl = av_malloc(sizeof(int) * 2); smk->type_tbl = av_malloc(sizeof(int) * 2);
smk->type_tbl[0] = 0; smk->type_tbl[0] = 0;

8
libavcodec/svq1dec.c
View File

@ -137,7 +137,7 @@ static const uint8_t string_table[256] = {
break;\ break;\
}\ }\
/* divide block if next bit set */\ /* divide block if next bit set */\
if (get_bits (bitbuf, 1) == 0)\ if (get_bits1 (bitbuf) == 0)\
break;\ break;\
/* add child nodes */\ /* add child nodes */\
list[n++] = list[i];\ list[n++] = list[i];\
@ -617,7 +617,7 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
} }
/* unknown fields */ /* unknown fields */
if (get_bits (bitbuf, 1) == 1) { if (get_bits1 (bitbuf) == 1) {
skip_bits1 (bitbuf); /* use packet checksum if (1) */ skip_bits1 (bitbuf); /* use packet checksum if (1) */
skip_bits1 (bitbuf); /* component checksums after image data if (1) */ skip_bits1 (bitbuf); /* component checksums after image data if (1) */
@ -625,13 +625,13 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
return -1; return -1;
} }
if (get_bits (bitbuf, 1) == 1) { if (get_bits1 (bitbuf) == 1) {
skip_bits1 (bitbuf); skip_bits1 (bitbuf);
skip_bits (bitbuf, 4); skip_bits (bitbuf, 4);
skip_bits1 (bitbuf); skip_bits1 (bitbuf);
skip_bits (bitbuf, 2); skip_bits (bitbuf, 2);
while (get_bits (bitbuf, 1) == 1) { while (get_bits1 (bitbuf) == 1) {
skip_bits (bitbuf, 8); skip_bits (bitbuf, 8);
} }
} }

4
libavcodec/svq3.c
View File

@ -465,9 +465,9 @@ static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
mb_type = MB_TYPE_16x16; mb_type = MB_TYPE_16x16;
} }
} else if (mb_type < 8) { /* INTER */ } else if (mb_type < 8) { /* INTER */
if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) { if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
mode = THIRDPEL_MODE; mode = THIRDPEL_MODE;
} else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) { } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
mode = HALFPEL_MODE; mode = HALFPEL_MODE;
} else { } else {
mode = FULLPEL_MODE; mode = FULLPEL_MODE;

110
libavcodec/vc1.c
View File

@ -149,11 +149,11 @@ static void decode_rowskip(uint8_t* plane, int width, int height, int stride, Ge
int x, y; int x, y;
for (y=0; y<height; y++){ for (y=0; y<height; y++){
if (!get_bits(gb, 1)) //rowskip if (!get_bits1(gb)) //rowskip
memset(plane, 0, width); memset(plane, 0, width);
else else
for (x=0; x<width; x++) for (x=0; x<width; x++)
plane[x] = get_bits(gb, 1); plane[x] = get_bits1(gb);
plane += stride; plane += stride;
} }
} }
@ -169,12 +169,12 @@ static void decode_colskip(uint8_t* plane, int width, int height, int stride, Ge
int x, y; int x, y;
for (x=0; x<width; x++){ for (x=0; x<width; x++){
if (!get_bits(gb, 1)) //colskip if (!get_bits1(gb)) //colskip
for (y=0; y<height; y++) for (y=0; y<height; y++)
plane[y*stride] = 0; plane[y*stride] = 0;
else else
for (y=0; y<height; y++) for (y=0; y<height; y++)
plane[y*stride] = get_bits(gb, 1); plane[y*stride] = get_bits1(gb);
plane ++; plane ++;
} }
} }
@ -196,7 +196,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
width = v->s.mb_width; width = v->s.mb_width;
height = v->s.mb_height; height = v->s.mb_height;
stride = v->s.mb_stride; stride = v->s.mb_stride;
invert = get_bits(gb, 1); invert = get_bits1(gb);
imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1); imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
*raw_flag = 0; *raw_flag = 0;
@ -210,7 +210,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
case IMODE_NORM2: case IMODE_NORM2:
if ((height * width) & 1) if ((height * width) & 1)
{ {
*planep++ = get_bits(gb, 1); *planep++ = get_bits1(gb);
offset = 1; offset = 1;
} }
else offset = 0; else offset = 0;
@ -329,7 +329,7 @@ static int vop_dquant_decoding(VC1Context *v)
} }
else else
{ {
v->dquantfrm = get_bits(gb, 1); v->dquantfrm = get_bits1(gb);
if ( v->dquantfrm ) if ( v->dquantfrm )
{ {
v->dqprofile = get_bits(gb, 2); v->dqprofile = get_bits(gb, 2);
@ -340,7 +340,7 @@ static int vop_dquant_decoding(VC1Context *v)
v->dqsbedge = get_bits(gb, 2); v->dqsbedge = get_bits(gb, 2);
break; break;
case DQPROFILE_ALL_MBS: case DQPROFILE_ALL_MBS:
v->dqbilevel = get_bits(gb, 1); v->dqbilevel = get_bits1(gb);
default: break; //Forbidden ? default: break; //Forbidden ?
} }
if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
@ -797,22 +797,22 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
v->frmrtq_postproc = get_bits(gb, 3); //common v->frmrtq_postproc = get_bits(gb, 3); //common
// (bitrate-32kbps)/64kbps // (bitrate-32kbps)/64kbps
v->bitrtq_postproc = get_bits(gb, 5); //common v->bitrtq_postproc = get_bits(gb, 5); //common
v->s.loop_filter = get_bits(gb, 1); //common v->s.loop_filter = get_bits1(gb); //common
if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
{ {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"LOOPFILTER shell not be enabled in simple profile\n"); "LOOPFILTER shell not be enabled in simple profile\n");
} }
v->res_x8 = get_bits(gb, 1); //reserved v->res_x8 = get_bits1(gb); //reserved
if (v->res_x8) if (v->res_x8)
{ {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"1 for reserved RES_X8 is forbidden\n"); "1 for reserved RES_X8 is forbidden\n");
//return -1; //return -1;
} }
v->multires = get_bits(gb, 1); v->multires = get_bits1(gb);
v->res_fasttx = get_bits(gb, 1); v->res_fasttx = get_bits1(gb);
if (!v->res_fasttx) if (!v->res_fasttx)
{ {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
@ -820,14 +820,14 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
//return -1; //return -1;
} }
v->fastuvmc = get_bits(gb, 1); //common v->fastuvmc = get_bits1(gb); //common
if (!v->profile && !v->fastuvmc) if (!v->profile && !v->fastuvmc)
{ {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"FASTUVMC unavailable in Simple Profile\n"); "FASTUVMC unavailable in Simple Profile\n");
return -1; return -1;
} }
v->extended_mv = get_bits(gb, 1); //common v->extended_mv = get_bits1(gb); //common
if (!v->profile && v->extended_mv) if (!v->profile && v->extended_mv)
{ {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
@ -835,9 +835,9 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
return -1; return -1;
} }
v->dquant = get_bits(gb, 2); //common v->dquant = get_bits(gb, 2); //common
v->vstransform = get_bits(gb, 1); //common v->vstransform = get_bits1(gb); //common
v->res_transtab = get_bits(gb, 1); v->res_transtab = get_bits1(gb);
if (v->res_transtab) if (v->res_transtab)
{ {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
@ -845,10 +845,10 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
return -1; return -1;
} }
v->overlap = get_bits(gb, 1); //common v->overlap = get_bits1(gb); //common
v->s.resync_marker = get_bits(gb, 1); v->s.resync_marker = get_bits1(gb);
v->rangered = get_bits(gb, 1); v->rangered = get_bits1(gb);
if (v->rangered && v->profile == PROFILE_SIMPLE) if (v->rangered && v->profile == PROFILE_SIMPLE)
{ {
av_log(avctx, AV_LOG_INFO, av_log(avctx, AV_LOG_INFO,
@ -858,8 +858,8 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
v->quantizer_mode = get_bits(gb, 2); //common v->quantizer_mode = get_bits(gb, 2); //common
v->finterpflag = get_bits(gb, 1); //common v->finterpflag = get_bits1(gb); //common
v->res_rtm_flag = get_bits(gb, 1); //reserved v->res_rtm_flag = get_bits1(gb); //reserved
if (!v->res_rtm_flag) if (!v->res_rtm_flag)
{ {
// av_log(avctx, AV_LOG_ERROR, // av_log(avctx, AV_LOG_ERROR,
@ -903,7 +903,7 @@ static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
v->frmrtq_postproc = get_bits(gb, 3); //common v->frmrtq_postproc = get_bits(gb, 3); //common
// (bitrate-32kbps)/64kbps // (bitrate-32kbps)/64kbps
v->bitrtq_postproc = get_bits(gb, 5); //common v->bitrtq_postproc = get_bits(gb, 5); //common
v->postprocflag = get_bits(gb, 1); //common v->postprocflag = get_bits1(gb); //common
v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1; v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1; v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
@ -1038,14 +1038,14 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
{ {
int pqindex, lowquant, status; int pqindex, lowquant, status;
if(v->finterpflag) v->interpfrm = get_bits(gb, 1); if(v->finterpflag) v->interpfrm = get_bits1(gb);
skip_bits(gb, 2); //framecnt unused skip_bits(gb, 2); //framecnt unused
v->rangeredfrm = 0; v->rangeredfrm = 0;
if (v->rangered) v->rangeredfrm = get_bits(gb, 1); if (v->rangered) v->rangeredfrm = get_bits1(gb);
v->s.pict_type = get_bits(gb, 1); v->s.pict_type = get_bits1(gb);
if (v->s.avctx->max_b_frames) { if (v->s.avctx->max_b_frames) {
if (!v->s.pict_type) { if (!v->s.pict_type) {
if (get_bits(gb, 1)) v->s.pict_type = I_TYPE; if (get_bits1(gb)) v->s.pict_type = I_TYPE;
else v->s.pict_type = B_TYPE; else v->s.pict_type = B_TYPE;
} else v->s.pict_type = P_TYPE; } else v->s.pict_type = P_TYPE;
} else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE; } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
@ -1080,10 +1080,10 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
if (v->quantizer_mode == QUANT_NON_UNIFORM) if (v->quantizer_mode == QUANT_NON_UNIFORM)
v->pquantizer = 0; v->pquantizer = 0;
v->pqindex = pqindex; v->pqindex = pqindex;
if (pqindex < 9) v->halfpq = get_bits(gb, 1); if (pqindex < 9) v->halfpq = get_bits1(gb);
else v->halfpq = 0; else v->halfpq = 0;
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT) if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
v->pquantizer = get_bits(gb, 1); v->pquantizer = get_bits1(gb);
v->dquantfrm = 0; v->dquantfrm = 0;
if (v->extended_mv == 1) v->mvrange = get_unary(gb, 0, 3); if (v->extended_mv == 1) v->mvrange = get_unary(gb, 0, 3);
v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
@ -1092,7 +1092,7 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
v->range_y = 1 << (v->k_y - 1); v->range_y = 1 << (v->k_y - 1);
if (v->profile == PROFILE_ADVANCED) if (v->profile == PROFILE_ADVANCED)
{ {
if (v->postprocflag) v->postproc = get_bits(gb, 1); if (v->postprocflag) v->postproc = get_bits1(gb);
} }
else else
if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2); if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
@ -1179,7 +1179,7 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
v->ttfrm = 0; //FIXME Is that so ? v->ttfrm = 0; //FIXME Is that so ?
if (v->vstransform) if (v->vstransform)
{ {
v->ttmbf = get_bits(gb, 1); v->ttmbf = get_bits1(gb);
if (v->ttmbf) if (v->ttmbf)
{ {
v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
@ -1220,7 +1220,7 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
v->ttfrm = 0; v->ttfrm = 0;
if (v->vstransform) if (v->vstransform)
{ {
v->ttmbf = get_bits(gb, 1); v->ttmbf = get_bits1(gb);
if (v->ttmbf) if (v->ttmbf)
{ {
v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
@ -1239,7 +1239,7 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
v->y_ac_table_index = decode012(gb); v->y_ac_table_index = decode012(gb);
} }
/* DC Syntax */ /* DC Syntax */
v->s.dc_table_index = get_bits(gb, 1); v->s.dc_table_index = get_bits1(gb);
if(v->s.pict_type == BI_TYPE) { if(v->s.pict_type == BI_TYPE) {
v->s.pict_type = B_TYPE; v->s.pict_type = B_TYPE;
@ -1293,7 +1293,7 @@ static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
v->rnd = get_bits1(gb); v->rnd = get_bits1(gb);
if(v->interlace) if(v->interlace)
v->uvsamp = get_bits1(gb); v->uvsamp = get_bits1(gb);
if(v->finterpflag) v->interpfrm = get_bits(gb, 1); if(v->finterpflag) v->interpfrm = get_bits1(gb);
if(v->s.pict_type == B_TYPE) { if(v->s.pict_type == B_TYPE) {
v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1); v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
v->bfraction = ff_vc1_bfraction_lut[v->bfraction]; v->bfraction = ff_vc1_bfraction_lut[v->bfraction];
@ -1314,10 +1314,10 @@ static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
if (v->quantizer_mode == QUANT_NON_UNIFORM) if (v->quantizer_mode == QUANT_NON_UNIFORM)
v->pquantizer = 0; v->pquantizer = 0;
v->pqindex = pqindex; v->pqindex = pqindex;
if (pqindex < 9) v->halfpq = get_bits(gb, 1); if (pqindex < 9) v->halfpq = get_bits1(gb);
else v->halfpq = 0; else v->halfpq = 0;
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT) if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
v->pquantizer = get_bits(gb, 1); v->pquantizer = get_bits1(gb);
if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0; if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
@ -1420,7 +1420,7 @@ static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
v->ttfrm = 0; //FIXME Is that so ? v->ttfrm = 0; //FIXME Is that so ?
if (v->vstransform) if (v->vstransform)
{ {
v->ttmbf = get_bits(gb, 1); v->ttmbf = get_bits1(gb);
if (v->ttmbf) if (v->ttmbf)
{ {
v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
@ -1470,7 +1470,7 @@ static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
v->ttfrm = 0; v->ttfrm = 0;
if (v->vstransform) if (v->vstransform)
{ {
v->ttmbf = get_bits(gb, 1); v->ttmbf = get_bits1(gb);
if (v->ttmbf) if (v->ttmbf)
{ {
v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
@ -1489,7 +1489,7 @@ static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
v->y_ac_table_index = decode012(gb); v->y_ac_table_index = decode012(gb);
} }
/* DC Syntax */ /* DC Syntax */
v->s.dc_table_index = get_bits(gb, 1); v->s.dc_table_index = get_bits1(gb);
if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) { if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n"); av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
vop_dquant_decoding(v); vop_dquant_decoding(v);
@ -1522,7 +1522,7 @@ static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
{ \ { \
if (v->dqbilevel) \ if (v->dqbilevel) \
{ \ { \
mquant = (get_bits(gb, 1)) ? v->altpq : v->pq; \ mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
} \ } \
else \ else \
{ \ { \
@ -2273,7 +2273,7 @@ static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value,
run = vc1_index_decode_table[codingset][index][0]; run = vc1_index_decode_table[codingset][index][0];
level = vc1_index_decode_table[codingset][index][1]; level = vc1_index_decode_table[codingset][index][1];
lst = index >= vc1_last_decode_table[codingset]; lst = index >= vc1_last_decode_table[codingset];
if(get_bits(gb, 1)) if(get_bits1(gb))
level = -level; level = -level;
} else { } else {
escape = decode210(gb); escape = decode210(gb);
@ -2293,11 +2293,11 @@ static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value,
else else
run += vc1_delta_run_table[codingset][level] + 1; run += vc1_delta_run_table[codingset][level] + 1;
} }
if(get_bits(gb, 1)) if(get_bits1(gb))
level = -level; level = -level;
} else { } else {
int sign; int sign;
lst = get_bits(gb, 1); lst = get_bits1(gb);
if(v->s.esc3_level_length == 0) { if(v->s.esc3_level_length == 0) {
if(v->pq < 8 || v->dquantfrm) { // table 59 if(v->pq < 8 || v->dquantfrm) { // table 59
v->s.esc3_level_length = get_bits(gb, 3); v->s.esc3_level_length = get_bits(gb, 3);
@ -2309,7 +2309,7 @@ static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value,
v->s.esc3_run_length = 3 + get_bits(gb, 2); v->s.esc3_run_length = 3 + get_bits(gb, 2);
} }
run = get_bits(gb, v->s.esc3_run_length); run = get_bits(gb, v->s.esc3_run_length);
sign = get_bits(gb, 1); sign = get_bits1(gb);
level = get_bits(gb, v->s.esc3_level_length); level = get_bits(gb, v->s.esc3_level_length);
if(sign) if(sign)
level = -level; level = -level;
@ -2361,9 +2361,9 @@ static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded
if (v->pq == 1) if (v->pq == 1)
dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3; dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
else if (v->pq == 2) else if (v->pq == 2)
dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1; dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
} }
if (get_bits(gb, 1)) if (get_bits1(gb))
dcdiff = -dcdiff; dcdiff = -dcdiff;
} }
@ -2531,9 +2531,9 @@ static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int c
if (mquant == 1) if (mquant == 1)
dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3; dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
else if (mquant == 2) else if (mquant == 2)
dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1; dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
} }
if (get_bits(gb, 1)) if (get_bits1(gb))
dcdiff = -dcdiff; dcdiff = -dcdiff;
} }
@ -2735,9 +2735,9 @@ static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int c
if (mquant == 1) if (mquant == 1)
dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3; dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
else if (mquant == 2) else if (mquant == 2)
dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1; dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
} }
if (get_bits(gb, 1)) if (get_bits1(gb))
dcdiff = -dcdiff; dcdiff = -dcdiff;
} }
@ -3054,12 +3054,12 @@ static int vc1_decode_p_mb(VC1Context *v)
if (s->mb_intra && !mb_has_coeffs) if (s->mb_intra && !mb_has_coeffs)
{ {
GET_MQUANT(); GET_MQUANT();
s->ac_pred = get_bits(gb, 1); s->ac_pred = get_bits1(gb);
cbp = 0; cbp = 0;
} }
else if (mb_has_coeffs) else if (mb_has_coeffs)
{ {
if (s->mb_intra) s->ac_pred = get_bits(gb, 1); if (s->mb_intra) s->ac_pred = get_bits1(gb);
cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2); cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT(); GET_MQUANT();
} }
@ -3176,7 +3176,7 @@ static int vc1_decode_p_mb(VC1Context *v)
break; break;
} }
} }
if(intrapred)s->ac_pred = get_bits(gb, 1); if(intrapred)s->ac_pred = get_bits1(gb);
else s->ac_pred = 0; else s->ac_pred = 0;
} }
if (!v->ttmbf && coded_inter) if (!v->ttmbf && coded_inter)
@ -3449,7 +3449,7 @@ static void vc1_decode_i_blocks(VC1Context *v)
// do actual MB decoding and displaying // do actual MB decoding and displaying
cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
v->s.ac_pred = get_bits(&v->s.gb, 1); v->s.ac_pred = get_bits1(&v->s.gb);
for(k = 0; k < 6; k++) { for(k = 0; k < 6; k++) {
val = ((cbp >> (5 - k)) & 1); val = ((cbp >> (5 - k)) & 1);
@ -3561,13 +3561,13 @@ static void vc1_decode_i_blocks_adv(VC1Context *v)
// do actual MB decoding and displaying // do actual MB decoding and displaying
cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
if(v->acpred_is_raw) if(v->acpred_is_raw)
v->s.ac_pred = get_bits(&v->s.gb, 1); v->s.ac_pred = get_bits1(&v->s.gb);
else else
v->s.ac_pred = v->acpred_plane[mb_pos]; v->s.ac_pred = v->acpred_plane[mb_pos];
if(v->condover == CONDOVER_SELECT) { if(v->condover == CONDOVER_SELECT) {
if(v->overflg_is_raw) if(v->overflg_is_raw)
overlap = get_bits(&v->s.gb, 1); overlap = get_bits1(&v->s.gb);
else else
overlap = v->over_flags_plane[mb_pos]; overlap = v->over_flags_plane[mb_pos];
} else } else

2
libavcodec/vorbis_dec.c
View File

@ -791,7 +791,7 @@ static int vorbis_parse_setup_hdr_modes(vorbis_context *vc) {
for(i=0;i<vc->mode_count;++i) { for(i=0;i<vc->mode_count;++i) {
vorbis_mode *mode_setup=&vc->modes[i]; vorbis_mode *mode_setup=&vc->modes[i];
mode_setup->blockflag=get_bits(gb, 1); mode_setup->blockflag=get_bits1(gb);
mode_setup->windowtype=get_bits(gb, 16); //FIXME check mode_setup->windowtype=get_bits(gb, 16); //FIXME check
mode_setup->transformtype=get_bits(gb, 16); //FIXME check mode_setup->transformtype=get_bits(gb, 16); //FIXME check
mode_setup->mapping=get_bits(gb, 8); //FIXME check mode_setup->mapping=get_bits(gb, 8); //FIXME check

16
libavcodec/vp3.c
View File

@ -686,7 +686,7 @@ static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
} else { } else {
/* unpack the list of partially-coded superblocks */ /* unpack the list of partially-coded superblocks */
bit = get_bits(gb, 1); bit = get_bits1(gb);
/* toggle the bit because as soon as the first run length is /* toggle the bit because as soon as the first run length is
* fetched the bit will be toggled again */ * fetched the bit will be toggled again */
bit ^= 1; bit ^= 1;
@ -722,7 +722,7 @@ static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
current_superblock = 0; current_superblock = 0;
current_run = 0; current_run = 0;
bit = get_bits(gb, 1); bit = get_bits1(gb);
/* toggle the bit because as soon as the first run length is /* toggle the bit because as soon as the first run length is
* fetched the bit will be toggled again */ * fetched the bit will be toggled again */
bit ^= 1; bit ^= 1;
@ -753,7 +753,7 @@ static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
if (decode_partial_blocks) { if (decode_partial_blocks) {
current_run = 0; current_run = 0;
bit = get_bits(gb, 1); bit = get_bits1(gb);
/* toggle the bit because as soon as the first run length is /* toggle the bit because as soon as the first run length is
* fetched the bit will be toggled again */ * fetched the bit will be toggled again */
bit ^= 1; bit ^= 1;
@ -979,7 +979,7 @@ static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
memset(motion_y, 0, 6 * sizeof(int)); memset(motion_y, 0, 6 * sizeof(int));
/* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */ /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
coding_mode = get_bits(gb, 1); coding_mode = get_bits1(gb);
debug_vectors(" using %s scheme for unpacking motion vectors\n", debug_vectors(" using %s scheme for unpacking motion vectors\n",
(coding_mode == 0) ? "VLC" : "fixed-length"); (coding_mode == 0) ? "VLC" : "fixed-length");
@ -2337,7 +2337,7 @@ static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
{ {
Vp3DecodeContext *s = avctx->priv_data; Vp3DecodeContext *s = avctx->priv_data;
if (get_bits(gb, 1)) { if (get_bits1(gb)) {
int token; int token;
if (s->entries >= 32) { /* overflow */ if (s->entries >= 32) { /* overflow */
av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n"); av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
@ -2488,10 +2488,10 @@ static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
for (plane = 0; plane <= 2; plane++) { for (plane = 0; plane <= 2; plane++) {
int newqr= 1; int newqr= 1;
if (inter || plane > 0) if (inter || plane > 0)
newqr = get_bits(gb, 1); newqr = get_bits1(gb);
if (!newqr) { if (!newqr) {
int qtj, plj; int qtj, plj;
if(inter && get_bits(gb, 1)){ if(inter && get_bits1(gb)){
qtj = 0; qtj = 0;
plj = plane; plj = plane;
}else{ }else{
@ -2532,7 +2532,7 @@ static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
for (s->hti = 0; s->hti < 80; s->hti++) { for (s->hti = 0; s->hti < 80; s->hti++) {
s->entries = 0; s->entries = 0;
s->huff_code_size = 1; s->huff_code_size = 1;
if (!get_bits(gb, 1)) { if (!get_bits1(gb)) {
s->hbits = 0; s->hbits = 0;
read_huffman_tree(avctx, gb); read_huffman_tree(avctx, gb);
s->hbits = 1; s->hbits = 1;

10
libavcodec/wmadec.c
View File

@ -393,11 +393,11 @@ static int wma_decode_block(WMACodecContext *s)
return -1; return -1;
if (s->nb_channels == 2) { if (s->nb_channels == 2) {
s->ms_stereo = get_bits(&s->gb, 1); s->ms_stereo = get_bits1(&s->gb);
} }
v = 0; v = 0;
for(ch = 0; ch < s->nb_channels; ch++) { for(ch = 0; ch < s->nb_channels; ch++) {
a = get_bits(&s->gb, 1); a = get_bits1(&s->gb);
s->channel_coded[ch] = a; s->channel_coded[ch] = a;
v |= a; v |= a;
} }
@ -433,7 +433,7 @@ static int wma_decode_block(WMACodecContext *s)
int i, n, a; int i, n, a;
n = s->exponent_high_sizes[bsize]; n = s->exponent_high_sizes[bsize];
for(i=0;i<n;i++) { for(i=0;i<n;i++) {
a = get_bits(&s->gb, 1); a = get_bits1(&s->gb);
s->high_band_coded[ch][i] = a; s->high_band_coded[ch][i] = a;
/* if noise coding, the coefficients are not transmitted */ /* if noise coding, the coefficients are not transmitted */
if (a) if (a)
@ -466,7 +466,7 @@ static int wma_decode_block(WMACodecContext *s)
/* exponents can be reused in short blocks. */ /* exponents can be reused in short blocks. */
if ((s->block_len_bits == s->frame_len_bits) || if ((s->block_len_bits == s->frame_len_bits) ||
get_bits(&s->gb, 1)) { get_bits1(&s->gb)) {
for(ch = 0; ch < s->nb_channels; ch++) { for(ch = 0; ch < s->nb_channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
if (s->use_exp_vlc) { if (s->use_exp_vlc) {
@ -516,7 +516,7 @@ static int wma_decode_block(WMACodecContext *s)
run = run_table[code]; run = run_table[code];
level = level_table[code]; level = level_table[code];
} }
sign = get_bits(&s->gb, 1); sign = get_bits1(&s->gb);
if (!sign) if (!sign)
level = -level; level = -level;
ptr += run; ptr += run;

2
libavcodec/wmv2.c
View File

@ -363,7 +363,7 @@ return -1;
if(s->picture_number==0) if(s->picture_number==0)
decode_ext_header(w); decode_ext_header(w);
s->pict_type = get_bits(&s->gb, 1) + 1; s->pict_type = get_bits1(&s->gb) + 1;
if(s->pict_type == I_TYPE){ if(s->pict_type == I_TYPE){
code = get_bits(&s->gb, 7); code = get_bits(&s->gb, 7);
av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code); av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);