libavcodec.hg: vc1.c comparison

comparison vc1.c @ 3364:59c10b66fbbc libavcodec

Added loop filtering as ersatz for overlap filter (improves picture quality for coarse quantization).

author	kostya
date	Tue, 27 Jun 2006 15:37:48 +0000
parents	4c5227327416
children	c59aa4cdf042

comparison

equal deleted inserted replaced

-:4c5227327416
+:59c10b66fbbc
 int ttmb;             ///< Transform type
 uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
 int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
 int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
 int pqindex;          ///< raw pqindex used in coding set selection
+int a_avail, c_avail;
 /** Luma compensation parameters */
 //@{
 uint8_t lumscale;
 int run_diff, i;
 int16_t *dc_val;
 int16_t *ac_val, *ac_val2;
 int dcdiff;
 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
-int a_avail, c_avail;
+int a_avail = v->a_avail, c_avail = v->c_avail;
 /* XXX: Guard against dumb values of mquant */
 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
 /* Set DC scale - y and c use the same */
 s->y_dc_scale = s->y_dc_scale_table[mquant];
 s->c_dc_scale = s->c_dc_scale_table[mquant];
-/* check if prediction blocks A and C are available */
-a_avail = c_avail = 0;
-if((n == 2 || n == 3) || (s->mb_y && IS_INTRA(s->current_picture.mb_type[mb_pos - s->mb_stride])))
-a_avail = 1;
-if((n == 1 || n == 3) || (s->mb_x && IS_INTRA(s->current_picture.mb_type[mb_pos - 1])))
-c_avail = 1;
 /* Get DC differential */
 if (n < 4) {
 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 } else {
 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 int last = 0, skip, value;
 const int8_t *zz_table;
 int scale;
 int k;
-scale = mquant * 2 + v->halfpq;
+scale = mquant * 2;
 zz_table = vc1_simple_progressive_8x8_zz;
 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 ac_val2 = ac_val;
 if(!a_avail) {
 memset(ac_val + 8, 0, 8 * sizeof(ac_val[0]));
 dc_pred_dir = 1;
 }
-scale = mquant * 2 + v->halfpq;
+scale = mquant * 2;
 memset(ac_val2, 0, 16 * 2);
 if(dc_pred_dir) {//left
 ac_val -= 16;
 if(s->ac_pred)
 memcpy(ac_val2, ac_val, 8 * 2);
 if(ttblk == TT_4X4) {
 subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
 }
 if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
 subblkpat = decode012(gb);
+if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
 }
 scale = 2 * mquant;
 s->dc_val[0][s->block_index[i]] = 0;
 dst_idx += i >> 2;
 val = ((cbp >> (5 - i)) & 1);
 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
 if(s->mb_intra) {
+/* check if prediction blocks A and C are available */
+v->a_avail = v->c_avail = 0;
+if((i == 2 || i == 3) || (s->mb_y && IS_INTRA(s->current_picture.mb_type[mb_pos - s->mb_stride])))
+v->a_avail = 1;
+if((i == 1 || i == 3) || (s->mb_x && IS_INTRA(s->current_picture.mb_type[mb_pos - 1])))
+v->c_avail = 1;
 vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
 vc1_inv_trans(s->block[i], 8, 8);
 for(j = 0; j < 64; j++) s->block[i][j] += 128;
 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
+/* TODO: proper loop filtering */
+if(v->a_avail)
+s->dsp.h263_v_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
+if(v->c_avail)
+s->dsp.h263_h_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
 } else if(val) {
 vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
 if(!v->ttmbf && ttmb < 8) ttmb = -1;
 first_block = 0;
 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
 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);
 for(k = 0; k < 6; k++) {
 val = ((cbp >> (5 - k)) & 1);
 if (k < 4) {
 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
 val = val ^ pred;
 *coded_val = val;
 }
 vc1_overlap_block(s, s->block[k], k, (s->mb_y || k>1), (s->mb_x || (k != 0 && k != 2)));
 }
 }
 vc1_put_block(v, s->block);
+if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
+if(s->mb_y) {
+s->dsp.h263_v_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
+s->dsp.h263_v_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
+s->dsp.h263_v_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
+s->dsp.h263_v_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
+}
+s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
+s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
+if(s->mb_x) {
+s->dsp.h263_h_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
+s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
+s->dsp.h263_h_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
+s->dsp.h263_h_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
+}
+s->dsp.h263_h_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
+s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
+}
 if(get_bits_count(&s->gb) > v->bits) {
 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
 return;
 }

Mercurial > libavcodec.hg

comparison vc1.c @ 3364:59c10b66fbbc libavcodec