libavcodec.hg: h263.c comparison

comparison h263.c @ 350:6ebbecc10063 libavcodec

- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now. - Bug fix H.263+ AIC tables. - Warning fixes.

author	pulento
date	Thu, 02 May 2002 04:39:45 +0000
parents	c2f789fe4945
children	ac6fc4c7aecb

comparison

equal deleted inserted replaced

-:34f6c77ff01a
+:6ebbecc10063
 static int h263p_decode_umotion(MpegEncContext * s, int pred);
 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
 int n, int coded);
 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
 int n, int coded);
+static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
 int dir);
 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
 put_bits(&s->pb,1,0); /* Custom PCF: off */
 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
 put_bits(&s->pb,1,0); /* SAC: off */
 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
-put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
+put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
 put_bits(&s->pb,1,0); /* Slice Structured: off */
 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
-put_bits(&s->pb,1,0); /* Rounding Type */
+if (s->pict_type == I_TYPE)
+s->no_rounding = 0;
+else
+s->no_rounding ^= 1;
+put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 put_bits(&s->pb,2,0); /* Reserved */
 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 /* This should be here if PLUSPTYPE */
 put_bits(&s->pb, 1, 0);	/* Continuous Presence Multipoint mode: off */
 void h263_encode_mb(MpegEncContext * s,
 		    DCTELEM block[6][64],
 		    int motion_x, int motion_y)
 {
 int cbpc, cbpy, i, cbp, pred_x, pred_y;
+INT16 pred_dc;
-//    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
+INT16 rec_intradc[6];
+UINT16 *dc_ptr[6];
+//printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 if (!s->mb_intra) {
-	   /* compute cbp */
+/* compute cbp */
 cbp = 0;
 for (i = 0; i < 6; i++) {
 if (s->block_last_index[i] >= 0)
 cbp |= 1 << (5 - i);
 }
 if ((cbp | motion_x | motion_y) == 0) {
 /* skip macroblock */
 put_bits(&s->pb, 1, 1);
 return;
 }
-put_bits(&s->pb, 1, 0);    /* mb coded */
+put_bits(&s->pb, 1, 0);	/* mb coded */
 cbpc = cbp & 3;
 put_bits(&s->pb,
-inter_MCBPC_bits[cbpc],
+		    inter_MCBPC_bits[cbpc],
-inter_MCBPC_code[cbpc]);
+		    inter_MCBPC_code[cbpc]);
 cbpy = cbp >> 2;
 cbpy ^= 0xf;
 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 /* motion vectors: 16x16 mode only now */
 h263_pred_motion(s, 0, &pred_x, &pred_y);
 if (!s->umvplus) {
 h263_encode_motion(s, motion_x - pred_x, s->f_code);
 h263_encode_motion(s, motion_y - pred_y, s->f_code);
 }
 else {
 h263p_encode_umotion(s, motion_x - pred_x);
 h263p_encode_umotion(s, motion_y - pred_y);
 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 /* To prevent Start Code emulation */
 put_bits(&s->pb,1,1);
 }
 } else {
-	/* compute cbp */
+int li = s->h263_aic ? 0 : 1;
-	cbp = 0;
-	for (i = 0; i < 6; i++) {
+cbp = 0;
-	    if (s->block_last_index[i] >= 1)
+for(i=0; i<6; i++) {
-		cbp |= 1 << (5 - i);
+/* Predict DC */
-	}
+if (s->h263_aic && s->mb_intra) {
+INT16 level = block[i][0];
-	cbpc = cbp & 3;
-	if (s->pict_type == I_TYPE) {
+pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
-	    put_bits(&s->pb,
+level -= pred_dc;
-		     intra_MCBPC_bits[cbpc],
+/* Quant */
-		     intra_MCBPC_code[cbpc]);
+if (level < 0)
-	} else {
+level = (level + (s->qscale >> 1))/(s->y_dc_scale);
-	    put_bits(&s->pb, 1, 0);	/* mb coded */
+else
-	    put_bits(&s->pb,
+level = (level - (s->qscale >> 1))/(s->y_dc_scale);
-		     inter_MCBPC_bits[cbpc + 4],
-		     inter_MCBPC_code[cbpc + 4]);
+/* AIC can change CBP */
-	}
+if (level == 0 && s->block_last_index[i] == 0)
-	if (s->h263_pred) {
+s->block_last_index[i] = -1;
-	    /* XXX: currently, we do not try to use ac prediction */
+else if (level < -127)
-	    put_bits(&s->pb, 1, 0);	/* no ac prediction */
+level = -127;
-	}
+else if (level > 127)
-	cbpy = cbp >> 2;
+level = 127;
-	put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
-}
+block[i][0] = level;
+/* Reconstruction */
-/* encode each block */
+rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
-for (i = 0; i < 6; i++) {
+/* Oddify */
+rec_intradc[i] |= 1;
+//if ((rec_intradc[i] % 2) == 0)
+//    rec_intradc[i]++;
+/* Clipping */
+if (rec_intradc[i] < 0)
+rec_intradc[i] = 0;
+else if (rec_intradc[i] > 2047)
+rec_intradc[i] = 2047;
+/* Update AC/DC tables */
+*dc_ptr[i] = rec_intradc[i];
+}
+/* compute cbp */
+if (s->block_last_index[i] >= li)
+cbp |= 1 << (5 - i);
+}
+cbpc = cbp & 3;
+if (s->pict_type == I_TYPE) {
+put_bits(&s->pb,
+intra_MCBPC_bits[cbpc],
+intra_MCBPC_code[cbpc]);
+} else {
+put_bits(&s->pb, 1, 0);	/* mb coded */
+put_bits(&s->pb,
+inter_MCBPC_bits[cbpc + 4],
+inter_MCBPC_code[cbpc + 4]);
+}
+if (s->h263_aic) {
+/* XXX: currently, we do not try to use ac prediction */
+put_bits(&s->pb, 1, 0);	/* no AC prediction */
+}
+cbpy = cbp >> 2;
+put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
+}
+for(i=0; i<6; i++) {
+/* encode each block */
 h263_encode_block(s, block[i], i);
-}
-}
+/* Update INTRADC for decoding */
+if (s->h263_aic && s->mb_intra) {
-void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
+block[i][0] = rec_intradc[i];
-{
-int x, y, wrap, a, c, pred_dc, scale, i;
+}
-INT16 *dc_val, *ac_val, *ac_val1;
+}
+}
+static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
+{
+int x, y, wrap, a, c, pred_dc, scale;
+INT16 *dc_val, *ac_val;
 /* find prediction */
 if (n < 4) {
 x = 2 * s->mb_x + 1 + (n & 1);
 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 wrap = s->mb_width + 2;
 dc_val = s->dc_val[n - 4 + 1];
 ac_val = s->ac_val[n - 4 + 1][0];
 scale = s->c_dc_scale;
 }
+/* B C
+* A X
+*/
+a = dc_val[(x - 1) + (y) * wrap];
+c = dc_val[(x) + (y - 1) * wrap];
+/* No prediction outside GOB boundary */
+if (s->first_gob_line && ((n < 2) || (n > 3)))
+c = 1024;
+pred_dc = 1024;
+/* just DC prediction */
+if (a != 1024 && c != 1024)
+pred_dc = (a + c) >> 1;
+else if (a != 1024)
+pred_dc = a;
+else
+pred_dc = c;
+/* we assume pred is positive */
+//pred_dc = (pred_dc + (scale >> 1)) / scale;
+*dc_val_ptr = &dc_val[x + y * wrap];
+return pred_dc;
+}
+void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
+{
+int x, y, wrap, a, c, pred_dc, scale, i;
+INT16 *dc_val, *ac_val, *ac_val1;
+/* find prediction */
+if (n < 4) {
+x = 2 * s->mb_x + 1 + (n & 1);
+y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
+wrap = s->mb_width * 2 + 2;
+dc_val = s->dc_val[0];
+ac_val = s->ac_val[0][0];
+scale = s->y_dc_scale;
+} else {
+x = s->mb_x + 1;
+y = s->mb_y + 1;
+wrap = s->mb_width + 2;
+dc_val = s->dc_val[n - 4 + 1];
+ac_val = s->ac_val[n - 4 + 1][0];
+scale = s->c_dc_scale;
+}
 ac_val += ((y) * wrap + (x)) * 16;
 ac_val1 = ac_val;
 /* B C
 * A X
 */
 a = dc_val[(x - 1) + (y) * wrap];
 c = dc_val[(x) + (y - 1) * wrap];
+/* No prediction outside GOB boundary */
+if (s->first_gob_line && ((n < 2) || (n > 3)))
+c = 1024;
 pred_dc = 1024;
 if (s->ac_pred) {
 if (s->h263_aic_dir) {
 /* left prediction */
 if (a != 1024) {
 init_uni_dc_tab();
 init_rl(&rl_inter);
 init_rl(&rl_intra);
+init_rl(&rl_intra_aic);
 init_mv_penalty_and_fcode(s);
 }
 s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
 }
 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 {
-int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
+int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
-int code;
+RLTable *rl;
-RLTable *rl = &rl_inter;
+rl = &rl_inter;
-if (s->mb_intra) {
+if (s->mb_intra && !s->h263_aic) {
 /* DC coef */
 	    level = block[0];
 /* 255 cannot be represented, so we clamp */
 if (level > 254) {
 level = 254;
 	    else
 	        put_bits(&s->pb, 8, level & 0xff);
 	    i = 1;
 } else {
 	    i = 0;
-}
+	    if (s->h263_aic && s->mb_intra)
+	        rl = &rl_intra_aic;
+}
 /* AC coefs */
 last_index = s->block_last_index[n];
 last_non_zero = i - 1;
 for (; i <= last_index; i++) {
-	j = zigzag_direct[i];
+j = zigzag_direct[i];
-	level = block[j];
+level = block[j];
-	if (level) {
+if (level) {
-	    run = i - last_non_zero - 1;
+run = i - last_non_zero - 1;
-	    last = (i == last_index);
+last = (i == last_index);
-	    sign = 0;
+sign = 0;
-	    slevel = level;
+slevel = level;
-	    if (level < 0) {
+if (level < 0) {
-		sign = 1;
+sign = 1;
-		level = -level;
+level = -level;
-	    }
+}
 code = get_rl_index(rl, last, run, level);
 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 if (code == rl->n) {
 put_bits(&s->pb, 1, last);
 put_bits(&s->pb, 6, run);
 put_bits(&s->pb, 8, slevel & 0xff);
 } else {
 put_bits(&s->pb, 1, sign);
 }
-	    last_non_zero = i;
+	        last_non_zero = i;
-	}
+	    }
 }
 }
 /***************************************************/
 	if(s->aspect_ratio_info == EXTENDET_PAR){
 skip_bits(&s->gb, 8); //par_width
 skip_bits(&s->gb, 8); // par_height
 }
-if(vol_control=get_bits1(&s->gb)){ /* vol control parameter */
+if ((vol_control=get_bits1(&s->gb))) { /* vol control parameter */
 int chroma_format= get_bits(&s->gb, 2);
 if(chroma_format!=1){
 printf("illegal chroma format\n");
 }
 s->low_delay= get_bits1(&s->gb);

Mercurial > libavcodec.hg

comparison h263.c @ 350:6ebbecc10063 libavcodec