coder_bpb.c

好东西呢

				X3 = abs( sister_x[ x + fullw*y ] ) & nextmask;
				X4 = abs( sister_y[ y + fullw*x ] ) & nextmask;
				break;
			case 3:
				X3 = abs( sister_x[ y + fullw*x ] ) & nextmask;
				X4 = abs( sister_y[ y + fullw*x ] ) & nextmask;
				break;
		}
	} else {

		/** more vertical correlation (than horizontal) **/

		if ( y > 1 ) 			X1 = abs(dp[-fullw-fullw]) & nextmask; else X1 = VD;	//NN
		X2 = S;
		if ( y > parent_step ) 			X3 = abs(pp[-fullw])	& nextmask; else X3 = VD;		//PN
		if ( y < (height - parent_step) )	X4 = abs(pp[fullw]) 	& nextmask; else X4 = VD;		//PS
	}

	shapes = 0;
	if ( N > VD ) shapes += SHAPE(0);
	if ( W > VD ) shapes += SHAPE(1);

#ifdef BIG_SHAPE_CNTX
#ifdef XX_SHAPES
	if ( X1 > VD ) shapes += SHAPE(2);
	if ( X2 > VD ) shapes += SHAPE(3);
#else
	if ( S > VD ) shapes += SHAPE(2);
	if ( E > VD ) shapes += SHAPE(3);
#endif
#ifdef FIFTH_SHAPE
	if ( (X3+X4+P) > 3*VD ) shapes += SHAPE(4);
#endif
#endif

#ifdef NO_XX
	X3 = X4 = 0;
#endif

	s1 = &stats1[ min(VAL_CONTEXT_MAX, ((C1A * VD + C1B * P + C1C * N + C1D * W + C1E * NW + C1F * NE + C1G * X1 + C1H * X2 + C1I * X3 + C1J * X4)>>8)) + shapes ];
	s2 = &stats2[ min(VAL_CONTEXT_MAX, ((C2A * VD + C2B * P + C2C * N + C2D * W + C2E * NW + C2F * NE + C2G * X1 + C2H * X2 + C2I * X3 + C2J * X4)>>8)) + shapes ];
	s3 = &stats3[ min(VAL_CONTEXT_MAX, ((C3A * VD + C3B * P + C3C * N + C3D * W + C3E * NW + C3F * NE + C3G * X1 + C3H * X2 + C3I * X3 + C3J * X4)>>8)) + shapes ];
	s4 = &stats4[ min(VAL_CONTEXT_MAX, ((C4A * VD + C4B * P + C4C * N + C4D * W + C4E * NW + C4F * NE + C4G * X1 + C4H * X2 + C4I * X3 + C4J * X4)>>8)) + shapes ];

	/** weighting 
	*
	*	find the best two, then weight them by 2^(-entropy) 
	**/

#ifdef LOCAL_LENS
	len1 = intentropy(s1->p0,s1->pt);
	len2 = intentropy(s2->p0,s2->pt);
	len3 = intentropy(s3->p0,s3->pt);
	len4 = intentropy(s4->p0,s4->pt);
#endif
#ifdef ADD_CUR_WEIGHTS
	len1 += LOEweight(s1->p0,s1->pt);
	len2 += LOEweight(s2->p0,s2->pt);
	len3 += LOEweight(s3->p0,s3->pt);
	len4 += LOEweight(s4->p0,s4->pt);
#endif

	lena = len1; sa = s1;
	if ( len2 < lena ) { lena = len2; sa = s2; }
	if ( len3 < lena ) { lena = len3; sa = s3; }
	if ( len4 < lena ) { lena = len4; sa = s4; }

	lenb = INT_MAX;
	if ( len1 < lenb && sa != s1 ) { lenb = len1; sb = s1; }
	if ( len2 < lenb && sa != s2 ) { lenb = len2; sb = s2; }
	if ( len3 < lenb && sa != s3 ) { lenb = len3; sb = s3; }
	if ( len4 < lenb && sa != s4 ) { lenb = len4; sb = s4; }

#ifdef LOG
	     if ( sa == s1 ) nbest1++;
	else if ( sa == s2 ) nbest2++;
	else if ( sa == s3 ) nbest3++;
	else if ( sa == s4 ) nbest4++;
