libavcodec.hg: vc1.c comparison

comparison vc1.c @ 5513:9f8219a3b86f libavcodec

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

author	alex
date	Thu, 09 Aug 2007 00:13:31 +0000
parents	7617e066481e
children	b790f8c0ee24

comparison

equal deleted inserted replaced

-:28dcc5cd79d2
+:9f8219a3b86f
 */
 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 int x, y;
 for (y=0; y<height; y++){
-if (!get_bits(gb, 1)) //rowskip
+if (!get_bits1(gb)) //rowskip
 memset(plane, 0, width);
 else
 for (x=0; x<width; x++)
-plane[x] = get_bits(gb, 1);
+plane[x] = get_bits1(gb);
 plane += stride;
 }
 }
 /** Decode columns by checking if they are skipped
 */
 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 int x, y;
 for (x=0; x<width; x++){
-if (!get_bits(gb, 1)) //colskip
+if (!get_bits1(gb)) //colskip
 for (y=0; y<height; y++)
 plane[y*stride] = 0;
 else
 for (y=0; y<height; y++)
-plane[y*stride] = get_bits(gb, 1);
+plane[y*stride] = get_bits1(gb);
 plane ++;
 }
 }
 /** Decode a bitplane's bits
 int width, height, stride;
 width = v->s.mb_width;
 height = v->s.mb_height;
 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);
 *raw_flag = 0;
 switch (imode)
 {
 return invert;
 case IMODE_DIFF2:
 case IMODE_NORM2:
 if ((height * width) & 1)
 {
-*planep++ = get_bits(gb, 1);
+*planep++ = get_bits1(gb);
 offset = 1;
 }
 else offset = 0;
 // decode bitplane as one long line
 for (y = offset; y < height * width; y += 2) {
 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
 else v->altpq = v->pq + pqdiff + 1;
 }
 else
 {
-v->dquantfrm = get_bits(gb, 1);
+v->dquantfrm = get_bits1(gb);
 if ( v->dquantfrm )
 {
 v->dqprofile = get_bits(gb, 2);
 switch (v->dqprofile)
 {
 case DQPROFILE_SINGLE_EDGE:
 case DQPROFILE_DOUBLE_EDGES:
 v->dqsbedge = get_bits(gb, 2);
 break;
 case DQPROFILE_ALL_MBS:
-v->dqbilevel = get_bits(gb, 1);
+v->dqbilevel = get_bits1(gb);
 default: break; //Forbidden ?
 }
 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
 {
 pqdiff = get_bits(gb, 3);
 // (fps-2)/4 (->30)
 v->frmrtq_postproc = get_bits(gb, 3); //common
 // (bitrate-32kbps)/64kbps
 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)
 {
 av_log(avctx, AV_LOG_ERROR,
 "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)
 {
 av_log(avctx, AV_LOG_ERROR,
 "1 for reserved RES_X8 is forbidden\n");
 //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)
 {
 av_log(avctx, AV_LOG_ERROR,
 "0 for reserved RES_FASTTX is forbidden\n");
 //return -1;
 }
-v->fastuvmc =  get_bits(gb, 1); //common
+v->fastuvmc =  get_bits1(gb); //common
 if (!v->profile && !v->fastuvmc)
 {
 av_log(avctx, AV_LOG_ERROR,
 "FASTUVMC unavailable in Simple Profile\n");
 return -1;
 }
-v->extended_mv =  get_bits(gb, 1); //common
+v->extended_mv =  get_bits1(gb); //common
 if (!v->profile && v->extended_mv)
 {
 av_log(avctx, AV_LOG_ERROR,
 "Extended MVs unavailable in Simple Profile\n");
 return -1;
 }
 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)
 {
 av_log(avctx, AV_LOG_ERROR,
 "1 for reserved RES_TRANSTAB is forbidden\n");
 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)
 {
 av_log(avctx, AV_LOG_INFO,
 "RANGERED should be set to 0 in simple profile\n");
 }
 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //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)
 {
 //            av_log(avctx, AV_LOG_ERROR,
 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
 av_log(avctx, AV_LOG_ERROR,
 // (fps-2)/4 (->30)
 v->frmrtq_postproc = get_bits(gb, 3); //common
 // (bitrate-32kbps)/64kbps
 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_height = (get_bits(gb, 12) + 1) << 1;
 v->s.avctx->width = v->s.avctx->coded_width;
 v->s.avctx->height = v->s.avctx->coded_height;
 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
 {
 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
 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.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 = P_TYPE;
 } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
 v->bi_type = 0;
 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 v->pquantizer = pqindex < 9;
 if (v->quantizer_mode == QUANT_NON_UNIFORM)
 v->pquantizer = 0;
 v->pqindex = pqindex;
-if (pqindex < 9) v->halfpq = get_bits(gb, 1);
+if (pqindex < 9) v->halfpq = get_bits1(gb);
 else v->halfpq = 0;
 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
-v->pquantizer = get_bits(gb, 1);
+v->pquantizer = get_bits1(gb);
 v->dquantfrm = 0;
 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_y = v->mvrange + 8; //k_y can be 8 9 10 11
 v->range_x = 1 << (v->k_x - 1);
 v->range_y = 1 << (v->k_y - 1);
 if (v->profile == PROFILE_ADVANCED)
 {
-if (v->postprocflag) v->postproc = get_bits(gb, 1);
+if (v->postprocflag) v->postproc = get_bits1(gb);
 }
 else
 if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
 if(v->res_x8 && (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)){
 }
 v->ttfrm = 0; //FIXME Is that so ?
 if (v->vstransform)
 {
-v->ttmbf = get_bits(gb, 1);
+v->ttmbf = get_bits1(gb);
 if (v->ttmbf)
 {
 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 }
 } else {
 }
 v->ttfrm = 0;
 if (v->vstransform)
 {
-v->ttmbf = get_bits(gb, 1);
+v->ttmbf = get_bits1(gb);
 if (v->ttmbf)
 {
 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 }
 } else {
 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
 {
 v->y_ac_table_index = decode012(gb);
 }
 /* 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) {
 v->s.pict_type = B_TYPE;
 v->bi_type = 1;
 }
 //...
 }
 v->rnd = get_bits1(gb);
 if(v->interlace)
 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) {
 v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 v->bfraction = ff_vc1_bfraction_lut[v->bfraction];
 if(v->bfraction == 0) {
 v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 v->pquantizer = pqindex < 9;
 if (v->quantizer_mode == QUANT_NON_UNIFORM)
 v->pquantizer = 0;
 v->pqindex = pqindex;
-if (pqindex < 9) v->halfpq = get_bits(gb, 1);
+if (pqindex < 9) v->halfpq = get_bits1(gb);
 else v->halfpq = 0;
 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;
 switch(v->s.pict_type) {
 case I_TYPE:
 }
 v->ttfrm = 0; //FIXME Is that so ?
 if (v->vstransform)
 {
-v->ttmbf = get_bits(gb, 1);
+v->ttmbf = get_bits1(gb);
 if (v->ttmbf)
 {
 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 }
 } else {
 }
 v->ttfrm = 0;
 if (v->vstransform)
 {
-v->ttmbf = get_bits(gb, 1);
+v->ttmbf = get_bits1(gb);
 if (v->ttmbf)
 {
 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 }
 } else {
 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
 {
 v->y_ac_table_index = decode012(gb);
 }
 /* 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) {
 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
 vop_dquant_decoding(v);
 }
 int edges = 0;                                             \
 if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
 {                                                          \
 if (v->dqbilevel)                                        \
 {                                                        \
-mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
+mquant = (get_bits1(gb)) ? v->altpq : v->pq;           \
 }                                                        \
 else                                                     \
 {                                                        \
 mqdiff = get_bits(gb, 3);                              \
 if (mqdiff != 7) mquant = v->pq + mqdiff;              \
 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
 if (index != vc1_ac_sizes[codingset] - 1) {
 run = vc1_index_decode_table[codingset][index][0];
 level = vc1_index_decode_table[codingset][index][1];
 lst = index >= vc1_last_decode_table[codingset];
-if(get_bits(gb, 1))
+if(get_bits1(gb))
 level = -level;
 } else {
 escape = decode210(gb);
 if (escape != 2) {
 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
 if(lst)
 run += vc1_last_delta_run_table[codingset][level] + 1;
 else
 run += vc1_delta_run_table[codingset][level] + 1;
 }
-if(get_bits(gb, 1))
+if(get_bits1(gb))
 level = -level;
 } else {
 int sign;
-lst = get_bits(gb, 1);
+lst = get_bits1(gb);
 if(v->s.esc3_level_length == 0) {
 if(v->pq < 8 || v->dquantfrm) { // table 59
 v->s.esc3_level_length = get_bits(gb, 3);
 if(!v->s.esc3_level_length)
 v->s.esc3_level_length = get_bits(gb, 2) + 8;
 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
 }
 v->s.esc3_run_length = 3 + get_bits(gb, 2);
 }
 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);
 if(sign)
 level = -level;
 }
 }
 else
 {
 if (v->pq == 1)
 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
 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;
 }
 /* Prediction */
 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
 else
 {
 if (mquant == 1)
 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
 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;
 }
 /* Prediction */
 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
 else
 {
 if (mquant == 1)
 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
 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;
 }
 /* Prediction */
 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
 /* FIXME Set DC val for inter block ? */
 if (s->mb_intra && !mb_has_coeffs)
 {
 GET_MQUANT();
-s->ac_pred = get_bits(gb, 1);
+s->ac_pred = get_bits1(gb);
 cbp = 0;
 }
 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);
 GET_MQUANT();
 }
 else
 {
 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
 intrapred = 1;
 break;
 }
 }
-if(intrapred)s->ac_pred = get_bits(gb, 1);
+if(intrapred)s->ac_pred = get_bits1(gb);
 else s->ac_pred = 0;
 }
 if (!v->ttmbf && coded_inter)
 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
 for (i=0; i<6; i++)
 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
 // do actual MB decoding and displaying
 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++) {
 val = ((cbp >> (5 - k)) & 1);
 if (k < 4) {
 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
 // do actual MB decoding and displaying
 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
 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
 v->s.ac_pred = v->acpred_plane[mb_pos];
 if(v->condover == CONDOVER_SELECT) {
 if(v->overflg_is_raw)
-overlap = get_bits(&v->s.gb, 1);
+overlap = get_bits1(&v->s.gb);
 else
 overlap = v->over_flags_plane[mb_pos];
 } else
 overlap = (v->condover == CONDOVER_ALL);

Mercurial > libavcodec.hg

comparison vc1.c @ 5513:9f8219a3b86f libavcodec