getpic.c

G729、h263、h264、MPEG4四种最流行的音频和视频标准的压缩和解压算法的源代码.rar

						addblock(comp,bx,by,1);
					}
				}
			}
			
		} /* end if (MBA > 0) */
		
		if (!COD) 
		{
			Mode = modemap[ypos+1][xpos+1];
			
			/* decode blocks */
			for (comp=0; comp<blk_cnt; comp++) 
			{
				clearblock(comp);
				if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) 
				{ /* Intra */
					bp = ld->block[comp];
					if(syntax_arith_coding) 
					{
						INTRADC_index = decode_a_symbol(cumf_INTRADC);
						bp[0] = intradctab[INTRADC_index];
					}
					else 
					{
						bp[0] = getbits(8);
					}
					
					if (bp[0] == 128)
						if (!quiet)
							fprintf(stderr,"Illegal DC-coeff: 1000000\n");
						if (bp[0] == 255)  /* Spec. in H.26P, not in TMN4 */
							bp[0] = 128;
						bp[0] *= 8; /* Iquant */
						if ( (CBP & (1<<(blk_cnt-1-comp))) ) 
						{
							if (!syntax_arith_coding)
								getblock(comp,0);
							else 
								get_sac_block(comp,0);
						}
				}
				else 
				{ /* Inter */
					if ( (CBP & (1<<(blk_cnt-1-comp))) ) 
					{
						if (!syntax_arith_coding)
							getblock(comp,1);
						else
							get_sac_block(comp,1);
					}
				}
				if (fault) goto resync;
			}
			
			/* Decode B blocks */
			if (pb_frame) 
			{
				for (comp=6; comp<blk_cnt+6; comp++) 
				{
					clearblock(comp);
					if ( (CBPB & (1<<(blk_cnt-1-comp%6))) ) 
					{
						if (!syntax_arith_coding)
							getblock(comp,1);
						else
							get_sac_block(comp,1);
					}
					if (fault) goto resync;
				}
			}
			
		}
		
		/* advance to next macroblock */
		MBA++;
		
		pCBP = CBP; pCBPB = CBPB; pCOD = COD;
		pmvdbx = mvdbx; pmvdby = mvdby;
		fflush(stdout);
		
		if (MBA >= MBAmax && !last_done)
		{
			COD = 1;
			xpos = 0;
			ypos++;
			last_done = 1;
			goto reconstruct_mb;
		}
  }
}

/* set block to zero */

static void clearblock(comp)
int comp;
{
	int *bp;
	int i;
	
	bp = (int *)ld->block[comp];
	
	for (i=0; i<8; i++)
	{
		bp[0] = bp[1] = bp[2] = bp[3] = 0;
		bp += 4;
	}
}


/* move/add 8x8-Block from block[comp] to refframe or bframe */

static void addblock(comp,bx,by,addflag)
int comp,bx,by,addflag;
{
	int cc,i, iincr, P = 1;
	unsigned char *rfp;
	short *bp;
	
	bp = ld->block[comp];
	
	if (comp >= 6) 
	{
		/* This is a component for B-frame forward prediction */
		P = 0;
		addflag = 1;
		comp -= 6;
	}
	
	cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
	
	if (cc==0)
	{
		/* luminance */
		
		/* frame DCT coding */
		if (P)
			rfp = newframe[0]
			+ coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
		else
			rfp = bframe[0]
			+ coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
		iincr = coded_picture_width;
	}
	else 
	{
		/* chrominance */
		
		/* scale coordinates */
		bx >>= 1;
		by >>= 1;
		/* frame DCT coding */
		if (P)
			rfp = newframe[cc] + chrom_width*by + bx;
		else
			rfp = bframe[cc] + chrom_width*by + bx;
		iincr = chrom_width;
	}
	
	
	if (addflag) 
	{
		for (i=0; i<8; i++) 
		{
			rfp[0] = clp[bp[0]+rfp[0]];
			rfp[1] = clp[bp[1]+rfp[1]];
			rfp[2] = clp[bp[2]+rfp[2]];
			rfp[3] = clp[bp[3]+rfp[3]];
			rfp[4] = clp[bp[4]+rfp[4]];
			rfp[5] = clp[bp[5]+rfp[5]];
			rfp[6] = clp[bp[6]+rfp[6]];
			rfp[7] = clp[bp[7]+rfp[7]];
			bp += 8;
			rfp+= iincr;
		}
	}
	else  
	{
		for (i=0; i<8; i++) 
		{
			rfp[0] = clp[bp[0]];
			rfp[1] = clp[bp[1]];
			rfp[2] = clp[bp[2]];
			rfp[3] = clp[bp[3]];
			rfp[4] = clp[bp[4]];
			rfp[5] = clp[bp[5]];
			rfp[6] = clp[bp[6]];
			rfp[7] = clp[bp[7]];
			bp += 8;
			rfp += iincr;
		}
	}
}