#endif

	if ( lena == lenb ) {
		p0 = (sa->p0 + sb->p0)>>1;
		pt = (sa->pt + sb->pt)>>1;
	} else if ( lenb < lena ) {
		diff = 1 + ((lena-lenb+8)>>4);
		if ( diff >= 18 ) {
			p0 = sb->p0;
			pt = sb->pt;
		} else {
			p0 = (((sb->p0)<<diff) + (sa->p0))/((1<<diff) + 1);
			pt = (((sb->pt)<<diff) + (sa->pt))/((1<<diff) + 1);
		}
	} else {
		diff = 1 + ((lenb-lena+8)>>4);
		if ( lenb-lena >= 18 ) {
			p0 = sa->p0;
			pt = sa->pt;
		} else {
			p0 = (((sa->p0)<<diff) + (sb->p0))/((1<<diff) + 1);
			pt = (((sa->pt)<<diff) + (sb->pt))/((1<<diff) + 1);
		}
	}
}

static void fixStats(bool bit)
{

	/** track the weights as the actual coded len from that model **/

#ifndef LOCAL_LENS
#ifdef SCALEDOWN_LENS
	len1 -= len1>>SCALEDOWN_SHIFT;
	len2 -= len2>>SCALEDOWN_SHIFT;
	len3 -= len3>>SCALEDOWN_SHIFT;
	len4 -= len4>>SCALEDOWN_SHIFT;
#endif

	if ( bit ) {
		len1 += log2x16( s1->pt ) - log2x16( s1->pt - s1->p0 );
		len2 += log2x16( s2->pt ) - log2x16( s2->pt - s2->p0 );
		len3 += log2x16( s3->pt ) - log2x16( s3->pt - s3->p0 );
		len4 += log2x16( s4->pt ) - log2x16( s4->pt - s4->p0 );

		if ( len1 > 40000 ) {	/** for safety **/
			len1 >>= 1; len2 >>= 1; len3 >>= 1; len4 >>= 1;
		}
	} else {
		len1 += log2x16( s1->pt ) - log2x16( s1->p0 );
		len2 += log2x16( s2->pt ) - log2x16( s2->p0 );
		len3 += log2x16( s3->pt ) - log2x16( s3->p0 );
		len4 += log2x16( s4->pt ) - log2x16( s4->p0 );
	}
#endif

	bitModel(bit,s1->p0,s1->pt);
	bitModel(bit,s2->p0,s2->pt);
	bitModel(bit,s3->p0,s3->pt);
	bitModel(bit,s4->p0,s4->pt);

}

static void codeBand_init(coder *me,subband_leaf *sb)
{
myInfo *d;
int i;

	d = (myInfo *)me->data;

	if ( sb->cntx1 && sb->cntx1shift == 0 && sb->cntx2 && sb->cntx2shift == 0 ) {
		sister_x = sb->cntx1->band;
		sister_y = sb->cntx2->band;
		sister_trans = 0;
		if ( sb->cntx1->transposed != sb->transposed ) sister_trans |= 1;
		if ( sb->cntx2->transposed != sb->transposed ) sister_trans |= 2;
	} else {
		sister_x = sister_y = NULL;
	}

	len1=len2=len3=len4=0;
	stats1 = d->stats1;
	stats2 = d->stats2;
	stats3 = d->stats3;
	stats4 = d->stats4;

	parent = sb->parent->band;
	parent_step = (sb->width) / (sb->parent->width);
	if ( parent_step == 0 ) errexit("BP_bin can't handle parent bigger than band");
	parent_mask = parent_step - 1;
	parent_shift = 0;
	for(i=parent_step;i>1;i>>=1) parent_shift++;
}

void coderBPbin_encodeSubbandBP(coder *me,subband_leaf *sb,int bitmask)
{
int *band,width,height,fullw;
int x,y,bit;
int *dp,*pp,*dpn;
arithInfo *ari = me->arith;
binContext *signs = ((myInfo *)me->data)->signs;

	for(x= bitmask,nextmask=0; x<CODE_MAX_VAL ;x+=x) nextmask += x;
	donemask = nextmask - bitmask;

	band = sb->band; width = sb->width; height = sb->height; fullw = sb->rowpad + width;

	codeBand_init(me,sb);

	dp = band;	pp = parent;
	for(y=0;y<height;y++) {
		if ( coder_timetostop(me) ) { coder_didstop(me,y); return; }
		dpn = dp + fullw;
		for(x=0;x<width;x++) {

			getStats(&dp[x],&pp[x>>parent_shift],x,y,width,height,fullw);

			bit = (abs(dp[x])&bitmask)?1:0;
			arithEncBit(ari,p0,pt,bit);

			fixStats(bit);

			if ( bit & !VD ) {
				int context;
				/** code the sign **/
				context = 0;
				if ( x < (width-1) )	AddSignContext(context,dp[x+1],donemask); else AddSignContext(context,0,0);
				if ( x > 0 )			AddSignContext(context,dp[x-1],nextmask); else AddSignContext(context,0,0);
				if ( y < (height-1) )	AddSignContext(context,dp[x+fullw],donemask); else AddSignContext(context,0,0);
				if ( y > 0 )			AddSignContext(context,dp[x-fullw],nextmask); else AddSignContext(context,0,0);
#ifdef BIG_SIGN_CONTEXT
				if ( y > 0 && x > 0 )	AddSignContext(context,dp[x-fullw-1],nextmask); else AddSignContext(context,0,0);
				if ( y > 0 && x < (width-1) )	AddSignContext(context,dp[x-fullw+1],nextmask); else AddSignContext(context,0,0);
#endif
				bitEnc( (isneg(dp[x])?1:0) ,ari,signs[context].p0,signs[context].pt);
			}
			
		}
		if ( (y & parent_mask) == parent_mask ) pp += fullw;
		dp += fullw;
	}


#ifdef LOG
printf("nbest : 1 = %d , 2 = %d , 3 = %d , 4 = %d \n",nbest1,nbest2,nbest3,nbest4);
#endif
}

void coderBPbin_decodeSubbandBP(coder *me,subband_leaf *sb,int bitmask)
{
int *band,width,height,fullw;
int x,y,bit;
int *dp,*pp,*dpn;
arithInfo *ari = me->arith;
binContext *signs = ((myInfo *)me->data)->signs;

	band = sb->band; width = sb->width; height = sb->height; fullw = sb->rowpad + width;

	codeBand_init(me,sb);

	for(x= bitmask,nextmask=0; x<CODE_MAX_VAL ;x+=x) nextmask += x;
	donemask = nextmask - bitmask;

	dp = band;	pp = parent;
	for(y=0;y<height;y++) {
		if ( coder_timetostopd(me,y) ) { dbf(); return; }
		dpn = dp + fullw;
		for(x=0;x<width;x++) {

			getStats(&dp[x],&pp[x>>parent_shift],x,y,width,height,fullw);

			bit = arithDecBit(ari,p0,pt);

			fixStats(bit);

			if ( bit ) {
				if ( isneg(dp[x]) ) dp[x] -= bitmask;
				else dp[x] += bitmask; 
				if ( ! VD ) {
					int context;
					/** code the sign **/
					context = 0;
					if ( x < (width-1) )	AddSignContext(context,dp[x+1],donemask); else AddSignContext(context,0,0);
					if ( x > 0 )			AddSignContext(context,dp[x-1],nextmask); else AddSignContext(context,0,0);
					if ( y < (height-1) )	AddSignContext(context,dp[x+fullw],donemask); else AddSignContext(context,0,0);
					if ( y > 0 )			AddSignContext(context,dp[x-fullw],nextmask); else AddSignContext(context,0,0);
#ifdef BIG_SIGN_CONTEXT
					if ( y > 0 && x > 0 )	AddSignContext(context,dp[x-fullw-1],nextmask); else AddSignContext(context,0,0);
					if ( y > 0 && x < (width-1) )	AddSignContext(context,dp[x-fullw+1],nextmask); else AddSignContext(context,0,0);
#endif
					bitDec(bit,ari,signs[context].p0,signs[context].pt);
					if ( bit ) dp[x] = - dp[x];
				}
			}
		}
		if ( (y & parent_mask) == parent_mask ) pp += fullw;
		dp += fullw;
	}
}