/* bidirectionally reconstruct 8x8-Block from block[comp] to bframe */

static void reconblock_b(comp,bx,by,mode,bdx,bdy)
int comp,bx,by;
int mode,bdx,bdy;
{
	int cc,i,j,k, ii;
	unsigned char *bfr, *ffr;
	int BMVx, BMVy;
	int xa,xb,ya,yb,x,y,xvec,yvec,mvx,mvy;
	int xint,xhalf,yint,yhalf,pel;
	
	x = bx/16+1;y=by/16+1;
	
	if (mode == MODE_INTER4V) {
		if (comp < 4) {
			/* luma */
			mvx = MV[0][comp+1][y][x];
			mvy = MV[1][comp+1][y][x];
			BMVx = (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
			BMVy = (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
		}
		else {
			/* chroma */
			xvec = yvec = 0;
			for (k = 1; k <= 4; k++) {
				mvx = MV[0][k][y][x];
				mvy = MV[1][k][y][x];
				xvec += (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
				yvec += (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
			}
			
			/* chroma rounding (table 16/H.263) */
			BMVx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
			BMVy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
		}
	}
	else {
		if (comp < 4) {
			/* luma */
			mvx = MV[0][0][y][x];
			mvy = MV[1][0][y][x];
			BMVx = (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
			BMVy = (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
		}
		else {
			/* chroma */
			mvx = MV[0][0][y][x];
			mvy = MV[1][0][y][x];
			xvec = (bdx == 0 ? (trb-trd)* mvx/trd : trb * mvx/trd + bdx - mvx);
			yvec = (bdy == 0 ? (trb-trd)* mvy/trd : trb * mvy/trd + bdy - mvy);
			xvec *= 4;
			yvec *= 4;
			
			/* chroma rounding (table 16/H.263) */
			BMVx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
			BMVy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
		}
	}
	
	cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
	
	if (cc==0) {
		/* luminance */
		find_bidir_limits(BMVx,&xa,&xb,comp&1);
		find_bidir_limits(BMVy,&ya,&yb,(comp&2)>>1);
		bfr = bframe[0] +
			coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
		ffr = newframe[0] +
			coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
		ii = coded_picture_width;
	}
	else {
		/* chrominance */
		/* scale coordinates and vectors*/
		bx >>= 1;
		by >>= 1;
		
		find_bidir_chroma_limits(BMVx,&xa,&xb);
		find_bidir_chroma_limits(BMVy,&ya,&yb);
		
		bfr = bframe[cc]      + chrom_width*(by+((comp&2)<<2)) + bx + (comp&8);
		ffr = newframe[cc]    + chrom_width*(by+((comp&2)<<2)) + bx + (comp&8);
		ii = chrom_width;
	}
	
	xint = BMVx>>1;
	xhalf = BMVx - 2*xint;
	yint = BMVy>>1;
	yhalf = BMVy - 2*yint;
	
	ffr += xint + (yint+ya)*ii;
	bfr += ya*ii;
	
	if (!xhalf && !yhalf) {
		for (j = ya; j < yb; j++) {
			for (i = xa; i < xb; i++) {
				pel = ffr[i];
				bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
			}
			bfr += ii;
			ffr += ii;
		}
	}
	else if (xhalf && !yhalf) {
		for (j = ya; j < yb; j++) {
			for (i = xa; i < xb; i++) {
				pel = ((unsigned int)(ffr[i]+ffr[i+1]+1))>>1;
				bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
			}
			bfr += ii;
			ffr += ii;
		}
	}
	else if (!xhalf && yhalf) {
		for (j = ya; j < yb; j++) {
			for (i = xa; i < xb; i++) {
				pel = ((unsigned int)(ffr[i]+ffr[ii+i]+1))>>1;
				bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
			}
			bfr += ii;
			ffr += ii;
		}
	}
	else { /* if (xhalf && yhalf) */
		for (j = ya; j < yb; j++) {
			for (i = xa; i < xb; i++) {
				pel = ((unsigned int)(ffr[i]+ffr[i+1]+ffr[ii+i]+ffr[ii+i+1]+2))>>2;
				bfr[i] = ((unsigned int)(pel + bfr[i]))>>1;
			}
			bfr += ii;
			ffr += ii;
		}
	}
	return;
}

int motion_decode(vec,pmv)
int vec,pmv;
{
	if (vec > 31) vec -= 64;
	vec += pmv;
	if (!long_vectors) {
		if (vec > 31)
			vec -= 64;
		if (vec < -32)
			vec += 64;
	}
	else {
		if (pmv < -31 && vec < -63)
			vec += 64;
		if (pmv > 32 && vec > 63)
			vec -= 64;
	}
	return vec;
}


int find_pmv(x, y, block,comp)
int x,y,block,comp;
{
	int p1,p2,p3;
	int xin1=0,xin2=0,xin3=0;
	int yin1=0,yin2=0,yin3=0;
	int vec1=0,vec2=0,vec3=0;
	int l8,o8,or8;
	
	x++;y++;
	
	l8 = (modemap[y][x-1] == MODE_INTER4V ? 1 : 0);
	o8 =  (modemap[y-1][x] == MODE_INTER4V ? 1 : 0);
	or8 = (modemap[y-1][x+1] == MODE_INTER4V ? 1 : 0);
	
	switch (block) {
	case 0: 
		vec1 = (l8 ? 2 : 0) ; yin1 = y  ; xin1 = x-1;
		vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
		vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
		break;
	case 1:
		vec1 = (l8 ? 2 : 0) ; yin1 = y  ; xin1 = x-1;
		vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
		vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
		break;
	case 2:
		vec1 = 1            ; yin1 = y  ; xin1 = x;
		vec2 = (o8 ? 4 : 0) ; yin2 = y-1; xin2 = x;
		vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
		break;
	case 3:
		vec1 = (l8 ? 4 : 0) ; yin1 = y  ; xin1 = x-1;
		vec2 = 1            ; yin2 = y  ; xin2 = x;
		vec3 = 2            ; yin3 = y  ; xin3 = x;
		break;
	case 4:
		vec1 = 3            ; yin1 = y  ; xin1 = x;
		vec2 = 1            ; yin2 = y  ; xin2 = x;
		vec3 = 2            ; yin3 = y  ; xin3 = x;
		break;
	default:
		fprintf(stderr,"Illegal block number in find_pmv (getpic.c)\n");
		exit(1);
		break;
	}
	p1 = MV[comp][vec1][yin1][xin1];
	p2 = MV[comp][vec2][yin2][xin2];
	p3 = MV[comp][vec3][yin3][xin3];
	
	if (newgob && (block == 0 || block == 1 || block == 2))
		p2 = NO_VEC;
	
	if (p2 == NO_VEC) { p2 = p3 = p1; }
	
	return p1+p2+p3 - mmax(p1,mmax(p2,p3)) - mmin(p1,mmin(p2,p3));
}



void find_bidir_limits(vec, start, stop, nhv)
int vec;
int *start, *stop, nhv;
{
	/* limits taken from C loop in section G5 in H.263 */
	*start = mmax(0,(-vec+1)/2 - nhv*8);
	*stop = mmin(7,15-(vec+1)/2 - nhv*8);
	
	(*stop)++; /* I use < and not <= in the loop */
}

void find_bidir_chroma_limits(vec, start, stop)
int vec;
int *start, *stop;
{
	
	/* limits taken from C loop in section G5 in H.263 */
	*start = mmax(0,(-vec+1)/2);
	*stop = mmin(7,7-(vec+1)/2);
	
	(*stop)++; /* I use < and not <= in the loop */
	return;
}

void make_edge_image(src,dst,width,height,edge)
unsigned char *src, *dst;
int width,height,edge;
{
	int i,j;
	unsigned char *p1,*p2,*p3,*p4;
	unsigned char *o1,*o2,*o3,*o4;
	
	/* center image */
	p1 = dst;
	o1 = src;
	for (j = 0; j < height;j++) {
		for (i = 0; i < width; i++) {
			*(p1 + i) = *(o1 + i);
		}
		p1 += width + (edge<<1);
		o1 += width;
	}
	
	/* left and right edges */
	p1 = dst-1;
	o1 = src;
	for (j = 0; j < height;j++) {
		for (i = 0; i < edge; i++) {
			*(p1 - i) = *o1;
			*(p1 + width + i + 1) = *(o1 + width - 1);
		}
		p1 += width + (edge<<1);
		o1 += width;
	}    
    
	/* top and bottom edges */
	p1 = dst;
	p2 = dst + (width + (edge<<1))*(height-1);
	o1 = src;
	o2 = src + width*(height-1);
	for (j = 0; j < edge;j++) {
		p1 = p1 - (width + (edge<<1));
		p2 = p2 + (width + (edge<<1));
		for (i = 0; i < width; i++) {
			*(p1 + i) = *(o1 + i);
			*(p2 + i) = *(o2 + i);
		}
	}    
	
	/* corners */
	p1 = dst - (width+(edge<<1)) - 1;
	p2 = p1 + width + 1;
	p3 = dst + (width+(edge<<1))*(height)-1;
	p4 = p3 + width + 1;
	
	o1 = src;
	o2 = o1 + width - 1;
	o3 = src + width*(height-1);
	o4 = o3 + width - 1;
	for (j = 0; j < edge; j++) {
		for (i = 0; i < edge; i++) {
			*(p1 - i) = *o1;
			*(p2 + i) = *o2;
			*(p3 - i) = *o3;
			*(p4 + i) = *o4; 
		}
		p1 = p1 - (width + (edge<<1));
		p2 = p2 - (width + (edge<<1));
		p3 = p3 + width + (edge<<1);
		p4 = p4 + width + (edge<<1);
	}
	
}


void interpolate_image(in, out, width, height)
/* only used for displayed interpolated frames, not reconstructed ones */
unsigned char *in, *out;
int width, height;
{
	
	int x,xx,y,w2;
	
	unsigned char *pp,*ii;
	
	w2 = 2*width;
	
	/* Horizontally */
	pp = out;
	ii = in;
	for (y = 0; y < height-1; y++) {
		for (x = 0,xx=0; x < width-1; x++,xx+=2) {
			*(pp + xx) = *(ii + x);
			*(pp + xx+1) = ((unsigned int)(*(ii + x)  + *(ii + x + 1)))>>1;
			*(pp + w2 + xx) = ((unsigned int)(*(ii + x) + *(ii + x + width)))>>1;
			*(pp + w2 + xx+1) = ((unsigned int)(*(ii + x) + *(ii + x + 1) + 
				*(ii + x + width) + *(ii + x + width + 1)))>>2;
			
		}
		*(pp + w2 - 2) = *(ii + width - 1);
		*(pp + w2 - 1) = *(ii + width - 1);
		*(pp + w2 + w2 - 2) = *(ii + width + width - 1);
		*(pp + w2 + w2 - 1) = *(ii + width + width - 1);
		pp += w2<<1;
		ii += width;
	}
	
	/* last lines */
	for (x = 0,xx=0; x < width-1; x++,xx+=2) {
		*(pp+ xx) = *(ii + x);    
		*(pp+ xx+1) = ((unsigned int)(*(ii + x) + *(ii + x + 1) + 1))>>1;
		*(pp+ w2+ xx) = *(ii + x);    
		*(pp+ w2+ xx+1) = ((unsigned int)(*(ii + x) + *(ii + x + 1) + 1))>>1;
	}
	
	/* bottom right corner pels */
	*(pp + (width<<1) - 2) = *(ii + width -1);
	*(pp + (width<<1) - 1) = *(ii + width -1);
	*(pp + (width<<2) - 2) = *(ii + width -1);
	*(pp + (width<<2) - 1) = *(ii + width -1);
	
	return;
}