vid_sim.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "vid_config.h"
#include "vid_macros.h"

Go to the source code of this file.

Classes
struct	motionvector
struct	point
struct	pict_image
struct	pict
struct	slice
struct	macroblock
struct	mb_structure
struct	bits_counted
struct	results
Defines
#define	MB_SIZE   16
#define	MBC   88
#define	MBR   72
#define	PREF_NULL_VEC   100
#define	PREF_16_VEC   200
#define	PREF_PBDELTA_NULL_VEC   50
#define	PSC   1
#define	PSC_LENGTH   17
#define	ESCAPE   7167
#define	PCT_INTER   1
#define	PCT_INTRA   0
#define	ON   1
#define	OFF   0
#define	SF_SQCIF   1
#define	SF_QCIF   2
#define	SF_CIF   3
#define	SF_4CIF   4
#define	SF_16CIF   5
#define	MODE_INTER   0
#define	MODE_INTER_Q   1
#define	MODE_INTER4V   2
#define	MODE_INTRA   3
#define	MODE_INTRA_Q   4
#define	PBMODE_NORMAL   0
#define	PBMODE_MVDB   1
#define	PBMODE_CBPB_MVDB   2
#define	NO_VEC   999
Typedefs
typedef motionvector	MotionVector
typedef point	Point
typedef pict_image	PictImage
typedef pict	Pict
typedef slice	Slice
typedef macroblock	Macroblock
typedef mb_structure	MB_Structure
typedef bits_counted	Bits
typedef results	Results
Functions
void	Help ()
void	AdvancedHelp ()
int	NextTwoPB (PictImage *p2, PictImage *bim, PictImage *p1, int bskip, int pskip, int seek_dist)
void	PrintSNR (Results *res, int num)
void	PrintResult (Bits *bits, int num_units, int num)
unsigned char *	ReadImage (char *filename, int frame_no, int headerlength)
PictImage *	FillImage (unsigned char *in)
void	WriteImage (PictImage *image, char *filename)
PictImage *	InitImage (int size)
void	FreeImage (PictImage *image)
char *	StripName (char *s)
int *	MB_Encode (MB_Structure *mb_orig, int QP, int I)
int	MB_Decode (int *qcoeff, MB_Structure *mb_recon, int QP, int I)
int	Dct (int *block, int *coeff)
int	idct (int *coeff, int *block)
void	FillLumBlock (int x, int y, PictImage *image, MB_Structure *data)
void	FillChromBlock (int x_curr, int y_curr, PictImage *image, MB_Structure *data)
void	ReconImage (int i, int j, MB_Structure *data, PictImage *recon)
void	CodeOneOrTwo (PictImage *curr, PictImage *B_image, PictImage *prev, PictImage *prev_recon, int QP, int frameskip, Bits *bits, Pict *pic, PictImage *B_recon, PictImage *recon)
PictImage *	CodeOneIntra (PictImage *curr, int QP, Bits *bits, Pict *pic)
void	Dequant (int *qcoeff, int *rcoeff, int QP, int I)
void	Quant (int *coeff, int *qcoeff, int QP, int I)
void	CountBitsCoeff (int *qcoeff, int I, int CBP, Bits *bits, int ncoeffs)
int	CodeCoeff (int Mode, int *qcoeff, int block, int ncoeffs)
int	FindCBP (int *qcoeff, int Mode, int ncoeffs)
void	CountBitsVectors (MotionVector *MV[5][MBR+1][MBC+2], Bits *bits, int i, int j, int Mode, int newgob, Pict *pic)
void	FindPMV (MotionVector *MV[5][MBR+1][MBC+2], int x, int y, int *p0, int *p1, int block, int newgob, int half_pel)
void	ZeroBits (Bits *bits)
void	ZeroRes (Results *res)
void	ZeroVec (MotionVector *MV)
void	MarkVec (MotionVector *MV)
void	CopyVec (MotionVector *MV1, MotionVector *MV2)
int	EqualVec (MotionVector *MV2, MotionVector *MV1)
void	AddBits (Bits *total, Bits *bits)
void	AddRes (Results *total, Results *res, Pict *pic)
void	AddBitsPicture (Bits *bits)
void	FindMB (int x, int y, unsigned char *image, int MB[16][16])
MB_Structure *	MB_Recon (PictImage *prev_recon, MB_Structure *diff, int x_curr, int y_curr, MotionVector *MV)
MB_Structure *	Predict (PictImage *curr, PictImage *prev_recon, int x_curr, int y_curr, MotionVector *MV)
unsigned char *	InterpolateImage (unsigned char *image, int w, int h)
void	MotionEstimatePicture (unsigned char *curr, unsigned char *prev, unsigned char *prev_ipol, int seek_dist, MotionVector *MV[5][MBR+1][MBC+2], int gobsync)
void	MotionEstimation (unsigned char *curr, unsigned char *prev, int x_curr, int y_curr, int xoff, int yoff, int seek_dist, MotionVector *MV[5][MBR+1][MBC+2], int *sad_0)
unsigned char *	LoadArea (unsigned char *im, int x, int y, int x_size, int y_size, int lx)
int	SAD_Macroblock (unsigned char *ii, unsigned char *act_block, int h_length, int Min_FRAME)
int	SAD_MB_Bidir (unsigned char *ii, unsigned char *aa, unsigned char *bb, int width, int min_sofar)
int	SAD_Block (unsigned char *ii, unsigned char *act_block, int h_length, int min_sofar)
int	SAD_MB_integer (int *ii, int *act_block, int h_length, int min_sofar)
MB_Structure *	Predict_P (PictImage *curr_image, PictImage *prev_image, unsigned char *prev_ipol, int x_curr, int y_curr, MotionVector *fr[5][MBR+1][MBC+2], int PB)
MB_Structure *	Predict_B (PictImage *curr_image, PictImage *prev_image, unsigned char *prev_ipol, int x_curr, int y_curr, MotionVector *fr[5][MBR+1][MBC+2], MB_Structure *recon_P, int TR, int TRB)
void	Clip (MB_Structure *data)
void	FindForwLumPredPB (unsigned char *prev_ipol, int x_curr, int y_curr, MotionVector *fr, int *pred, int TRD, int TRB, int bdx, int bdy, int bs, int comp)
void	FindBiDirLumPredPB (int *recon_P, MotionVector *fr, int *pred, int TRD, int TRB, int bdx, int bdy, int nh, int nv)
void	FindBiDirChrPredPB (MB_Structure *recon_P, int dx, int dy, MB_Structure *pred)
void	FindBiDirLimits (int vec, int *start, int *stop, int nhv)
void	FindBiDirChromaLimits (int vec, int *start, int *stop)
void	BiDirPredBlock (int xstart, int xstop, int ystart, int ystop, int xvec, int yvec, int *recon, int *pred, int bl)
void	DoPredChrom_P (int x_curr, int y_curr, int dx, int dy, PictImage *curr, PictImage *prev, MB_Structure *pred_error)
void	FindHalfPel (int x, int y, MotionVector *MV, unsigned char *prev, int *curr, int bs, int comp)
void	FindPred (int x, int y, MotionVector *fr, unsigned char *prev, int *pred, int bs, int comp)
void	FindPredOBMC (int x, int y, MotionVector *MV[5][MBR+1][MBC+2], unsigned char *prev, int *pred, int comp, int PB)
MB_Structure *	MB_Recon_P (PictImage *prev_image, unsigned char *prev_ipol, MB_Structure *diff, int x_curr, int y_curr, MotionVector *MV[5][MBR+1][MBC+2], int PB)
MB_Structure *	MB_Recon_B (PictImage *prev, MB_Structure *diff, unsigned char *prev_ipol, int x_curr, int y_curr, MotionVector *MV[5][MBR+1][MBC+2], MB_Structure *recon_P, int TR, int TRB)
void	ReconLumBlock_P (int x, int y, MotionVector *fr, unsigned char *prev, int *data, int bs, int comp)
void	ReconChromBlock_P (int x_curr, int y_curr, int dx, int dy, PictImage *prev, MB_Structure *data)
void	FindChromBlock_P (int x_curr, int y_curr, int dx, int dy, PictImage *prev, MB_Structure *data)
void	ComputeSNR (PictImage *im1, PictImage *im2, Results *res, int write)
void	ZeroMBlock (MB_Structure *data)
int	CountBitsPicture (Pict *pic)
void	CountBitsMB (int Mode, int COD, int CBP, int CBPB, Pict *pic, Bits *bits)
int	CountBitsSlice (int slice, int quant)
int	ChooseMode (unsigned char *curr, int x_pos, int y_pos, int min_SAD)
int	ModifyMode (int Mode, int dquant)
int *	InterleaveCoeff (int *qp, int *qb, int bs)
void	MakeEdgeImage (unsigned char *src, unsigned char *dst, int width, int height, int edge)
void	BitPrint (int length, int val, char *bit)
int	UpdateQuantizer (int mb, float QP_mean, int pict_type, float bit_rate, int mb_width, int mb_height, int bitcount)
int	InitializeQuantizer (int pict_type, float bit_rate, float target_frame_rate, float QP_mean)
void	InitializeRateControl ()
void	UpdateRateControl (int bits)
void	init_idctref (void)
void	idctref (int *coeff, int *block)
void	Count_sac_BitsCoeff (int *qcoeff, int I, int CBP, Bits *bits, int ncoeffs)
int	Code_sac_Coeff (int Mode, int *qcoeff, int block, int ncoeffs)
int	CodeTCoef (int mod_index, int position, int intra)
void	Count_sac_BitsVectors (MotionVector *MV[5][MBR+1][MBC+2], Bits *bits, int i, int j, int Mode, int newgob, Pict *pic)
void	Count_sac_BitsMB (int Mode, int COD, int CBP, int CBPB, Pict *pic, Bits *bits)
int	AR_Encode (int index, int cumul_freq[])
int	indexfn (int value, int table[], int max)
int	bit_opp_bits (int)
int	bit_in_psc_layer (int)
int	encoder_flush ()
void	initbits ()
void	putbits (int, int)
int	alignbits ()
int	bitcount ()

---

Define Documentation

#define ESCAPE   7167

Definition at line 139 of file vid_sim.h. Referenced by Code_sac_Coeff().

#define MB_SIZE   16

Definition at line 77 of file vid_sim.h. Referenced by ChooseMode(), CodeOneIntra(), CodeOneOrTwo(), FindPredOBMC(), MB_Recon_B(), MB_Recon_P(), MotionEstimatePicture(), MotionEstimation(), NextTwoPB(), Predict_B(), and Predict_P().

#define MBC   88

Definition at line 108 of file vid_sim.h. Referenced by CodeOneOrTwo(), and NextTwoPB().

#define MBR   72

Definition at line 109 of file vid_sim.h. Referenced by CodeOneOrTwo(), and NextTwoPB().

#define MODE_INTER   0

Definition at line 152 of file vid_sim.h. Referenced by CodeOneOrTwo(), MB_Recon_P(), and Predict_P().

#define MODE_INTER4V   2

Definition at line 154 of file vid_sim.h. Referenced by FindPredOBMC().

#define MODE_INTER_Q   1

Definition at line 153 of file vid_sim.h. Referenced by CodeOneOrTwo().

#define MODE_INTRA   3

Definition at line 155 of file vid_sim.h. Referenced by Code_sac_Coeff(), CodeCoeff(), CodeOneOrTwo(), Count_sac_BitsCoeff(), Count_sac_BitsMB(), CountBitsCoeff(), CountBitsMB(), Dequant(), FindCBP(), FindPredOBMC(), Predict_B(), and Quant().

#define MODE_INTRA_Q   4

Definition at line 156 of file vid_sim.h. Referenced by FindPredOBMC().

#define NO_VEC   999

Definition at line 162 of file vid_sim.h.

#define OFF   0

Definition at line 144 of file vid_sim.h.

#define ON   1

Definition at line 143 of file vid_sim.h.

#define PBMODE_CBPB_MVDB   2

Definition at line 160 of file vid_sim.h. Referenced by Count_sac_BitsMB(), and CountBitsMB().

#define PBMODE_MVDB   1

Definition at line 159 of file vid_sim.h. Referenced by Count_sac_BitsMB(), Count_sac_BitsVectors(), CountBitsMB(), and CountBitsVectors().

#define PBMODE_NORMAL   0

Definition at line 158 of file vid_sim.h. Referenced by Count_sac_BitsMB(), and CountBitsMB().

#define PCT_INTER   1

Definition at line 141 of file vid_sim.h. Referenced by CodeOneOrTwo().

#define PCT_INTRA   0

Definition at line 142 of file vid_sim.h.

#define PREF_16_VEC   200

Definition at line 113 of file vid_sim.h.

#define PREF_NULL_VEC   100

Definition at line 112 of file vid_sim.h.

#define PREF_PBDELTA_NULL_VEC   50

Definition at line 114 of file vid_sim.h.

#define PSC   1

Definition at line 136 of file vid_sim.h. Referenced by CountBitsPicture(), and CountBitsSlice().

#define PSC_LENGTH   17

Definition at line 137 of file vid_sim.h. Referenced by CountBitsPicture(), and CountBitsSlice().

#define SF_16CIF   5

Definition at line 150 of file vid_sim.h.

#define SF_4CIF   4

Definition at line 149 of file vid_sim.h.

#define SF_CIF   3

Definition at line 148 of file vid_sim.h.

#define SF_QCIF   2

Definition at line 147 of file vid_sim.h.

#define SF_SQCIF   1

Definition at line 146 of file vid_sim.h.

---

Typedef Documentation

typedef struct bits_counted Bits

Referenced by AddBits(), AddBitsPicture(), code_video(), CodeOneIntra(), CodeOneOrTwo(), Count_sac_BitsCoeff(), Count_sac_BitsMB(), Count_sac_BitsVectors(), CountBitsCoeff(), CountBitsMB(), CountBitsVectors(), new_video_codec(), PrintResult(), and ZeroBits().

typedef struct macroblock Macroblock

typedef struct mb_structure MB_Structure

Referenced by Clip(), CodeOneIntra(), CodeOneOrTwo(), DoPredChrom_P(), FillChromBlock(), FillLumBlock(), FindBiDirChrPredPB(), FindChromBlock_P(), MB_Decode(), MB_Encode(), MB_Recon_B(), MB_Recon_P(), Predict_B(), Predict_P(), ReconChromBlock_P(), ReconImage(), and ZeroMBlock().

typedef struct motionvector MotionVector

Referenced by CodeOneOrTwo(), CopyVec(), Count_sac_BitsVectors(), CountBitsVectors(), EqualVec(), FindBiDirLumPredPB(), FindForwLumPredPB(), FindHalfPel(), FindPMV(), FindPred(), FindPredOBMC(), MarkVec(), MB_Recon_B(), MB_Recon_P(), MotionEstimatePicture(), MotionEstimation(), NextTwoPB(), Predict_B(), Predict_P(), ReconLumBlock_P(), and ZeroVec().

typedef struct pict Pict

Referenced by AddRes(), CodeOneIntra(), CodeOneOrTwo(), Count_sac_BitsMB(), Count_sac_BitsVectors(), CountBitsMB(), CountBitsPicture(), CountBitsVectors(), FillImage(), and new_video_codec().

typedef struct pict_image PictImage

Referenced by CodeOneIntra(), CodeOneOrTwo(), ComputeSNR(), DoPredChrom_P(), FillChromBlock(), FillImage(), FillLumBlock(), FindChromBlock_P(), FreeImage(), InitImage(), MB_Recon_B(), MB_Recon_P(), NextTwoPB(), Predict_B(), Predict_P(), ReconChromBlock_P(), ReconImage(), and WriteImage().

typedef struct point Point

Referenced by FindHalfPel().

typedef struct results Results

Referenced by AddRes(), ComputeSNR(), new_video_codec(), PrintSNR(), and ZeroRes().

typedef struct slice Slice

---

Function Documentation

void AddBits (  Bits *  total, Bits *  bits )

Definition at line 1069 of file vid_countbit.c. References Bits, bits_counted::C, bits_counted::CBPB, bits_counted::CBPCM, bits_counted::CBPY, bits_counted::COD, bits_counted::DQUANT, bits_counted::header, bits_counted::MODB, bits_counted::no_inter, bits_counted::no_inter4v, bits_counted::no_intra, bits_counted::total, bits_counted::vec, and bits_counted::Y. Referenced by code_video(). { total->Y += bits->Y; total->C += bits->C; total->vec += bits->vec; total->CBPY += bits->CBPY; total->CBPCM += bits->CBPCM; total->MODB += bits->MODB; total->CBPB += bits->CBPB; total->COD += bits->COD; total->DQUANT += bits->DQUANT; total->header += bits->header; total->total += bits->total; total->no_inter += bits->no_inter; total->no_inter4v += bits->no_inter4v; total->no_intra += bits->no_intra; return; }

void AddBitsPicture (  Bits *  bits  )

Definition at line 1096 of file vid_countbit.c. References Bits, bits_counted::C, bits_counted::CBPB, bits_counted::CBPCM, bits_counted::CBPY, bits_counted::COD, bits_counted::DQUANT, bits_counted::header, bits_counted::MODB, bits_counted::total, bits_counted::vec, and bits_counted::Y. Referenced by code_video(), and CodeOneOrTwo(). { bits->total = bits->Y + bits->C + bits->vec + bits->CBPY + bits->CBPCM + bits->MODB + bits->CBPB + bits->COD + bits->DQUANT + bits->header ; }

void AddRes (  Results *  total, Results *  res, Pict *  pic )

Definition at line 1087 of file vid_countbit.c. References Pict, pict::QP_mean, results::QP_mean, Results, results::SNR_Cb, results::SNR_Cr, and results::SNR_l. Referenced by code_video(). { total->SNR_l += res->SNR_l; total->SNR_Cr += res->SNR_Cr; total->SNR_Cb += res->SNR_Cb; total->QP_mean += pic->QP_mean; return; }

void AdvancedHelp (   )

int alignbits (   )

Definition at line 115 of file vid_putbits.c. References video_codec::outcnt, putbits(), and VidSt. Referenced by code_video(). { int ret_value; if ((VidSt->outcnt)!=8) { ret_value = (VidSt->outcnt); /* outcnt is reset in call to putbits () */ putbits ((VidSt->outcnt), 0); return ret_value; } else return 0; }

int AR_Encode (  int  index, int  cumul_freq[] )

Definition at line 86 of file vid_sac.c. References bit_opp_bits(), bitcount(), low, and q1. Referenced by Code_sac_Coeff(), CodeTCoef(), Count_sac_BitsMB(), and Count_sac_BitsVectors(). { int bitcount=0; if (index<0) return -1; /* Escape Code */ length = high - low + 1; high = low - 1 + (length * cumul_freq[index]) / cumul_freq[0]; low += (length * cumul_freq[index+1]) / cumul_freq[0]; for ( ; ; ) { if (high < q2) { bitcount+=bit_opp_bits(0); } else if (low >= q2) { bitcount+=bit_opp_bits(1); low -= q2; high -= q2; } else if (low >= q1 && high < q3) { opposite_bits += 1; low -= q1; high -= q1; } else break; low *= 2; high = 2*high+1; } return bitcount; }

void BiDirPredBlock (  int  xstart, int  xstop, int  ystart, int  ystop, int  xvec, int  yvec, int *  recon, int *  pred, int  bl )

Definition at line 607 of file vid_pred.c. References mmax, and mmin. Referenced by FindBiDirChrPredPB(), and FindBiDirLumPredPB(). { int i,j,pel; int xint, yint; int xh, yh; xint = xvec>>1; xh = xvec - 2*xint; yint = yvec>>1; yh = yvec - 2*yint; if (!xh && !yh) { for (j = ystart; j <= ystop; j++) { for (i = xstart; i <= xstop; i++) { pel = *(recon +(j+yint)*bl + i+xint); *(pred + j*bl + i) = (mmin(255,mmax(0,pel)) + *(pred + j*bl + i))>>1; } } } else if (!xh && yh) { for (j = ystart; j <= ystop; j++) { for (i = xstart; i <= xstop; i++) { pel = (*(recon +(j+yint)*bl + i+xint) + *(recon +(j+yint+yh)*bl + i+xint) + 1)>>1; *(pred + j*bl + i) = (pel + *(pred + j*bl + i))>>1; } } } else if (xh && !yh) { for (j = ystart; j <= ystop; j++) { for (i = xstart; i <= xstop; i++) { pel = (*(recon +(j+yint)*bl + i+xint) + *(recon +(j+yint)*bl + i+xint+xh) + 1)>>1; *(pred + j*bl + i) = (pel + *(pred + j*bl + i))>>1; } } } else { /* xh && yh */ for (j = ystart; j <= ystop; j++) { for (i = xstart; i <= xstop; i++) { pel = (*(recon +(j+yint)*bl + i+xint) + *(recon +(j+yint+yh)*bl + i+xint) + *(recon +(j+yint)*bl + i+xint+xh) + *(recon +(j+yint+yh)*bl + i+xint+xh)+2)>>2; *(pred + j*bl + i) = (pel + *(pred + j*bl + i))>>1; } } } return; }

int bit_in_psc_layer (  int   )

Definition at line 190 of file vid_sac.c. References bitcount(), putbits(), video_codec::tf, video_codec::trace, and VidSt. Referenced by bit_opp_bits(). { void putbits (int, int); int bitcount = 0; if (zerorun > 13) { if ((VidSt->trace)) fprintf((VidSt->tf), "PSC emulation ... Bit stuffed.\n"); putbits (1, 1); bitcount++; zerorun = 0; } putbits (1, bit); bitcount++; if (bit) zerorun = 0; else zerorun++; return bitcount; }

int bit_opp_bits (  int   )

Definition at line 119 of file vid_sac.c. References bit_in_psc_layer(), and bitcount(). Referenced by AR_Encode(), and encoder_flush(). { int bitcount=0; bitcount = bit_in_psc_layer(bit); while(opposite_bits > 0){ bitcount += bit_in_psc_layer(!bit); opposite_bits--; } return bitcount; }

int bitcount (   )

Definition at line 130 of file vid_putbits.c. References video_codec::bytecnt, video_codec::outcnt, and VidSt. Referenced by AR_Encode(), bit_in_psc_layer(), bit_opp_bits(), encoder_flush(), and UpdateQuantizer(). { return 8*(VidSt->bytecnt) + (8-(VidSt->outcnt)); }

void BitPrint (  int  length, int  val, char *  bit )

Definition at line 137 of file vid_putbits.c. Referenced by putbits(). { int m; m = length; bit[0] = '"'; while (m--) { bit[length-m] = (val & (1<<m)) ? '1' : '0'; } bit[length+1] = '"'; bit[length+2] = '\n'; bit[length+3] = '\0'; return; }

int ChooseMode (  unsigned char *  curr, int  x_pos, int  y_pos, int  min_SAD )

Definition at line 1509 of file vid_pred.c. References MB_SIZE, video_codec::pels, and VidSt. Referenced by MotionEstimatePicture(). { int i,j; int MB_mean = 0, A = 0; int y_off; for (j = 0; j < MB_SIZE; j++) { y_off = (y_pos + j) * (VidSt->pels); for (i = 0; i < MB_SIZE; i++) { MB_mean += *(curr + x_pos + i + y_off); } } MB_mean /= (MB_SIZE*MB_SIZE); for (j = 0; j < MB_SIZE; j++) { y_off = (y_pos + j) * (VidSt->pels); for (i = 0; i < MB_SIZE; i++) { A += abs( *(curr + x_pos + i + y_off) - MB_mean ); } } if (A < (min_SAD - 500)) return MODE_INTRA; else return MODE_INTER; }

void Clip (  MB_Structure *  data  )

Definition at line 1076 of file vid_coder.c. References mb_structure::Cb, mb_structure::Cr, data, mb_structure::lum, MB_Structure, mmax, and mmin. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int m,n; for (n = 0; n < 16; n++) { for (m = 0; m < 16; m++) { data->lum[n][m] = mmin(255,mmax(0,data->lum[n][m])); } } for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { data->Cr[n][m] = mmin(255,mmax(0,data->Cr[n][m])); data->Cb[n][m] = mmin(255,mmax(0,data->Cb[n][m])); } } }

int Code_sac_Coeff (  int  Mode, int *  qcoeff, int  block, int  ncoeffs )

Definition at line 526 of file vid_countbit.c. References AR_Encode(), CodeTCoef(), cumf_INTRADC, cumf_LAST, cumf_LAST_intra, cumf_LEVEL, cumf_LEVEL_intra, cumf_RUN, cumf_RUN_intra, cumf_SIGN, ESCAPE, indexfn(), intradctab, lasttab, leveltab, MODE_INTRA, position, runtab, signtab, tcoeftab, video_codec::tf, video_codec::trace, and VidSt. Referenced by Count_sac_BitsCoeff(). { int j, bits, mod_index, intra; int prev_run, run, prev_level, level, first, prev_position, position; int prev_ind, ind, prev_s, s, length; run = bits = 0; first = 1; position = 0; intra = 0; level = s = ind = 0; prev_run = prev_level = prev_ind = prev_s = prev_position = 0; intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q); for (j = block*ncoeffs; j< (block + 1)*ncoeffs; j++) { if (!(j%ncoeffs) && intra) { if ((VidSt->trace)) { fprintf((VidSt->tf),"DC: "); } if (qcoeff[block*ncoeffs]!=128) mod_index = indexfn(qcoeff[block*ncoeffs],intradctab,254); else mod_index = indexfn(255,intradctab,254); bits += AR_Encode(mod_index, cumf_INTRADC); } else { s = 0; /* Increment run if coeff is zero */ if ((level = qcoeff[j]) == 0) { run++; } else { /* code run & level and count bits */ if (level < 0) { s = 1; level = -level; } ind = level | run<<4; ind = ind | 0<<12; /* Not last coeff */ position++; if (!first) { mod_index = indexfn(prev_ind, tcoeftab, 103); if (prev_level < 13 && prev_run < 64) length = CodeTCoef(mod_index, prev_position, intra); else length = -1; if (length == -1) { /* Escape coding */ if ((VidSt->trace)) { fprintf((VidSt->tf),"Escape coding:\n"); } if (prev_s == 1) {prev_level = (prev_level^0xff)+1;} mod_index = indexfn(ESCAPE, tcoeftab, 103); bits += CodeTCoef(mod_index, prev_position, intra); if (intra) bits += AR_Encode(indexfn(0, lasttab, 2), cumf_LAST_intra); else bits += AR_Encode(indexfn(0, lasttab, 2), cumf_LAST); if (intra) bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN_intra); else bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN); if (intra) bits += AR_Encode(indexfn(prev_level, leveltab, 254), cumf_LEVEL_intra); else bits += AR_Encode(indexfn(prev_level, leveltab, 254), cumf_LEVEL); } else { bits += AR_Encode(indexfn(prev_s, signtab, 2), cumf_SIGN); bits += length; } } prev_run = run; prev_s = s; prev_level = level; prev_ind = ind; prev_position = position; run = first = 0; } } } /* Encode Last Coefficient */ if (!first) { if ((VidSt->trace)) { fprintf((VidSt->tf),"Last coeff: "); } prev_ind = prev_ind | 1<<12; /* last coeff */ mod_index = indexfn(prev_ind, tcoeftab, 103); if (prev_level < 13 && prev_run < 64) length = CodeTCoef(mod_index, prev_position, intra); else length = -1; if (length == -1) { /* Escape coding */ if ((VidSt->trace)) { fprintf((VidSt->tf),"Escape coding:\n"); } if (prev_s == 1) {prev_level = (prev_level^0xff)+1;} mod_index = indexfn(ESCAPE, tcoeftab, 103); bits += CodeTCoef(mod_index, prev_position, intra); if (intra) bits += AR_Encode(indexfn(1, lasttab, 2), cumf_LAST_intra); else bits += AR_Encode(indexfn(1, lasttab, 2), cumf_LAST); if (intra) bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN_intra); else bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN); if (intra) bits += AR_Encode(indexfn(prev_level, leveltab, 254), cumf_LEVEL_intra); else bits += AR_Encode(indexfn(prev_level, leveltab, 254), cumf_LEVEL); } else { bits += AR_Encode(indexfn(prev_s, signtab, 2), cumf_SIGN); bits += length; } } /* last coeff */ return bits; }

int CodeCoeff (  int  Mode, int *  qcoeff, int  block, int  ncoeffs )

Definition at line 361 of file vid_countbit.c. References MODE_INTRA, put_coeff(), putbits(), video_codec::tf, video_codec::trace, and VidSt. Referenced by CountBitsCoeff(). { int j, bits; int prev_run, run, prev_level, level, first; int prev_s, s, length; run = bits = 0; first = 1; prev_run = prev_level = level = s = prev_s = 0; if ((VidSt->trace)) { fprintf((VidSt->tf),"Coeffs block %d:\n",block); } for (j = block*ncoeffs; j< (block + 1)*ncoeffs; j++) { /* Do this block's DC-coefficient first */ if (!(j%ncoeffs) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)) { /* DC coeff */ if ((VidSt->trace)) { fprintf((VidSt->tf),"DC: "); } if (qcoeff[block*ncoeffs] != 128) putbits(8,qcoeff[block*ncoeffs]); else putbits(8,255); bits += 8; } else { /* AC coeff */ s = 0; /* Increment run if coeff is zero */ if ((level = qcoeff[j]) == 0) { run++; } else { /* code run & level and count bits */ if (level < 0) { s = 1; level = -level; } if (!first) { /* Encode the previous coefficient */ if (prev_level < 13 && prev_run < 64) length = put_coeff (prev_run, prev_level, 0); else length = 0; if (length == 0) { /* Escape coding */ if ((VidSt->trace)) { fprintf((VidSt->tf),"Escape code: "); } if (prev_s == 1) {prev_level = (prev_level^0xff)+1;} putbits(7,3); /* Escape code */ if ((VidSt->trace)) fprintf((VidSt->tf),"last: "); putbits(1,0); if ((VidSt->trace)) fprintf((VidSt->tf),"run: "); putbits(6,prev_run); if ((VidSt->trace)) fprintf((VidSt->tf),"level: "); putbits(8,prev_level); bits += 22; } else { putbits(1,prev_s); bits += length + 1; } } prev_run = run; prev_s = s; prev_level = level; run = first = 0; } } } /* Encode the last coeff */ if (!first) { if ((VidSt->trace)) { fprintf((VidSt->tf),"Last coeff: "); } if (prev_level < 13 && prev_run < 64) length = put_coeff (prev_run, prev_level, 1); else length = 0; if (length == 0) { /* Escape coding */ if ((VidSt->trace)) { fprintf((VidSt->tf),"Escape code: "); } if (prev_s == 1) {prev_level = (prev_level^0xff)+1;} putbits (7,3); /* Escape code */ if ((VidSt->trace)) fprintf((VidSt->tf),"last: "); putbits(1,1); if ((VidSt->trace)) fprintf((VidSt->tf),"run: "); putbits(6,prev_run); if ((VidSt->trace)) fprintf((VidSt->tf),"level: "); putbits(8,prev_level); bits += 22; } else { putbits(1,prev_s); bits += length + 1; } } return bits; }

PictImage* CodeOneIntra (  PictImage *  curr, int  QP, Bits *  bits, Pict *  pic )

Definition at line 435 of file vid_coder.c. References Bits, Clip(), Count_sac_BitsCoeff(), Count_sac_BitsMB(), CountBitsCoeff(), CountBitsMB(), CountBitsPicture(), CountBitsSlice(), data, FillChromBlock(), FillLumBlock(), FindCBP(), bits_counted::header, InitImage(), video_codec::lines, pict::MB, MB_Decode(), MB_Encode(), MB_SIZE, MB_Structure, bits_counted::no_intra, video_codec::pels, Pict, PictImage, pict::QP_mean, pict::QUANT, ReconImage(), video_codec::syntax_arith_coding, pict::use_gobsync, VidSt, and ZeroBits(). Referenced by code_video(). { PictImage *recon; MB_Structure *data = (MB_Structure *)malloc(sizeof(MB_Structure)); int *qcoeff; int Mode = MODE_INTRA; int CBP,COD; int i,j; recon = InitImage((VidSt->pels)*(VidSt->lines)); ZeroBits(bits); pic->QUANT = QP; bits->header += CountBitsPicture(pic); COD = 0; /* Every block is coded in Intra frame */ for ( j = 0; j < (VidSt->lines)/MB_SIZE; j++) { /* insert sync in *every* slice if use_gobsync is chosen */ if (pic->use_gobsync && j != 0) bits->header += CountBitsSlice(j,QP); for ( i = 0; i < (VidSt->pels)/MB_SIZE; i++) { pic->MB = i + j * ((VidSt->pels)/MB_SIZE); bits->no_intra++; FillLumBlock(i*MB_SIZE, j*MB_SIZE, curr, data); FillChromBlock(i*MB_SIZE, j*MB_SIZE, curr, data); qcoeff = MB_Encode(data, QP, Mode); CBP = FindCBP(qcoeff,Mode,64); if (!(VidSt->syntax_arith_coding)) { CountBitsMB(Mode,COD,CBP,0,pic,bits); CountBitsCoeff(qcoeff, Mode, CBP,bits,64); } else { Count_sac_BitsMB(Mode,COD,CBP,0,pic,bits); Count_sac_BitsCoeff(qcoeff, Mode, CBP,bits,64); } MB_Decode(qcoeff, data, QP, Mode); Clip(data); ReconImage(i,j,data,recon); free(qcoeff); } } pic->QP_mean = (float)QP; free(data); return recon; }

void CodeOneOrTwo (  PictImage *  curr, PictImage *  B_image, PictImage *  prev, PictImage *  prev_recon, int  QP, int  frameskip, Bits *  bits, Pict *  pic, PictImage *  B_recon, PictImage *  recon )

Definition at line 73 of file vid_coder.c. References AddBitsPicture(), pict::bit_rate, Bits, pict::BQUANT, pict_image::Cb, Clip(), Count_sac_BitsCoeff(), Count_sac_BitsMB(), Count_sac_BitsVectors(), CountBitsCoeff(), CountBitsMB(), CountBitsPicture(), CountBitsSlice(), CountBitsVectors(), pict_image::Cr, pict::DQUANT, EqualVec(), FillChromBlock(), FillLumBlock(), FindCBP(), FreeImage(), bits_counted::header, InitializeQuantizer(), InitImage(), InterpolateImage(), video_codec::lines, video_codec::long_vectors, pict_image::lum, MakeEdgeImage(), MarkVec(), pict::MB, MB_Decode(), MB_Encode(), MB_Recon_B(), MB_Recon_P(), MB_SIZE, MB_Structure, MBC, MBR, mmax, mmin, pict::MODB, motionvector::Mode, MODE_INTER, MODE_INTER_Q, MODE_INTRA, ModifyMode(), MotionEstimatePicture(), MotionVector, video_codec::mv_outside_frame, bits_counted::no_inter, bits_counted::no_inter4v, bits_counted::no_intra, pict::PB, PCT_INTER, video_codec::pels, Pict, PictImage, Predict_B(), Predict_P(), pict::QP_mean, pict::QUANT, ReconImage(), pict::seek_dist, video_codec::syntax_arith_coding, pict::target_frame_rate, bits_counted::total, pict::TRB, UpdateQuantizer(), pict::use_gobsync, VidSt, motionvector::x, motionvector::y, ZeroBits(), ZeroMBlock(), and ZeroVec(). Referenced by code_video(). { unsigned char *prev_ipol,*pi_edge=NULL,*pi,*orig_lum; PictImage *prev_recon=NULL, *pr_edge=NULL; MotionVector *MV[6][MBR+1][MBC+2]; MotionVector ZERO = {0,0,0,0,0}; MB_Structure *recon_data_P; MB_Structure *recon_data_B=NULL; MB_Structure *diff; int *qcoeff_P; int *qcoeff_B=NULL; int Mode,B; int CBP, CBPB=0; int bquant[] = {5,6,7,8}; int QP_B; int newgob; int i,j,k; /* buffer control vars */ float QP_cumulative = (float)0.0; int abs_mb_num = 0, QuantChangePostponed = 0; int QP_new, QP_prev, dquant, QP_xmitted=QP; ZeroBits(bits); /* interpolate image */ if ((VidSt->mv_outside_frame)) { if ((VidSt->long_vectors)) { /* If the Extended Motion Vector range is used, motion vectors may point further out of the picture than in the normal range, and the edge images will have to be made larger */ B = 16; } else { /* normal range */ B = 8; } pi_edge = (unsigned char *)malloc(sizeof(char)*((VidSt->pels)+4*B)*((VidSt->lines)+4*B)); if (pi_edge == NULL) { fprintf(stderr,"Couldn't allocate memory for pi_edge\n"); exit(-1); } MakeEdgeImage(pr->lum,pi_edge + ((VidSt->pels) + 4*B)*2*B+2*B,(VidSt->pels),(VidSt->lines),2*B); pi = InterpolateImage(pi_edge, (VidSt->pels)+4*B, (VidSt->lines)+4*B); free(pi_edge); prev_ipol = pi + (2*(VidSt->pels) + 8*B) * 4*B + 4*B; /* luma of non_interpolated image */ pr_edge = InitImage(((VidSt->pels)+4*B)*((VidSt->lines)+4*B)); MakeEdgeImage(prev->lum, pr_edge->lum + ((VidSt->pels) + 4*B)*2*B+2*B, (VidSt->pels),(VidSt->lines),2*B); orig_lum = pr_edge->lum + ((VidSt->pels) + 4*B)*2*B+2*B; /* non-interpolated image */ MakeEdgeImage(pr->lum,pr_edge->lum + ((VidSt->pels)+4*B)*2*B + 2*B,(VidSt->pels),(VidSt->lines),2*B); MakeEdgeImage(pr->Cr,pr_edge->Cr + ((VidSt->pels)/2 + 2*B)*B + B,(VidSt->pels)/2,(VidSt->lines)/2,B); MakeEdgeImage(pr->Cb,pr_edge->Cb + ((VidSt->pels)/2 + 2*B)*B + B,(VidSt->pels)/2,(VidSt->lines)/2,B); prev_recon = (PictImage *)malloc(sizeof(PictImage)); prev_recon->lum = pr_edge->lum + ((VidSt->pels) + 4*B)*2*B + 2*B; prev_recon->Cr = pr_edge->Cr + ((VidSt->pels)/2 + 2*B)*B + B; prev_recon->Cb = pr_edge->Cb + ((VidSt->pels)/2 + 2*B)*B + B; } else { pi = InterpolateImage(pr->lum,(VidSt->pels),(VidSt->lines)); prev_ipol = pi; prev_recon = pr; orig_lum = prev->lum; } /* mark PMV's outside the frame */ for (i = 1; i < ((VidSt->pels)>>4)+1; i++) { for (k = 0; k < 6; k++) { MV[k][0][i] = (MotionVector *)malloc(sizeof(MotionVector)); MarkVec(MV[k][0][i]); } MV[0][0][i]->Mode = MODE_INTRA; } /* zero out PMV's outside the frame */ for (i = 0; i < ((VidSt->lines)>>4)+1; i++) { for (k = 0; k < 6; k++) { MV[k][i][0] = (MotionVector *)malloc(sizeof(MotionVector)); ZeroVec(MV[k][i][0]); MV[k][i][((VidSt->pels)>>4)+1] = (MotionVector *)malloc(sizeof(MotionVector)); ZeroVec(MV[k][i][((VidSt->pels)>>4)+1]); } MV[0][i][0]->Mode = MODE_INTRA; MV[0][i][((VidSt->pels)>>4)+1]->Mode = MODE_INTRA; } /* Integer and half pel motion estimation */ MotionEstimatePicture(curr->lum,prev_recon->lum,prev_ipol, pic->seek_dist,MV, pic->use_gobsync); /* note: integer pel motion estimation is now based on previous reconstructed image, not the previous original image. We have found that this works better for some sequences and not worse for others. Note that it can not easily be changed back by substituting prev_recon->lum with orig_lum in the line above, because SAD for zero vector is not re-calculated in the half pel search. The half pel search has always been based on the previous reconstructed image */ if (pic->bit_rate != 0) { /* Initialization routine for Rate Control */ QP_new = InitializeQuantizer(PCT_INTER, (float)pic->bit_rate, (pic->PB ? pic->target_frame_rate/2 : pic->target_frame_rate), pic->QP_mean); QP_xmitted = QP_prev = QP_new; } else { QP_new = QP_xmitted = QP_prev = QP; /* Copy the passed value of QP */ } dquant = 0; for ( j = 0; j < (VidSt->lines)/MB_SIZE; j++) { if (pic->bit_rate != 0) { /* QP updated at the beginning of each row */ AddBitsPicture(bits); QP_new = UpdateQuantizer(abs_mb_num, pic->QP_mean, PCT_INTER, (float)pic->bit_rate, (VidSt->pels)/MB_SIZE, (VidSt->lines)/MB_SIZE, bits->total); } newgob = 0; if (j == 0) { pic->QUANT = QP_new; bits->header += CountBitsPicture(pic); QP_xmitted = QP_prev = QP_new; } else if (pic->use_gobsync && j%pic->use_gobsync == 0) { bits->header += CountBitsSlice(j,QP_new); /* insert gob sync */ QP_xmitted = QP_prev = QP_new; newgob = 1; } for ( i = 0; i < (VidSt->pels)/MB_SIZE; i++) { /* Update of dquant, check and correct its limit */ dquant = QP_new - QP_prev; if (dquant != 0 && i != 0 && MV[0][j+1][i+1]->Mode == MODE_INTER4V) { /* It is not possible to change the quantizer and at the same time use 8x8 vectors. Turning off 8x8 vectors is not possible at this stage because the previous macroblock encoded assumed this one should use 8x8 vectors. Therefore the change of quantizer is postponed until the first MB without 8x8 vectors */ dquant = 0; QP_xmitted = QP_prev; QuantChangePostponed = 1; } else { QP_xmitted = QP_new; QuantChangePostponed = 0; } if (dquant > 2) { dquant = 2; QP_xmitted = QP_prev + dquant;} if (dquant < -2) { dquant = -2; QP_xmitted = QP_prev + dquant;} pic->DQUANT = dquant; /* modify mode if dquant != 0 (e.g. MODE_INTER -> MODE_INTER_Q) */ Mode = ModifyMode(MV[0][j+1][i+1]->Mode,pic->DQUANT); MV[0][j+1][i+1]->Mode = Mode; pic->MB = i + j * ((VidSt->pels)/MB_SIZE); if (Mode == MODE_INTER || Mode == MODE_INTER_Q || Mode==MODE_INTER4V) { /* Predict P-MB */ diff = Predict_P(curr,prev_recon,prev_ipol, i*MB_SIZE,j*MB_SIZE,MV,pic->PB); } else { diff = (MB_Structure *)malloc(sizeof(MB_Structure)); FillLumBlock(i*MB_SIZE, j*MB_SIZE, curr, diff); FillChromBlock(i*MB_SIZE, j*MB_SIZE, curr, diff); } /* P or INTRA Macroblock */ qcoeff_P = MB_Encode(diff, QP_xmitted, Mode); CBP = FindCBP(qcoeff_P, Mode, 64); if (CBP == 0 && (Mode == MODE_INTER || Mode == MODE_INTER_Q)) ZeroMBlock(diff); else MB_Decode(qcoeff_P, diff, QP_xmitted, Mode); recon_data_P = MB_Recon_P(prev_recon, prev_ipol,diff, i*MB_SIZE,j*MB_SIZE,MV,pic->PB); Clip(recon_data_P); free(diff); /* Predict B-MB using reconstructed P-MB and prev. recon. image */ if (pic->PB) { diff = Predict_B(B_image, prev_recon, prev_ipol,i*MB_SIZE, j*MB_SIZE, MV, recon_data_P, frameskip, pic->TRB); if (QP_xmitted == 0) QP_B = 0; /* (QP = 0 means no quantization) */ else QP_B = mmax(1,mmin(31,bquant[pic->BQUANT]*QP_xmitted/4)); qcoeff_B = MB_Encode(diff, QP_B, MODE_INTER); CBPB = FindCBP(qcoeff_B, MODE_INTER, 64); if (CBPB) MB_Decode(qcoeff_B, diff, QP_B, MODE_INTER); else ZeroMBlock(diff); recon_data_B = MB_Recon_B(prev_recon, diff,prev_ipol,i*MB_SIZE, j*MB_SIZE,MV,recon_data_P,frameskip, pic->TRB); Clip(recon_data_B); /* decide MODB */ if (CBPB) { pic->MODB = PBMODE_CBPB_MVDB; } else { if (MV[5][j+1][i+1]->x == 0 && MV[5][j+1][i+1]->y == 0) pic->MODB = PBMODE_NORMAL; else pic->MODB = PBMODE_MVDB; } free(diff); } else ZeroVec(MV[5][j+1][i+1]); /* Zero out PB deltas */ if ((CBP==0) && (CBPB==0) && (EqualVec(MV[0][j+1][i+1],&ZERO)) && (EqualVec(MV[5][j+1][i+1],&ZERO)) && (Mode == MODE_INTER || Mode == MODE_INTER_Q)) { /* Skipped MB : both CBP and CBPB are zero, 16x16 vector is zero, PB delta vector is zero and Mode = MODE_INTER */ if (Mode == MODE_INTER_Q) { /* DQUANT != 0 but not coded anyway */ QP_xmitted = QP_prev; pic->DQUANT = 0; Mode = MODE_INTER; } if (!(VidSt->syntax_arith_coding)) CountBitsMB(Mode,1,CBP,CBPB,pic,bits); else Count_sac_BitsMB(Mode,1,CBP,CBPB,pic,bits); } else { /* Normal MB */ if (!(VidSt->syntax_arith_coding)) { /* VLC */ CountBitsMB(Mode,0,CBP,CBPB,pic,bits); if (Mode == MODE_INTER || Mode == MODE_INTER_Q) { bits->no_inter++; CountBitsVectors(MV, bits, i, j, Mode, newgob, pic); } else if (Mode == MODE_INTER4V) { bits->no_inter4v++; CountBitsVectors(MV, bits, i, j, Mode, newgob, pic); } else { /* MODE_INTRA or MODE_INTRA_Q */ bits->no_intra++; if (pic->PB) CountBitsVectors(MV, bits, i, j, Mode, newgob, pic); } if (CBP || Mode == MODE_INTRA || Mode == MODE_INTRA_Q) CountBitsCoeff(qcoeff_P, Mode, CBP, bits, 64); if (CBPB) CountBitsCoeff(qcoeff_B, MODE_INTER, CBPB, bits, 64); } /* end VLC */ else { /* SAC */ Count_sac_BitsMB(Mode,0,CBP,CBPB,pic,bits); if (Mode == MODE_INTER || Mode == MODE_INTER_Q) { bits->no_inter++; Count_sac_BitsVectors(MV, bits, i, j, Mode, newgob, pic); } else if (Mode == MODE_INTER4V) { bits->no_inter4v++; Count_sac_BitsVectors(MV, bits, i, j, Mode, newgob, pic); } else { /* MODE_INTRA or MODE_INTRA_Q */ bits->no_intra++; if (pic->PB) Count_sac_BitsVectors(MV, bits, i, j, Mode, newgob, pic); } if (CBP || Mode == MODE_INTRA || Mode == MODE_INTRA_Q) Count_sac_BitsCoeff(qcoeff_P, Mode, CBP, bits, 64); if (CBPB) Count_sac_BitsCoeff(qcoeff_B, MODE_INTER, CBPB, bits, 64); } /* end SAC */ QP_prev = QP_xmitted; } abs_mb_num++; QP_cumulative += QP_xmitted; #ifdef PRINTQ /* most useful when quantizer changes within a picture */ if (QuantChangePostponed) fprintf(stdout,"@%2d",QP_xmitted); else fprintf(stdout," %2d",QP_xmitted); #endif if (pic->PB) ReconImage(i,j,recon_data_B,B_recon); ReconImage(i,j,recon_data_P,recon); free(recon_data_P); free(qcoeff_P); if (pic->PB) { free(qcoeff_B); free(recon_data_B); } } #ifdef PRINTQ fprintf(stdout,"\n"); #endif } pic->QP_mean = QP_cumulative/(float)abs_mb_num; /* Free memory */ free(pi); if ((VidSt->mv_outside_frame)) { free(prev_recon); FreeImage(pr_edge); } for (j = 0; j < ((VidSt->lines)>>4)+1; j++) for (i = 0; i < ((VidSt->pels)>>4)+2; i++) for (k = 0; k < 6; k++) free(MV[k][j][i]); return; }

int CodeTCoef (  int  mod_index, int  position, int  intra )

Definition at line 686 of file vid_countbit.c. References AR_Encode(), cumf_TCOEF1, cumf_TCOEF1_intra, cumf_TCOEF2, cumf_TCOEF2_intra, cumf_TCOEF3, cumf_TCOEF3_intra, cumf_TCOEFr, and cumf_TCOEFr_intra. Referenced by Code_sac_Coeff(). { int length; switch (position) { case 1: { if (intra) length = AR_Encode(mod_index, cumf_TCOEF1_intra); else length = AR_Encode(mod_index, cumf_TCOEF1); break; } case 2: { if (intra) length = AR_Encode(mod_index, cumf_TCOEF2_intra); else length = AR_Encode(mod_index, cumf_TCOEF2); break; } case 3: { if (intra) length = AR_Encode(mod_index, cumf_TCOEF3_intra); else length = AR_Encode(mod_index, cumf_TCOEF3); break; } default: { if (intra) length = AR_Encode(mod_index, cumf_TCOEFr_intra); else length = AR_Encode(mod_index, cumf_TCOEFr); break; } } return length; }

void ComputeSNR (  PictImage *  im1, PictImage *  im2, Results *  res, int  write )

Definition at line 67 of file vid_snr.c. References pict_image::Cb, pict_image::Cr, video_codec::lines, pict_image::lum, video_codec::pels, PictImage, Results, results::SNR_Cb, results::SNR_Cr, results::SNR_l, and VidSt. Referenced by code_video(). { FILE *out = NULL; int n; register int m; int quad, quad_Cr, quad_Cb, diff; PictImage *diff_image = NULL; /* Diff. image written to diff_filename */ char *diff_filename=DEF_DIFFILENAME; if (write) { out = fopen(diff_filename,"ab"); diff_image = (PictImage *)malloc(sizeof(PictImage)); diff_image->lum = (unsigned char *)malloc(sizeof(char)*(VidSt->pels)*(VidSt->lines)); diff_image->Cr = (unsigned char *)malloc(sizeof(char)*(VidSt->pels)*(VidSt->lines)/4); diff_image->Cb = (unsigned char *)malloc(sizeof(char)*(VidSt->pels)*(VidSt->lines)/4); } quad = 0; quad_Cr = quad_Cb = 0; /* Luminance */ quad = 0; for (n = 0; n < (VidSt->lines); n++) for (m = 0; m < (VidSt->pels); m++) { diff = *(im1->lum + m + n*(VidSt->pels)) - *(im2->lum + m + n*(VidSt->pels)); if (write) *(diff_image->lum + m + n*(VidSt->pels)) = 10*diff + 128; quad += diff * diff; } res->SNR_l = (float)quad/(float)((VidSt->pels)*(VidSt->lines)); if (res->SNR_l) { res->SNR_l = (float)(255*255) / res->SNR_l; res->SNR_l = 10 * (float)log10(res->SNR_l); } else res->SNR_l = (float)99.99; /* Chrominance */ for (n = 0; n < (VidSt->lines)/2; n++) for (m = 0; m < (VidSt->pels)/2; m++) { quad_Cr += (*(im1->Cr+m + n*(VidSt->pels)/2) - *(im2->Cr + m + n*(VidSt->pels)/2)) * (*(im1->Cr+m + n*(VidSt->pels)/2) - *(im2->Cr + m + n*(VidSt->pels)/2)); quad_Cb += (*(im1->Cb+m + n*(VidSt->pels)/2) - *(im2->Cb + m + n*(VidSt->pels)/2)) * (*(im1->Cb+m + n*(VidSt->pels)/2) - *(im2->Cb + m + n*(VidSt->pels)/2)); if (write) { *(diff_image->Cr + m + n*(VidSt->pels)/2) = (*(im1->Cr+m + n*(VidSt->pels)/2) - *(im2->Cr + m + n*(VidSt->pels)/2))*10+128; *(diff_image->Cb + m + n*(VidSt->pels)/2) = (*(im1->Cb+m + n*(VidSt->pels)/2) - *(im2->Cb + m + n*(VidSt->pels)/2))*10+128; } } res->SNR_Cr = (float)quad_Cr/(float)((VidSt->pels)*(VidSt->lines)/4); if (res->SNR_Cr) { res->SNR_Cr = (float)(255*255) / res->SNR_Cr; res->SNR_Cr = 10 * (float)log10(res->SNR_Cr); } else res->SNR_Cr = (float)99.99; res->SNR_Cb = (float)quad_Cb/(float)((VidSt->pels)*(VidSt->lines)/4); if (res->SNR_Cb) { res->SNR_Cb = (float)(255*255) / res->SNR_Cb; res->SNR_Cb = 10 * (float)log10(res->SNR_Cb); } else res->SNR_Cb = (float)99.99; if (write) { fwrite(diff_image->lum, sizeof(char), (VidSt->pels)*(VidSt->lines), out); fwrite(diff_image->Cr, sizeof(char), (VidSt->pels)*(VidSt->lines)/4, out); fwrite(diff_image->Cb, sizeof(char), (VidSt->pels)*(VidSt->lines)/4, out); free(diff_image->lum); free(diff_image->Cr); free(diff_image->Cb); free(diff_image); fclose(out); } return; }

void CopyVec (  MotionVector *  MV1, MotionVector *  MV2 )

Definition at line 1127 of file vid_countbit.c. References MotionVector, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. { MV2->x = MV1->x; MV2->x_half = MV1->x_half; MV2->y = MV1->y; MV2->y_half = MV1->y_half; return; }

void Count_sac_BitsCoeff (  int *  qcoeff, int  I, int  CBP, Bits *  bits, int  ncoeffs )

Definition at line 486 of file vid_countbit.c. References video_codec::arith_used, Bits, bits_counted::C, Code_sac_Coeff(), MODE_INTRA, VidSt, and bits_counted::Y. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int i; (VidSt->arith_used) = 1; if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { for (i = 0; i < 4; i++) { bits->Y += Code_sac_Coeff(Mode, qcoeff,i,ncoeffs); } for (i = 4; i < 6; i++) { bits->C += Code_sac_Coeff(Mode, qcoeff,i,ncoeffs); } } else { for (i = 0; i < 4; i++) { if ((i==0 && CBP&32) || (i==1 && CBP&16) || (i==2 && CBP&8) || (i==3 && CBP&4) || (i==4 && CBP&2) || (i==5 && CBP&1)) { bits->Y += Code_sac_Coeff(Mode, qcoeff, i, ncoeffs); } } for (i = 4; i < 6; i++) { if ((i==0 && CBP&32) || (i==1 && CBP&16) || (i==2 && CBP&8) || (i==3 && CBP&4) || (i==4 && CBP&2) || (i==5 && CBP&1)) { bits->C += Code_sac_Coeff(Mode, qcoeff, i, ncoeffs); } } } return; }

void Count_sac_BitsMB (  int  Mode, int  COD, int  CBP, int  CBPB, Pict *  pic, Bits *  bits )

Definition at line 169 of file vid_countbit.c. References AR_Encode(), video_codec::arith_used, Bits, bits_counted::CBPB, bits_counted::CBPCM, bits_counted::CBPY, cbpy_intratab, cbpytab, bits_counted::COD, cumf_CBPY, cumf_CBPY_intra, cumf_COD, cumf_DQUANT, cumf_MCBPC, cumf_MCBPC_intra, cumf_MODB, cumf_UVCBPB, cumf_YCBPB, pict::DQUANT, bits_counted::DQUANT, dquanttab, indexfn(), pict::MB, mcbpc_intratab, mcbpctab, bits_counted::MODB, pict::MODB, MODE_INTRA, pict::PB, PBMODE_CBPB_MVDB, PBMODE_MVDB, PBMODE_NORMAL, Pict, pict::picture_coding_type, video_codec::tf, video_codec::trace, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int cbpy, cbpcm, length, i; (VidSt->arith_used) = 1; /* COD */ if ((VidSt->trace)) { fprintf((VidSt->tf),"MB-nr: %d",pic->MB); if (pic->picture_coding_type == PCT_INTER) fprintf((VidSt->tf)," COD: %d ",COD); } if (pic->picture_coding_type == PCT_INTER) bits->COD+=AR_Encode(COD, cumf_COD); if (COD) return; /* not coded */ /* CBPCM */ cbpcm = Mode | ((CBP&3)<<4); if ((VidSt->trace)) { fprintf((VidSt->tf),"CBPCM (CBP=%d) (cbpcm=%d): ",CBP,cbpcm); } if (pic->picture_coding_type == PCT_INTRA) length = AR_Encode(indexfn(cbpcm,mcbpc_intratab,9),cumf_MCBPC_intra); else length = AR_Encode(indexfn(cbpcm,mcbpctab,21),cumf_MCBPC); bits->CBPCM += length; /* MODB & CBPB */ if (pic->PB) { switch (pic->MODB) { case PBMODE_NORMAL: bits->MODB += AR_Encode(0, cumf_MODB); break; case PBMODE_MVDB: bits->MODB += AR_Encode(1, cumf_MODB); break; case PBMODE_CBPB_MVDB: bits->MODB += AR_Encode(2, cumf_MODB); /* CBPB */ for(i=5; i>1; i--) bits->CBPB += AR_Encode(((CBPB & 1<<i)>>i), cumf_YCBPB); for(i=1; i>-1; i--) bits->CBPB += AR_Encode(((CBPB & 1<<i)>>i), cumf_UVCBPB); break; } if ((VidSt->trace)) fprintf((VidSt->tf),"MODB: %d, CBPB: %d\n", pic->MODB, CBPB); } /* CBPY */ cbpy = CBP>>2; if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */ length = AR_Encode(indexfn(cbpy,cbpy_intratab,16),cumf_CBPY_intra); } else { length = AR_Encode(indexfn(cbpy,cbpytab,16),cumf_CBPY); } if ((VidSt->trace)) { fprintf((VidSt->tf),"CBPY (CBP=%d) (cbpy=%d): ",CBP,cbpy); } bits->CBPY += length; /* DQUANT */ if ((Mode == MODE_INTER_Q) || (Mode == MODE_INTRA_Q)) { if ((VidSt->trace)) { fprintf((VidSt->tf),"DQUANT: "); } bits->DQUANT += AR_Encode(indexfn(pic->DQUANT+2,dquanttab,4), cumf_DQUANT); } return; }

void Count_sac_BitsVectors (  MotionVector *  MV[5][MBR+1][MBC+2], Bits *  bits, int  i, int  j, int  Mode, int  newgob, Pict *  pic )

Referenced by CodeOneOrTwo().

void CountBitsCoeff (  int *  qcoeff, int  I, int  CBP, Bits *  bits, int  ncoeffs )

Definition at line 323 of file vid_countbit.c. References Bits, bits_counted::C, CodeCoeff(), MODE_INTRA, and bits_counted::Y. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int i; if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { for (i = 0; i < 4; i++) { bits->Y += CodeCoeff(Mode, qcoeff,i,ncoeffs); } for (i = 4; i < 6; i++) { bits->C += CodeCoeff(Mode, qcoeff,i,ncoeffs); } } else { for (i = 0; i < 4; i++) { if ((i==0 && CBP&32) || (i==1 && CBP&16) || (i==2 && CBP&8) || (i==3 && CBP&4) || (i==4 && CBP&2) || (i==5 && CBP&1)) { bits->Y += CodeCoeff(Mode, qcoeff, i, ncoeffs); } } for (i = 4; i < 6; i++) { if ((i==0 && CBP&32) || (i==1 && CBP&16) || (i==2 && CBP&8) || (i==3 && CBP&4) || (i==4 && CBP&2) || (i==5 && CBP&1)) { bits->C += CodeCoeff(Mode, qcoeff, i, ncoeffs); } } } return; }

void CountBitsMB (  int  Mode, int  COD, int  CBP, int  CBPB, Pict *  pic, Bits *  bits )

Definition at line 65 of file vid_countbit.c. References Bits, bits_counted::CBPB, bits_counted::CBPCM, bits_counted::CBPY, bits_counted::COD, bits_counted::DQUANT, pict::DQUANT, pict::MB, bits_counted::MODB, pict::MODB, MODE_INTRA, pict::PB, PBMODE_CBPB_MVDB, PBMODE_MVDB, PBMODE_NORMAL, Pict, pict::picture_coding_type, put_cbpcm_inter(), put_cbpcm_intra(), put_cbpy(), putbits(), video_codec::tf, video_codec::trace, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int cbpy, cbpcm, length; /* COD */ if ((VidSt->trace)) { fprintf((VidSt->tf),"MB-nr: %d",pic->MB); if (pic->picture_coding_type == PCT_INTER) fprintf((VidSt->tf)," COD: %d\n",COD); } if (pic->picture_coding_type == PCT_INTER) { putbits(1,COD); bits->COD++; } if (COD) return; /* not coded */ /* CBPCM */ cbpcm = Mode | ((CBP&3)<<4); if ((VidSt->trace)) { fprintf((VidSt->tf),"CBPCM (CBP=%d) (cbpcm=%d): ",CBP,cbpcm); } if (pic->picture_coding_type == PCT_INTRA) length = put_cbpcm_intra (CBP, Mode); else length = put_cbpcm_inter (CBP, Mode); bits->CBPCM += length; /* MODB & CBPB */ if (pic->PB) { switch (pic->MODB) { case PBMODE_NORMAL: putbits(1,0); bits->MODB += 1; break; case PBMODE_MVDB: putbits(2,2); bits->MODB += 2; break; case PBMODE_CBPB_MVDB: putbits(2,3); bits->MODB += 2; /* CBPB */ putbits(6,CBPB); bits->CBPB += 6; break; } if ((VidSt->trace)) fprintf((VidSt->tf),"MODB: %d, CBPB: %d\n", pic->MODB, CBPB); } /* CBPY */ cbpy = CBP>>2; if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) /* Intra */ cbpy = cbpy^15; if ((VidSt->trace)) { fprintf((VidSt->tf),"CBPY (CBP=%d) (cbpy=%d): ",CBP,cbpy); } length = put_cbpy (CBP, Mode); bits->CBPY += length; /* DQUANT */ if ((Mode == MODE_INTER_Q) || (Mode == MODE_INTRA_Q)) { if ((VidSt->trace)) { fprintf((VidSt->tf),"DQUANT: "); } switch (pic->DQUANT) { case -1: putbits(2,0); break; case -2: putbits(2,1); break; case 1: putbits(2,2); break; case 2: putbits(2,3); break; default: fprintf(stderr,"Invalid DQUANT\n"); exit(-1); } bits->DQUANT += 2; } return; }

int CountBitsPicture (  Pict *  pic  )

Definition at line 1163 of file vid_countbit.c. References video_codec::advanced, pict::BQUANT, pict::PB, Pict, pict::picture_coding_type, PSC, PSC_LENGTH, putbits(), pict::QUANT, pict::source_format, pict::spare, video_codec::syntax_arith_coding, video_codec::tf, pict::TR, video_codec::trace, pict::TRB, pict::unrestricted_mv_mode, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int bits = 0; /* in case of arithmetic coding, encoder_flush() has been called before zeroflush() in vid_main.c */ /* Picture start code */ if ((VidSt->trace)) { fprintf((VidSt->tf),"picture_start_code: "); } putbits(PSC_LENGTH,PSC); bits += PSC_LENGTH; /* Group number */ if ((VidSt->trace)) { fprintf((VidSt->tf),"Group number in picture header: "); } putbits(5,0); bits += 5; /* Time reference */ if ((VidSt->trace)) { fprintf((VidSt->tf),"Time reference: "); } putbits(8,pic->TR); bits += 8; /* bit 1 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"spare: "); } pic->spare = 1; /* always 1 to avoid start code emulation */ putbits(1,pic->spare); bits += 1; /* bit 2 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"always zero for distinction with H.261\n"); } putbits(1,0); bits += 1; /* bit 3 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"split_screen_indicator: "); } putbits(1,0); /* no support for split-screen in this software */ bits += 1; /* bit 4 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"document_camera_indicator: "); } putbits(1,0); bits += 1; /* bit 5 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"freeze_picture_release: "); } putbits(1,0); bits += 1; /* bit 6-8 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"source_format: "); } putbits(3,pic->source_format); bits += 3; /* bit 9 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"picture_coding_type: "); } putbits(1,pic->picture_coding_type); bits += 1; /* bit 10 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"mv_outside_frame: "); } putbits(1,pic->unrestricted_mv_mode); /* Unrestricted Motion Vector mode */ bits += 1; /* bit 11 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"sac_coding: "); } putbits(1,(VidSt->syntax_arith_coding)); /* Syntax-based Arithmetic Coding mode */ bits += 1; /* bit 12 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"adv_pred_mode: "); } putbits(1,(VidSt->advanced)); /* Advanced Prediction mode */ bits += 1; /* bit 13 */ if ((VidSt->trace)) { fprintf((VidSt->tf),"PB-coded: "); /* PB-frames mode */ } putbits(1,pic->PB); bits += 1; /* QUANT */ if ((VidSt->trace)) { fprintf((VidSt->tf),"QUANT: "); } putbits(5,pic->QUANT); bits += 5; /* Continuous Presence Multipoint (CPM) */ putbits(1,0); /* CPM is not supported in this software */ bits += 1; /* Picture Sub Bitstream Indicator (PSBI) */ /* if CPM == 1: 2 bits PSBI */ /* not supported */ /* extra information for PB-frames */ if (pic->PB) { if ((VidSt->trace)) { fprintf((VidSt->tf),"TRB: "); } putbits(3,pic->TRB); bits += 3; if ((VidSt->trace)) { fprintf((VidSt->tf),"BQUANT: "); } putbits(2,pic->BQUANT); bits += 2; } /* PEI (extra information) */ if ((VidSt->trace)) { fprintf((VidSt->tf),"PEI: "); } /* "Encoders shall not insert PSPARE until specified by the ITU" */ putbits(1,0); bits += 1; /* PSPARE */ /* if PEI == 1: 8 bits PSPARE + another PEI bit */ /* not supported */ return bits; }

int CountBitsSlice (  int  slice, int  quant )

Definition at line 260 of file vid_countbit.c. References video_codec::arith_used, encoder_flush(), PSC, PSC_LENGTH, putbits(), video_codec::tf, video_codec::trace, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int bits = 0; if ((VidSt->arith_used)) { bits+=encoder_flush(); /* Need to call before fixed length string output */ (VidSt->arith_used) = 0; } /* Picture Start Code */ if ((VidSt->trace)) fprintf((VidSt->tf),"GOB sync (GBSC): "); putbits(PSC_LENGTH,PSC); /* PSC */ bits += PSC_LENGTH; /* Group Number */ if ((VidSt->trace)) fprintf((VidSt->tf),"GN: "); putbits(5,slice); bits += 5; /* GOB Sub Bitstream Indicator */ /* if CPM == 1: read 2 bits GSBI */ /* not supported in this version */ /* GOB Frame ID */ if ((VidSt->trace)) fprintf((VidSt->tf),"GFID: "); putbits(2, 0); /* NB: in error-prone environments this value should change if PTYPE in picture header changes. In this version of the encoder PTYPE only changes when PB-frames are used in the following cases: (i) after the first intra frame (ii) if the distance between two P-frames is very large Therefore I haven't implemented this GFID change */ /* GFID is not allowed to change unless PTYPE changes */ bits += 2; /* Gquant */ if ((VidSt->trace)) fprintf((VidSt->tf),"GQUANT: "); putbits(5,quant); bits += 5; return bits; }

void CountBitsVectors (  MotionVector *  MV[5][MBR+1][MBC+2], Bits *  bits, int  i, int  j, int  Mode, int  newgob, Pict *  pic )

Referenced by CodeOneOrTwo().

int Dct (  int *  block, int *  coeff )

Definition at line 89 of file vid_dct.c. References zigzag. Referenced by MB_Encode(). { int j1, i, j, k; float b[8]; float b1[8]; float d[8][8]; float f0=(float).7071068; float f1=(float).4903926; float f2=(float).4619398; float f3=(float).4157348; float f4=(float).3535534; float f5=(float).2777851; float f6=(float).1913417; float f7=(float).0975452; for (i = 0, k = 0; i < 8; i++, k += 8) { for (j = 0; j < 8; j++) { b[j] = (float)block[k+j]; } /* Horizontal transform */ for (j = 0; j < 4; j++) { j1 = 7 - j; b1[j] = b[j] + b[j1]; b1[j1] = b[j] - b[j1]; } b[0] = b1[0] + b1[3]; b[1] = b1[1] + b1[2]; b[2] = b1[1] - b1[2]; b[3] = b1[0] - b1[3]; b[4] = b1[4]; b[5] = (b1[6] - b1[5]) * f0; b[6] = (b1[6] + b1[5]) * f0; b[7] = b1[7]; d[i][0] = (b[0] + b[1]) * f4; d[i][4] = (b[0] - b[1]) * f4; d[i][2] = b[2] * f6 + b[3] * f2; d[i][6] = b[3] * f6 - b[2] * f2; b1[4] = b[4] + b[5]; b1[7] = b[7] + b[6]; b1[5] = b[4] - b[5]; b1[6] = b[7] - b[6]; d[i][1] = b1[4] * f7 + b1[7] * f1; d[i][5] = b1[5] * f3 + b1[6] * f5; d[i][7] = b1[7] * f7 - b1[4] * f1; d[i][3] = b1[6] * f3 - b1[5] * f5; } /* Vertical transform */ for (i = 0; i < 8; i++) { for (j = 0; j < 4; j++) { j1 = 7 - j; b1[j] = d[j][i] + d[j1][i]; b1[j1] = d[j][i] - d[j1][i]; } b[0] = b1[0] + b1[3]; b[1] = b1[1] + b1[2]; b[2] = b1[1] - b1[2]; b[3] = b1[0] - b1[3]; b[4] = b1[4]; b[5] = (b1[6] - b1[5]) * f0; b[6] = (b1[6] + b1[5]) * f0; b[7] = b1[7]; d[0][i] = (b[0] + b[1]) * f4; d[4][i] = (b[0] - b[1]) * f4; d[2][i] = b[2] * f6 + b[3] * f2; d[6][i] = b[3] * f6 - b[2] * f2; b1[4] = b[4] + b[5]; b1[7] = b[7] + b[6]; b1[5] = b[4] - b[5]; b1[6] = b[7] - b[6]; d[1][i] = b1[4] * f7 + b1[7] * f1; d[5][i] = b1[5] * f3 + b1[6] * f5; d[7][i] = b1[7] * f7 - b1[4] * f1; d[3][i] = b1[6] * f3 - b1[5] * f5; } /* Zigzag - scanning */ for (i = 0; i < 8; i++) { for (j = 0; j < 8; j++) { *(coeff + zigzag[i][j]) = (int)(d[i][j]); } } return 0; }

void Dequant (  int *  qcoeff, int *  rcoeff, int  QP, int  I )

Definition at line 108 of file vid_quant.c. References MODE_INTRA, and sign. Referenced by MB_Decode(). { int i; if (QP) { for (i = 0; i < 64; i++) { if (qcoeff[i]) { if ((QP % 2) == 1) rcoeff[i] = QP * (2*abs(qcoeff[i]) + 1); else rcoeff[i] = QP * (2*abs(qcoeff[i]) + 1) - 1; rcoeff[i] = sign(qcoeff[i]) * rcoeff[i]; } else rcoeff[i] = 0; } if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */ rcoeff[0] = qcoeff[0]*8; } } else { /* No quantizing at all */ for (i = 0; i < 64; i++) { rcoeff[i] = qcoeff[i]; } } return; }

void DoPredChrom_P (  int  x_curr, int  y_curr, int  dx, int  dy, PictImage *  curr, PictImage *  prev, MB_Structure *  pred_error )

Definition at line 676 of file vid_pred.c. References mb_structure::Cb, pict_image::Cb, video_codec::cpels, mb_structure::Cr, pict_image::Cr, video_codec::long_vectors, MB_Structure, video_codec::mv_outside_frame, video_codec::pels, PictImage, and VidSt. Referenced by Predict_P(). { int m,n; int x, y, ofx, ofy, pel, lx; int xint, yint; int xh, yh; lx = ((VidSt->mv_outside_frame) ? (VidSt->pels)/2 + ((VidSt->long_vectors)?32:16) : (VidSt->pels)/2); x = x_curr>>1; y = y_curr>>1; xint = dx>>1; xh = dx & 1; yint = dy>>1; yh = dy & 1; if (!xh && !yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=*(prev->Cr+ofx + (ofy )*lx); pred_error->Cr[n][m] = (int)(*(curr->Cr + x+m + (y+n)*(VidSt->cpels)) - pel); pel=*(prev->Cb+ofx + (ofy )*lx); pred_error->Cb[n][m] = (int)(*(curr->Cb + x+m + (y+n)*(VidSt->cpels)) - pel); } } } else if (!xh && yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx + (ofy+yh)*lx) + 1)>>1; pred_error->Cr[n][m] = (int)(*(curr->Cr + x+m + (y+n)*(VidSt->cpels)) - pel); pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx + (ofy+yh)*lx) + 1)>>1; pred_error->Cb[n][m] = (int)(*(curr->Cb + x+m + (y+n)*(VidSt->cpels)) - pel); } } } else if (xh && !yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx+xh + (ofy )*lx) + 1)>>1; pred_error->Cr[n][m] = (int)(*(curr->Cr + x+m + (y+n)*(VidSt->cpels)) - pel); pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx+xh + (ofy )*lx) + 1)>>1; pred_error->Cb[n][m] = (int)(*(curr->Cb + x+m + (y+n)*(VidSt->cpels)) - pel); } } } else { /* xh && yh */ for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx+xh + (ofy )*lx)+ *(prev->Cr+ofx + (ofy+yh)*lx)+ *(prev->Cr+ofx+xh + (ofy+yh)*lx)+ 2)>>2; pred_error->Cr[n][m] = (int)(*(curr->Cr + x+m + (y+n)*(VidSt->cpels)) - pel); pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx+xh + (ofy )*lx)+ *(prev->Cb+ofx + (ofy+yh)*lx)+ *(prev->Cb+ofx+xh + (ofy+yh)*lx)+ 2)>>2; pred_error->Cb[n][m] = (int)(*(curr->Cb + x+m + (y+n)*(VidSt->cpels)) - pel); } } } return; }

int encoder_flush (   )

Definition at line 150 of file vid_sac.c. References bit_opp_bits(), bitcount(), low, video_codec::tf, video_codec::trace, and VidSt. Referenced by code_video(), and CountBitsSlice(). { int bitcount = 0; if ((VidSt->trace)) fprintf((VidSt->tf), "encoder_flush:\n"); opposite_bits++; if (low < q1) { bitcount+=bit_opp_bits(0); } else { bitcount+=bit_opp_bits(1); } low = 0; high = top; zerorun=0; return bitcount; }

int EqualVec (  MotionVector *  MV2, MotionVector *  MV1 )

Definition at line 1136 of file vid_countbit.c. References MotionVector, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by CodeOneOrTwo(). { if (MV1->x != MV2->x) return 0; if (MV1->y != MV2->y) return 0; if (MV1->x_half != MV2->x_half) return 0; if (MV1->y_half != MV2->y_half) return 0; return 1; }

void FillChromBlock (  int  x_curr, int  y_curr, PictImage *  image, MB_Structure *  data )

Definition at line 682 of file vid_coder.c. References pict_image::Cb, mb_structure::Cb, video_codec::cpels, pict_image::Cr, mb_structure::Cr, data, MB_Structure, PictImage, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int n; register int m; int x, y; x = x_curr>>1; y = y_curr>>1; for (n = 0; n < (MB_SIZE>>1); n++) for (m = 0; m < (MB_SIZE>>1); m++) { data->Cr[n][m] = (int)(*(image->Cr +x+m + (y+n)*(VidSt->cpels))); data->Cb[n][m] = (int)(*(image->Cb +x+m + (y+n)*(VidSt->cpels))); } return; }

PictImage* FillImage (  unsigned char *  in  )

Definition at line 114 of file vid_io.c. References InitImage(), video_codec::lines, video_codec::pels, Pict, PictImage, and VidSt. Referenced by code_video(). { PictImage *Pict; Pict = InitImage((VidSt->pels)*(VidSt->lines)); memcpy(Pict->lum, in, (VidSt->pels)*(VidSt->lines)); memcpy(Pict->Cb, in + (VidSt->pels)*(VidSt->lines), (VidSt->pels)*(VidSt->lines)/4); memcpy(Pict->Cr, in + (VidSt->pels)*(VidSt->lines) + (VidSt->pels)*(VidSt->lines)/4, (VidSt->pels)*(VidSt->lines)/4); free(in); return(Pict); }

void FillLumBlock (  int  x, int  y, PictImage *  image, MB_Structure *  data )

Definition at line 656 of file vid_coder.c. References data, pict_image::lum, mb_structure::lum, MB_Structure, video_codec::pels, PictImage, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int n; register int m; for (n = 0; n < MB_SIZE; n++) for (m = 0; m < MB_SIZE; m++) data->lum[n][m] = (int)(*(image->lum + x+m + (y+n)*(VidSt->pels))); return; }

void FindBiDirChromaLimits (  int  vec, int *  start, int *  stop )

Definition at line 596 of file vid_pred.c. References mmax, and mmin. Referenced by FindBiDirChrPredPB(). { /* limits taken from C loop in section G5 in H.263 */ *start = mmax(0,(-vec+1)/2); *stop = mmin(7,7-(vec+1)/2); return; }

void FindBiDirChrPredPB (  MB_Structure *  recon_P, int  dx, int  dy, MB_Structure *  pred )

Definition at line 569 of file vid_pred.c. References BiDirPredBlock(), mb_structure::Cb, mb_structure::Cr, FindBiDirChromaLimits(), and MB_Structure. Referenced by MB_Recon_B(), and Predict_B(). { int xstart,xstop,ystart,ystop; FindBiDirChromaLimits(dx,&xstart,&xstop); FindBiDirChromaLimits(dy,&ystart,&ystop); BiDirPredBlock(xstart,xstop,ystart,ystop,dx,dy, &recon_P->Cb[0][0], &pred->Cb[0][0],8); BiDirPredBlock(xstart,xstop,ystart,ystop,dx,dy, &recon_P->Cr[0][0], &pred->Cr[0][0],8); return; }

void FindBiDirLimits (  int  vec, int *  start, int *  stop, int  nhv )

Definition at line 585 of file vid_pred.c. References mmax, and mmin. Referenced by FindBiDirLumPredPB(). { /* 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); return; }

void FindBiDirLumPredPB (  int *  recon_P, MotionVector *  fr, int *  pred, int  TRD, int  TRB, int  bdx, int  bdy, int  nh, int  nv )

Definition at line 534 of file vid_pred.c. References BiDirPredBlock(), FindBiDirLimits(), MotionVector, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by MB_Recon_B(), and Predict_B(). { int xstart,xstop,ystart,ystop; int xvec,yvec, mvx, mvy; mvx = 2*fr->x + fr->x_half; mvy = 2*fr->y + fr->y_half; xvec = (bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx); yvec = (bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy); /* Luma */ FindBiDirLimits(xvec,&xstart,&xstop,nh); FindBiDirLimits(yvec,&ystart,&ystop,nv); BiDirPredBlock(xstart,xstop,ystart,ystop,xvec,yvec, recon_P,pred,16); return; }

int FindCBP (  int *  qcoeff, int  Mode, int  ncoeffs )

Definition at line 743 of file vid_countbit.c. References MODE_INTRA. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int i,j; int CBP = 0; int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q); /* Set CBP for this Macroblock */ for (i = 0; i < 6; i++) { for (j = i*ncoeffs + intra; j < (i+1)*ncoeffs; j++) { if (qcoeff[j]) { if (i == 0) {CBP |= 32;} else if (i == 1) {CBP |= 16;} else if (i == 2) {CBP |= 8;} else if (i == 3) {CBP |= 4;} else if (i == 4) {CBP |= 2;} else if (i == 5) {CBP |= 1;} else { fprintf(stderr,"Error in CBP assignment\n"); exit(-1); } break; } } } return CBP; }

void FindChromBlock_P (  int  x_curr, int  y_curr, int  dx, int  dy, PictImage *  prev, MB_Structure *  data )

Definition at line 1395 of file vid_pred.c. References mb_structure::Cb, pict_image::Cb, mb_structure::Cr, pict_image::Cr, data, video_codec::long_vectors, MB_Structure, video_codec::mv_outside_frame, video_codec::pels, PictImage, and VidSt. Referenced by MB_Recon_B(), and Predict_B(). { int m,n; int x, y, ofx, ofy, pel,lx; int xint, yint; int xh, yh; lx = ((VidSt->mv_outside_frame) ? (VidSt->pels)/2 + ((VidSt->long_vectors)?32:16) : (VidSt->pels)/2); x = x_curr>>1; y = y_curr>>1; xint = dx>>1; xh = dx & 1; yint = dy>>1; yh = dy & 1; if (!xh && !yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=*(prev->Cr+ofx + (ofy )*lx); data->Cr[n][m] = pel; pel=*(prev->Cb+ofx + (ofy )*lx); data->Cb[n][m] = pel; } } } else if (!xh && yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx + (ofy+yh)*lx) + 1)>>1; data->Cr[n][m] = pel; pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx + (ofy+yh)*lx) + 1)>>1; data->Cb[n][m] = pel; } } } else if (xh && !yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx+xh + (ofy )*lx) + 1)>>1; data->Cr[n][m] = pel; pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx+xh + (ofy )*lx) + 1)>>1; data->Cb[n][m] = pel; } } } else { /* xh && yh */ for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx+xh + (ofy )*lx)+ *(prev->Cr+ofx + (ofy+yh)*lx)+ *(prev->Cr+ofx+xh + (ofy+yh)*lx)+ 2)>>2; data->Cr[n][m] = pel; pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx+xh + (ofy )*lx)+ *(prev->Cb+ofx + (ofy+yh)*lx)+ *(prev->Cb+ofx+xh + (ofy+yh)*lx)+ 2)>>2; data->Cb[n][m] = pel; } } } return; }

void FindForwLumPredPB (  unsigned char *  prev_ipol, int  x_curr, int  y_curr, MotionVector *  fr, int *  pred, int  TRD, int  TRB, int  bdx, int  bdy, int  bs, int  comp )

Definition at line 494 of file vid_pred.c. References video_codec::long_vectors, MotionVector, video_codec::mv_outside_frame, video_codec::pels, VidSt, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by MB_Recon_B(), and Predict_B(). { int i,j; int xvec,yvec,lx; lx = ((VidSt->mv_outside_frame) ? (VidSt->pels) + ((VidSt->long_vectors)?64:32) : (VidSt->pels)); /* Luma */ xvec = (TRB)*(2*fr->x + fr->x_half)/TRD + bdx; yvec = (TRB)*(2*fr->y + fr->y_half)/TRD + bdy; x_curr += ((comp&1)<<3); y_curr += ((comp&2)<<2); for (j = 0; j < bs; j++) { for (i = 0; i < bs; i++) { *(pred+i+j*16) = *(prev_ipol + (i+x_curr)*2 + xvec + ((j+y_curr)*2 + yvec)*lx*2); } } return; }

void FindHalfPel (  int  x, int  y, MotionVector *  MV, unsigned char *  prev, int *  curr, int  bs, int  comp )

Definition at line 797 of file vid_pred.c. References video_codec::lines, video_codec::long_vectors, motionvector::min_error, MotionVector, video_codec::mv_outside_frame, video_codec::pels, Point, VidSt, point::x, motionvector::x, motionvector::x_half, point::y, motionvector::y, and motionvector::y_half. Referenced by MotionEstimatePicture(). { int i, m, n; int half_pel; int start_x, start_y, stop_x, stop_y, new_x, new_y, lx; int min_pos; int AE, AE_min; Point search[9]; start_x = -1; stop_x = 1; start_y = -1; stop_y = 1; new_x = x + fr->x; new_y = y + fr->y; new_x += ((comp&1)<<3); new_y += ((comp&2)<<2); lx = ((VidSt->mv_outside_frame) ? (VidSt->pels) + ((VidSt->long_vectors)?64:32) : (VidSt->pels)); /* Make sure that no addressing is outside the frame */ if (!(VidSt->mv_outside_frame)) { if ((new_x) <= 0) start_x = 0; if ((new_y) <= 0) start_y = 0; if ((new_x) >= ((VidSt->pels)-bs)) stop_x = 0; if ((new_y) >= ((VidSt->lines)-bs)) stop_y = 0; } search[0].x = 0; search[0].y = 0; search[1].x = start_x; search[1].y = start_y; /* 1 2 3 */ search[2].x = 0; search[2].y = start_y; /* 4 0 5 */ search[3].x = stop_x; search[3].y = start_y; /* 6 7 8 */ search[4].x = start_x; search[4].y = 0; search[5].x = stop_x; search[5].y = 0; search[6].x = start_x; search[6].y = stop_y; search[7].x = 0; search[7].y = stop_y; search[8].x = stop_x; search[8].y = stop_y; AE_min = INT_MAX; min_pos = 0; for (i = 0; i < 9; i++) { AE = 0; for (n = 0; n < bs; n++) { for (m = 0; m < bs; m++) { /* Find absolute error */ half_pel = *(prev + 2*new_x + 2*m + search[i].x + (2*new_y + 2*n + search[i].y)*lx*2); AE += abs(half_pel - *(curr + m + n*16)); } } /* * if (i == 0 && fr->x == 0 && fr->y == 0 && bs == 16) * AE -= PREF_NULL_VEC; */ if (AE < AE_min) { AE_min = AE; min_pos = i; } } /* Store optimal values */ fr->min_error = AE_min; fr->x_half = search[min_pos].x; fr->y_half = search[min_pos].y; return; }

void FindMB (  int  x, int  y, unsigned char *  image, int  MB[16][16] )

Definition at line 490 of file vid_mot_est.c. References video_codec::pels, and VidSt. Referenced by MotionEstimatePicture(), Predict_B(), and Predict_P(). { int n; register int m; for (n = 0; n < MB_SIZE; n++) for (m = 0; m < MB_SIZE; m++) MB[n][m] = *(image + x+m + (y+n)*(VidSt->pels)); }

void FindPMV (  MotionVector *  MV[5][MBR+1][MBC+2], int  x, int  y, int *  p0, int *  p1, int  block, int  newgob, int  half_pel )

Referenced by Count_sac_BitsVectors(), CountBitsVectors(), and MotionEstimatePicture().

void FindPred (  int  x, int  y, MotionVector *  fr, unsigned char *  prev, int *  pred, int  bs, int  comp )

Definition at line 888 of file vid_pred.c. References video_codec::long_vectors, MotionVector, video_codec::mv_outside_frame, video_codec::pels, VidSt, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by Predict_P(). { int m, n; int new_x, new_y; int lx; lx = ((VidSt->mv_outside_frame) ? (VidSt->pels) + ((VidSt->long_vectors)?64:32) : (VidSt->pels)); new_x = x + fr->x; new_y = y + fr->y; new_x += ((comp&1)<<3); new_y += ((comp&2)<<2); /* Fill pred. data */ for (n = 0; n < bs; n++) { for (m = 0; m < bs; m++) { /* Find interpolated pixel-value */ *(pred + m + n*16) = *(prev + (new_x + m)*2 + fr->x_half + ((new_y + n)*2 + fr->y_half)*lx*2); } } return; }

void FindPredOBMC (  int  x, int  y, MotionVector *  MV[5][MBR+1][MBC+2], unsigned char *  prev, int *  pred, int  comp, int  PB )

Referenced by MB_Recon_P(), and Predict_P().

void FreeImage (  PictImage *  image  )

Definition at line 232 of file vid_io.c. References pict_image::Cb, pict_image::Cr, pict_image::lum, and PictImage. Referenced by close_video_codec(), code_video(), and CodeOneOrTwo(). { free(image->lum); free(image->Cr); free(image->Cb); free(image); }

void Help (   )

int idct (  int *  coeff, int *  block )

Referenced by MB_Decode().

void idctref (  int *  coeff, int *  block )

Definition at line 313 of file vid_dct.c. References c, and zigzag. Referenced by MB_Decode(). { int i, j, k, v; double partial_product; double tmp[64]; int tmp2[64]; extern int zigzag[8][8]; for (i=0; i<8; i++) for (j=0; j<8; j++) tmp2[j+i*8] = *(coeff + zigzag[i][j]); for (i=0; i<8; i++) for (j=0; j<8; j++) { partial_product = 0.0; for (k=0; k<8; k++) partial_product+= c[k][j]*tmp2[8*i+k]; tmp[8*i+j] = partial_product; } /* Transpose operation is integrated into address mapping by switching loop order of i and j */ for (j=0; j<8; j++) for (i=0; i<8; i++) { partial_product = 0.0; for (k=0; k<8; k++) partial_product+= c[k][i]*tmp[8*k+j]; v = (int)floor(partial_product+0.5); block[8*i+j] = (v<-256) ? -256 : ((v>255) ? 255 : v); } }

int indexfn (  int  value, int  table[], int  max )

Definition at line 233 of file vid_sac.c. Referenced by Code_sac_Coeff(), Count_sac_BitsMB(), and Count_sac_BitsVectors(). { int n=0; while(1) { if (table[n++]==value) return n-1; if (n>max) return -1; } }

void init_idctref (  void   )

Definition at line 298 of file vid_dct.c. References c, and PI. Referenced by new_video_codec(). { int freq, time; double scale; for (freq=0; freq < 8; freq++) { scale = (freq == 0) ? sqrt(0.125) : 0.5; for (time=0; time<8; time++) c[freq][time] = scale*cos((PI/8.0)*freq*(time + 0.5)); } }

void initbits (   )

Definition at line 64 of file vid_putbits.c. References video_codec::bytecnt, video_codec::outcnt, and VidSt. Referenced by code_video(). { (VidSt->outcnt) = 8; (VidSt->bytecnt) = 0; }

int InitializeQuantizer (  int  pict_type, float  bit_rate, float  target_frame_rate, float  QP_mean )

Definition at line 95 of file vid_ratectrl.c. References video_codec::B_prev, video_codec::B_target, video_codec::global_adj, mmax, mmin, and VidSt. Referenced by CodeOneOrTwo(). : */ /* int bitcount; */ /* AddBitsPicture(bits); */ /* bitcount = bits->total; */ { int newQP; if (pict_type == PCT_INTER) { (VidSt->B_target) = bit_rate / target_frame_rate; /* compute picture buffer descrepency as of the previous picture */ if ((VidSt->B_prev) != 0.0) { (VidSt->global_adj) = ((VidSt->B_prev) - (VidSt->B_target)) / (2*(VidSt->B_target)); } else { (VidSt->global_adj) = (float)0.0; } newQP = (int)(QP_mean * (1 + (VidSt->global_adj)) + (float)0.5); newQP = mmax(1,mmin(31,newQP)); } else if (pict_type == PCT_INTRA) { fprintf(stderr,"No need to call InititializeQuantizer() for Intra picture\n"); exit(-1); } else { fprintf(stderr,"Error (InitializePictureRate): picture type unkown.\n"); exit(-1); } #if 1 printf("Global adj = %.2f\n", (VidSt->global_adj)); printf("meanQP = %.2f newQP = %d\n", QP_mean, newQP); #endif fprintf(stdout,"Target no. of bits: %.2f\n", (VidSt->B_target)); return newQP; }

void InitializeRateControl (   )

Definition at line 85 of file vid_ratectrl.c. References video_codec::B_prev, and VidSt. Referenced by code_video(). { (VidSt->B_prev) = (float)0.0; }

PictImage* InitImage (  int  size  )

Definition at line 191 of file vid_io.c. References PictImage. Referenced by code_video(), CodeOneIntra(), CodeOneOrTwo(), and FillImage(). { PictImage *new; if ((new = (PictImage *)malloc(sizeof(PictImage))) == NULL) { fprintf(stderr,"Couldn't allocate (PictImage *)\n"); exit(-1); } if ((new->lum = (unsigned char *)malloc(sizeof(char)*size)) == NULL) { fprintf(stderr,"Couldn't allocate memory for luminance\n"); exit(-1); } if ((new->Cr = (unsigned char *)malloc(sizeof(char)*size/4)) == NULL) { fprintf(stderr,"Couldn't allocate memory for Cr\n"); exit(-1); } if ((new->Cb = (unsigned char *)malloc(sizeof(char)*size/4)) == NULL) { fprintf(stderr,"Couldn't allocate memory for Cb\n"); exit(-1); } return new; }

int* InterleaveCoeff (  int *  qp, int *  qb, int  bs )

unsigned char* InterpolateImage (  unsigned char *  image, int  w, int  h )

Definition at line 788 of file vid_coder.c. Referenced by CodeOneOrTwo(). { unsigned char *ipol_image, *ii, *oo; int i,j; ipol_image = (unsigned char *)malloc(sizeof(char)*width*height*4); ii = ipol_image; oo = image; /* main image */ for (j = 0; j < height-1; j++) { for (i = 0; i < width-1; i++) { *(ii + (i<<1)) = *(oo + i); *(ii + (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1)>>1; *(ii + (i<<1)+(width<<1)) = (*(oo + i) + *(oo + i + width) + 1)>>1; *(ii + (i<<1)+1+(width<<1)) = (*(oo+i) + *(oo+i+1) + *(oo+i+width) + *(oo+i+1+width) + 2)>>2; } /* last pels on each line */ *(ii+ (width<<1) - 2) = *(oo + width - 1); *(ii+ (width<<1) - 1) = *(oo + width - 1); *(ii+ (width<<1)+ (width<<1)-2) = (*(oo+width-1)+*(oo+width+width-1)+1)>>1; *(ii+ (width<<1)+ (width<<1)-1) = (*(oo+width-1)+*(oo+width+width-1)+1)>>1; ii += (width<<2); oo += width; } /* last lines */ for (i = 0; i < width-1; i++) { *(ii+ (i<<1)) = *(oo + i); *(ii+ (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1)>>1; *(ii+ (width<<1)+ (i<<1)) = *(oo + i); *(ii+ (width<<1)+ (i<<1)+1) = (*(oo + i) + *(oo + i + 1) + 1)>>1; } /* bottom right corner pels */ *(ii + (width<<1) - 2) = *(oo + width -1); *(ii + (width<<1) - 1) = *(oo + width -1); *(ii + (width<<2) - 2) = *(oo + width -1); *(ii + (width<<2) - 1) = *(oo + width -1); return ipol_image; }

unsigned char* LoadArea (  unsigned char *  im, int  x, int  y, int  x_size, int  y_size, int  lx )

Definition at line 330 of file vid_mot_est.c. Referenced by MotionEstimation(). { unsigned char *res = (unsigned char *)malloc(sizeof(char)*x_size*y_size); unsigned char *in; unsigned char *out; int i = x_size; int j = y_size; in = im + (y*lx) + x; out = res; while (j--) { while (i--) *out++ = *in++; i = x_size; in += lx - x_size; }; return res; }

void MakeEdgeImage (  unsigned char *  src, unsigned char *  dst, int  width, int  height, int  edge )

Definition at line 997 of file vid_coder.c. Referenced by CodeOneOrTwo(). { 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++) { memcpy(p1,o1,width); 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 MarkVec (  MotionVector *  MV  )

Definition at line 1118 of file vid_countbit.c. References MotionVector, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by CodeOneOrTwo(). { MV->x = NO_VEC; MV->y = NO_VEC; MV->x_half = 0; MV->y_half = 0; return; }

int MB_Decode (  int *  qcoeff, MB_Structure *  mb_recon, int  QP, int  I )

Definition at line 566 of file vid_coder.c. References mb_structure::Cb, mb_structure::Cr, Dequant(), idct(), idctref(), mb_structure::lum, and MB_Structure. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int i, j, k, l, row, col; int *iblock; int *qcoeff_ind; int *rcoeff, *rcoeff_ind; if ((iblock = (int *)malloc(sizeof(int)*64)) == NULL) { fprintf(stderr,"MB_Coder: Could not allocate space for iblock\n"); exit(-1); } if ((rcoeff = (int *)malloc(sizeof(int)*384)) == NULL) { fprintf(stderr,"MB_Coder: Could not allocate space for rcoeff\n"); exit(-1); } /* For control purposes */ /* Zero data */ for (i = 0; i < 16; i++) for (j = 0; j < 16; j++) mb_recon->lum[j][i] = 0; for (i = 0; i < 8; i++) for (j = 0; j < 8; j++) { mb_recon->Cb[j][i] = 0; mb_recon->Cr[j][i] = 0; } qcoeff_ind = qcoeff; rcoeff_ind = rcoeff; for (k=0;k<16;k+=8) { for (l=0;l<16;l+=8) { Dequant(qcoeff_ind,rcoeff_ind,QP,I); #ifndef FASTIDCT idctref(rcoeff_ind,iblock); #else idct(rcoeff_ind,iblock); #endif qcoeff_ind += 64; rcoeff_ind += 64; for (i=k,row=0;row<64;i++,row+=8) { for (j=l,col=0;col<8;j++,col++) { mb_recon->lum[i][j] = *(iblock+row+col); } } } } Dequant(qcoeff_ind,rcoeff_ind,QP,I); #ifndef FASTIDCT idctref(rcoeff_ind,iblock); #else idct(rcoeff_ind,iblock); #endif qcoeff_ind += 64; rcoeff_ind += 64; for (i=0;i<8;i++) { for (j=0;j<8;j++) { mb_recon->Cb[i][j] = *(iblock+i*8+j); } } Dequant(qcoeff_ind,rcoeff_ind,QP,I); #ifndef FASTIDCT idctref(rcoeff_ind,iblock); #else idct(rcoeff_ind,iblock); #endif for (i=0;i<8;i++) { for (j=0;j<8;j++) { mb_recon->Cr[i][j] = *(iblock+i*8+j); } } free(iblock); free(rcoeff); return 0; }

int* MB_Encode (  MB_Structure *  mb_orig, int  QP, int  I )

Definition at line 501 of file vid_coder.c. References mb_structure::Cb, mb_structure::Cr, Dct(), mb_structure::lum, MB_Structure, and Quant(). Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int i, j, k, l, row, col; int fblock[64]; int coeff[384]; int *coeff_ind; int *qcoeff; int *qcoeff_ind; if ((qcoeff=(int *)malloc(sizeof(int)*384)) == 0) { fprintf(stderr,"mb_encode(): Couldn't allocate qcoeff.\n"); exit(-1); } coeff_ind = coeff; qcoeff_ind = qcoeff; for (k=0;k<16;k+=8) { for (l=0;l<16;l+=8) { for (i=k,row=0;row<64;i++,row+=8) { for (j=l,col=0;col<8;j++,col++) { *(fblock+row+col) = mb_orig->lum[i][j]; } } Dct(fblock,coeff_ind); Quant(coeff_ind,qcoeff_ind,QP,I); coeff_ind += 64; qcoeff_ind += 64; } } for (i=0;i<8;i++) { for (j=0;j<8;j++) { *(fblock+i*8+j) = mb_orig->Cb[i][j]; } } Dct(fblock,coeff_ind); Quant(coeff_ind,qcoeff_ind,QP,I); coeff_ind += 64; qcoeff_ind += 64; for (i=0;i<8;i++) { for (j=0;j<8;j++) { *(fblock+i*8+j) = mb_orig->Cr[i][j]; } } Dct(fblock,coeff_ind); Quant(coeff_ind,qcoeff_ind,QP,I); return qcoeff; }

MB_Structure* MB_Recon (  PictImage *  prev_recon, MB_Structure *  diff, int  x_curr, int  y_curr, MotionVector *  MV )

MB_Structure* MB_Recon_B (  PictImage *  prev, MB_Structure *  diff, unsigned char *  prev_ipol, int  x_curr, int  y_curr, MotionVector *  MV[5][MBR+1][MBC+2], MB_Structure *  recon_P, int  TR, int  TRB )

Definition at line 360 of file vid_pred.c. References mb_structure::Cb, mb_structure::Cr, FindBiDirChrPredPB(), FindBiDirLumPredPB(), FindChromBlock_P(), FindForwLumPredPB(), mb_structure::lum, MB_SIZE, MB_Structure, motionvector::Mode, MotionVector, PictImage, roundtab, sign, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by CodeOneOrTwo(). { int i,j,k; int dx, dy, bdx, bdy, mvx, mvy, xvec, yvec; MB_Structure *recon_B = (MB_Structure *)malloc(sizeof(MB_Structure)); MB_Structure *pred = (MB_Structure *)malloc(sizeof(MB_Structure)); MotionVector *f[5]; for (k = 0; k <= 4; k++) f[k] = MV[k][y/MB_SIZE+1][x/MB_SIZE+1]; bdx = MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->x; bdy = MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->y; if (f[0]->Mode == MODE_INTER4V) { /* Mode INTER4V */ /* Find forward prediction */ /* Luma */ FindForwLumPredPB(prev_ipol,x,y,f[1],&pred->lum[0][0],TRD,TRB,bdx,bdy,8,0); FindForwLumPredPB(prev_ipol,x,y,f[2],&pred->lum[0][8],TRD,TRB,bdx,bdy,8,1); FindForwLumPredPB(prev_ipol,x,y,f[3],&pred->lum[8][0],TRD,TRB,bdx,bdy,8,2); FindForwLumPredPB(prev_ipol,x,y,f[4],&pred->lum[8][8],TRD,TRB,bdx,bdy,8,3); /* chroma vectors are sum of B luma vectors divided and rounded */ xvec = yvec = 0; for (k = 1; k <= 4; k++) { xvec += TRB*(2*f[k]->x + f[k]->x_half)/TRD + bdx; yvec += TRB*(2*f[k]->y + f[k]->y_half)/TRD + bdy; } /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindChromBlock_P(x, y, dx, dy, prev_image, pred); /* Find bidirectional prediction */ FindBiDirLumPredPB(&recon_P->lum[0][0], f[1], &pred->lum[0][0], TRD, TRB, bdx, bdy, 0, 0); FindBiDirLumPredPB(&recon_P->lum[0][8], f[2], &pred->lum[0][8], TRD, TRB, bdx, bdy, 1, 0); FindBiDirLumPredPB(&recon_P->lum[8][0], f[3], &pred->lum[8][0], TRD, TRB, bdx, bdy, 0, 1); FindBiDirLumPredPB(&recon_P->lum[8][8], f[4], &pred->lum[8][8], TRD, TRB, bdx, bdy, 1, 1); /* chroma vectors are sum of B luma vectors divided and rounded */ xvec = yvec = 0; for (k = 1; k <= 4; k++) { mvx = 2*f[k]->x + f[k]->x_half; mvy = 2*f[k]->y + f[k]->y_half; xvec += bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx; yvec += bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy; } /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindBiDirChrPredPB(recon_P, dx, dy, pred); } else { /* Mode INTER or INTER_Q */ /* Find forward prediction */ FindForwLumPredPB(prev_ipol,x,y,f[0],&pred->lum[0][0],TRD,TRB, bdx,bdy,16,0); xvec = 4 * (TRB*(2*f[0]->x + f[0]->x_half) / TRD + bdx); yvec = 4 * (TRB*(2*f[0]->y + f[0]->y_half) / TRD + bdy); /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindChromBlock_P(x, y, dx, dy, prev_image, pred); /* Find bidirectional prediction */ FindBiDirLumPredPB(&recon_P->lum[0][0], f[0], &pred->lum[0][0], TRD, TRB, bdx, bdy, 0, 0); FindBiDirLumPredPB(&recon_P->lum[0][8], f[0], &pred->lum[0][8], TRD, TRB, bdx, bdy, 1, 0); FindBiDirLumPredPB(&recon_P->lum[8][0], f[0], &pred->lum[8][0], TRD, TRB, bdx, bdy, 0, 1); FindBiDirLumPredPB(&recon_P->lum[8][8], f[0], &pred->lum[8][8], TRD, TRB, bdx, bdy, 1, 1); /* chroma vectors */ mvx = 2*f[0]->x + f[0]->x_half; xvec = bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx; xvec *= 4; mvy = 2*f[0]->y + f[0]->y_half; yvec = bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy; yvec *= 4; /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindBiDirChrPredPB(recon_P, dx, dy, pred); } /* Reconstruction */ for (j = 0; j < MB_SIZE; j++) for (i = 0; i < MB_SIZE; i++) recon_B->lum[j][i] = pred->lum[j][i] + diff->lum[j][i]; for (j = 0; j < MB_SIZE>>1; j++) for (i = 0; i < MB_SIZE>>1; i++) { recon_B->Cr[j][i] = pred->Cr[j][i] + diff->Cr[j][i]; recon_B->Cb[j][i] = pred->Cb[j][i] + diff->Cb[j][i]; } free(pred); return recon_B; }

MB_Structure* MB_Recon_P (  PictImage *  prev_image, unsigned char *  prev_ipol, MB_Structure *  diff, int  x_curr, int  y_curr, MotionVector *  MV[5][MBR+1][MBC+2], int  PB )

Referenced by CodeOneOrTwo().

int ModifyMode (  int  Mode, int  dquant )

Definition at line 1535 of file vid_pred.c. Referenced by CodeOneOrTwo(). { if (Mode == MODE_INTRA) { if(dquant!=0) return MODE_INTRA_Q; else return MODE_INTRA; } else{ if(dquant!=0) return MODE_INTER_Q; else return Mode; } }

void MotionEstimatePicture (  unsigned char *  curr, unsigned char *  prev, unsigned char *  prev_ipol, int  seek_dist, MotionVector *  MV[5][MBR+1][MBC+2], int  gobsync )

Referenced by CodeOneOrTwo().

void MotionEstimation (  unsigned char *  curr, unsigned char *  prev, int  x_curr, int  y_curr, int  xoff, int  yoff, int  seek_dist, MotionVector *  MV[5][MBR+1][MBC+2], int *  sad_0 )

Referenced by MotionEstimatePicture(), and NextTwoPB().

int NextTwoPB (  PictImage *  p2, PictImage *  bim, PictImage *  p1, int  bskip, int  pskip, int  seek_dist )

Definition at line 75 of file vid_main.c. References video_codec::advanced, video_codec::lines, video_codec::long_vectors, pict_image::lum, MB_SIZE, MBC, MBR, motionvector::min_error, MotionEstimation(), MotionVector, video_codec::mv_outside_frame, video_codec::pels, PictImage, SAD_MB_Bidir(), VidSt, motionvector::x, and motionvector::y. Referenced by code_video(). { int adv_is_on = 0, mof_is_on = 0, lv_is_on = 0; int psad1, psad2, bsad, psad; MotionVector *MV[6][MBR+1][MBC+2]; MotionVector *mvp, *mvbf, *mvbb; int x,y; int i,j,k,tmp; /* Temporarily disable some options to simplify motion estimation */ if ((VidSt->advanced)) { (VidSt->advanced) = OFF; adv_is_on = ON; } if ((VidSt->mv_outside_frame)) { (VidSt->mv_outside_frame) = OFF; mof_is_on = ON; } if ((VidSt->long_vectors)) { (VidSt->long_vectors) = OFF; lv_is_on = ON; } for (j = 1; j <= ((VidSt->lines)>>4); j++) for (i = 1; i <= ((VidSt->pels)>>4); i++) for (k = 0; k < 3; k++) { MV[k][j][i] = (MotionVector *)calloc(1,sizeof(MotionVector)); /* calloc to avoid Checker warnings about reading of unitizalized memory in the memcpy's below */ } mvbf = (MotionVector *)malloc(sizeof(MotionVector)); mvbb = (MotionVector *)malloc(sizeof(MotionVector)); psad = 0; psad1 = 0; psad2 = 0; bsad = 0; /* Integer motion estimation */ for ( j = 1; j < (VidSt->lines)/MB_SIZE - 1; j++) { for ( i = 1; i < (VidSt->pels)/MB_SIZE - 1 ; i++) { x = i*MB_SIZE; y = j*MB_SIZE; /* picture order: prev -> next1 -> next2 */ /* next1 and next2 can be coded as PB or PP */ /* prev is the previous encoded picture */ /* computes vectors (prev <- next2) */ MotionEstimation(next2->lum,prev->lum,x,y,0,0,seek_dist,MV,&tmp); if (MV[0][j+1][i+1]->x == 0 && MV[0][j+1][i+1]->y == 0) MV[0][j+1][i+1]->min_error += PREF_NULL_VEC; /* not necessary to prefer zero vector here */ memcpy(MV[2][j+1][i+1],MV[0][j+1][i+1],sizeof(MotionVector)); /* computes sad(prev <- next1) */ MotionEstimation(next1->lum,prev->lum,x,y,0,0,seek_dist,MV,&tmp); if (MV[0][j+1][i+1]->x == 0 && MV[0][j+1][i+1]->y == 0) MV[0][j+1][i+1]->min_error += PREF_NULL_VEC; memcpy(MV[1][j+1][i+1],MV[0][j+1][i+1],sizeof(MotionVector)); /* computes vectors for (next1 <- next2) */ MotionEstimation(next2->lum,next1->lum,x,y,0,0,seek_dist,MV,&tmp); if (MV[0][j+1][i+1]->x == 0 && MV[0][j+1][i+1]->y == 0) MV[0][j+1][i+1]->min_error += PREF_NULL_VEC; /* scales vectors for (prev <- next2 ) */ mvp = MV[2][j+1][i+1]; mvbf->x = bskip * mvp->x / (bskip + pskip); mvbb->x = - pskip * mvp->x / (bskip + pskip); mvbf->y = bskip * mvp->y / (bskip + pskip); mvbb->y = - pskip * mvp->y / (bskip + pskip); psad1 += MV[0][j+1][i+1]->min_error; psad2 += MV[1][j+1][i+1]->min_error; psad += mvp->min_error; /* computes sad(prev <- next1 -> next2) */ bsad += SAD_MB_Bidir(next1->lum + x + y*(VidSt->pels), next2->lum + x + mvbb->x + (y + mvbb->y)*(VidSt->pels), prev->lum + x + mvbf->x + (y + mvbf->y)*(VidSt->pels), (VidSt->pels), INT_MAX); } } for (j = 1; j <= ((VidSt->lines)>>4); j++) for (i = 1; i <= ((VidSt->pels)>>4); i++) for (k = 0; k < 3; k++) free(MV[k][j][i]); free(mvbf); free(mvbb); /* restore advanced parameters */ (VidSt->advanced) = adv_is_on; (VidSt->mv_outside_frame) = mof_is_on; (VidSt->long_vectors) = lv_is_on; /* do the decision */ if (bsad < (psad1+psad2)/2) fprintf(stdout,"Chose PB - bsad %d, psad %d\n", bsad, (psad1+psad2)/2); else fprintf(stdout,"Chose PP - bsad %d, psad %d\n", bsad, (psad1+psad2)/2); if (bsad < (psad1 + psad2)/2) return 1; else return 0; }

MB_Structure* Predict (  PictImage *  curr, PictImage *  prev_recon, int  x_curr, int  y_curr, MotionVector *  MV )

MB_Structure* Predict_B (  PictImage *  curr_image, PictImage *  prev_image, unsigned char *  prev_ipol, int  x_curr, int  y_curr, MotionVector *  fr[5][MBR+1][MBC+2], MB_Structure *  recon_P, int  TR, int  TRB )

Definition at line 156 of file vid_pred.c. References pict_image::Cb, mb_structure::Cb, video_codec::cpels, pict_image::Cr, mb_structure::Cr, FindBiDirChrPredPB(), FindBiDirLumPredPB(), FindChromBlock_P(), FindForwLumPredPB(), FindMB(), video_codec::lines, mb_structure::lum, pict_image::lum, MB_SIZE, MB_Structure, motionvector::Mode, MODE_INTRA, MotionVector, video_codec::mv_outside_frame, video_codec::pels, PictImage, roundtab, SAD_MB_integer(), sign, VidSt, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by CodeOneOrTwo(). { int i,j,k; int dx, dy, sad, sad_min=INT_MAX, curr[16][16], bdx=0, bdy=0; MB_Structure *p_err = (MB_Structure *)malloc(sizeof(MB_Structure)); MB_Structure *pred = (MB_Structure *)malloc(sizeof(MB_Structure)); MotionVector *f[5]; int xvec, yvec, mvx, mvy; for (k = 0; k <= 4; k++) f[k] = MV[k][y/MB_SIZE+1][x/MB_SIZE+1]; /* Find MB in current image */ FindMB(x, y, curr_image->lum, curr); if (f[0]->Mode == MODE_INTER4V) { /* Mode INTER4V */ /* Find forward prediction */ /* Luma */ for (j = -DEF_PBDELTA_WIN; j <= DEF_PBDELTA_WIN; j++) { for (i = -DEF_PBDELTA_WIN; i <= DEF_PBDELTA_WIN; i++) { FindForwLumPredPB(prev_ipol, x, y, f[1], &pred->lum[0][0], TRD, TRB, i, j, 8, 0); FindForwLumPredPB(prev_ipol, x, y, f[2], &pred->lum[0][8], TRD, TRB, i, j, 8, 1); FindForwLumPredPB(prev_ipol, x, y, f[3], &pred->lum[8][0], TRD, TRB, i, j, 8, 2); FindForwLumPredPB(prev_ipol, x, y, f[4], &pred->lum[8][8], TRD, TRB, i, j, 8, 3); sad = SAD_MB_integer(&curr[0][0],&pred->lum[0][0], 16,INT_MAX); if (i == 0 && j == 0) sad -= PREF_PBDELTA_NULL_VEC; if (sad < sad_min) { sad_min = sad; bdx = i; bdy = j; } } } FindForwLumPredPB(prev_ipol,x,y,f[1],&pred->lum[0][0],TRD,TRB,bdx,bdy,8,0); FindForwLumPredPB(prev_ipol,x,y,f[2],&pred->lum[0][8],TRD,TRB,bdx,bdy,8,1); FindForwLumPredPB(prev_ipol,x,y,f[3],&pred->lum[8][0],TRD,TRB,bdx,bdy,8,2); FindForwLumPredPB(prev_ipol,x,y,f[4],&pred->lum[8][8],TRD,TRB,bdx,bdy,8,3); /* chroma vectors are sum of B luma vectors divided and rounded */ xvec = yvec = 0; for (k = 1; k <= 4; k++) { xvec += TRB*(2*f[k]->x + f[k]->x_half)/TRD + bdx; yvec += TRB*(2*f[k]->y + f[k]->y_half)/TRD + bdy; } /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindChromBlock_P(x, y, dx, dy, prev_image, pred); /* Find bidirectional prediction */ FindBiDirLumPredPB(&recon_P->lum[0][0], f[1], &pred->lum[0][0], TRD, TRB, bdx, bdy, 0, 0); FindBiDirLumPredPB(&recon_P->lum[0][8], f[2], &pred->lum[0][8], TRD, TRB, bdx, bdy, 1, 0); FindBiDirLumPredPB(&recon_P->lum[8][0], f[3], &pred->lum[8][0], TRD, TRB, bdx, bdy, 0, 1); FindBiDirLumPredPB(&recon_P->lum[8][8], f[4], &pred->lum[8][8], TRD, TRB, bdx, bdy, 1, 1); /* chroma vectors are sum of B luma vectors divided and rounded */ xvec = yvec = 0; for (k = 1; k <= 4; k++) { mvx = 2*f[k]->x + f[k]->x_half; mvy = 2*f[k]->y + f[k]->y_half; xvec += bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx; yvec += bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy; } /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindBiDirChrPredPB(recon_P, dx, dy, pred); } else { /* Mode INTER or INTER_Q */ /* Find forward prediction */ for (j = -DEF_PBDELTA_WIN; j <= DEF_PBDELTA_WIN; j++) { for (i = -DEF_PBDELTA_WIN; i <= DEF_PBDELTA_WIN; i++) { dx = i; dy = j; /* To keep things simple I turn off PB delta vectors at the edges */ if (!(VidSt->mv_outside_frame)) { if (x == 0) dx = 0; if (x == (VidSt->pels) - MB_SIZE) dx = 0; if (y == 0) dy = 0; if (y == (VidSt->lines) - MB_SIZE) dy = 0; } if (f[0]->Mode == MODE_INTRA || f[0]->Mode == MODE_INTRA_Q) { dx = dy = 0; } if (f[0]->x == 0 && f[0]->y == 0 && f[0]->x_half == 0 && f[0]->y_half == 0) { dx = dy = 0; } FindForwLumPredPB(prev_ipol, x, y, f[0], &pred->lum[0][0], TRD, TRB, dx, dy, 16, 0); sad = SAD_MB_integer(&curr[0][0],&pred->lum[0][0], 16, INT_MAX); if (i == 0 && j == 0) sad -= PREF_PBDELTA_NULL_VEC; if (sad < sad_min) { sad_min = sad; bdx = dx; bdy = dy; } } } FindForwLumPredPB(prev_ipol,x,y,f[0],&pred->lum[0][0],TRD,TRB, bdx,bdy,16,0); xvec = 4 * (TRB*(2*f[0]->x + f[0]->x_half) / TRD + bdx); yvec = 4 * (TRB*(2*f[0]->y + f[0]->y_half) / TRD + bdy); /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindChromBlock_P(x, y, dx, dy, prev_image, pred); /* Find bidirectional prediction */ FindBiDirLumPredPB(&recon_P->lum[0][0], f[0], &pred->lum[0][0], TRD, TRB, bdx, bdy, 0, 0); FindBiDirLumPredPB(&recon_P->lum[0][8], f[0], &pred->lum[0][8], TRD, TRB, bdx, bdy, 1, 0); FindBiDirLumPredPB(&recon_P->lum[8][0], f[0], &pred->lum[8][0], TRD, TRB, bdx, bdy, 0, 1); FindBiDirLumPredPB(&recon_P->lum[8][8], f[0], &pred->lum[8][8], TRD, TRB, bdx, bdy, 1, 1); /* chroma vectors */ mvx = 2*f[0]->x + f[0]->x_half; xvec = bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx; xvec *= 4; mvy = 2*f[0]->y + f[0]->y_half; yvec = bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy; yvec *= 4; /* round values according to TABLE 16/H.263 */ dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2); dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2); FindBiDirChrPredPB(recon_P, dx, dy, pred); } /* store PB-deltas */ MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->x = bdx; /* is in half pel format */ MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->y = bdy; MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->x_half = 0; MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->y_half = 0; /* Do the actual prediction */ for (j = 0; j < MB_SIZE; j++) for (i = 0; i < MB_SIZE; i++) p_err->lum[j][i] = *(curr_image->lum+x+i + (y+j)*(VidSt->pels)) - pred->lum[j][i]; y >>= 1; x >>= 1; for (j = 0; j < MB_SIZE>>1; j++) for (i = 0; i < MB_SIZE>>1; i++) { p_err->Cr[j][i] = *(curr_image->Cr+x+i + (y+j)*(VidSt->cpels)) - pred->Cr[j][i]; p_err->Cb[j][i] = *(curr_image->Cb+x+i + (y+j)*(VidSt->cpels)) - pred->Cb[j][i]; } free(pred); return p_err; }

MB_Structure* Predict_P (  PictImage *  curr_image, PictImage *  prev_image, unsigned char *  prev_ipol, int  x_curr, int  y_curr, MotionVector *  fr[5][MBR+1][MBC+2], int  PB )

Referenced by CodeOneOrTwo().

void PrintResult (  Bits *  bits, int  num_units, int  num )

Definition at line 204 of file vid_main.c. References Bits, bits_counted::C, bits_counted::CBPB, bits_counted::CBPCM, bits_counted::CBPY, bits_counted::COD, bits_counted::DQUANT, bits_counted::header, bits_counted::MODB, bits_counted::no_inter, bits_counted::no_inter4v, bits_counted::no_intra, bits_counted::total, bits_counted::vec, and bits_counted::Y. Referenced by close_video_codec(), and code_video(). { fprintf(stdout,"# intra : %d\n", bits->no_intra/num_units); fprintf(stdout,"# inter : %d\n", bits->no_inter/num_units); fprintf(stdout,"# inter4v : %d\n", bits->no_inter4v/num_units); fprintf(stdout,"--------------\n"); fprintf(stdout,"Coeff_Y: %d\n", bits->Y/num); fprintf(stdout,"Coeff_C: %d\n", bits->C/num); fprintf(stdout,"Vectors: %d\n", bits->vec/num); fprintf(stdout,"CBPY : %d\n", bits->CBPY/num); fprintf(stdout,"MCBPC : %d\n", bits->CBPCM/num); fprintf(stdout,"MODB : %d\n", bits->MODB/num); fprintf(stdout,"CBPB : %d\n", bits->CBPB/num); fprintf(stdout,"COD : %d\n", bits->COD/num); fprintf(stdout,"DQUANT : %d\n", bits->DQUANT/num); fprintf(stdout,"header : %d\n", bits->header/num); fprintf(stdout,"==============\n"); fprintf(stdout,"Total : %d\n", bits->total/num); fprintf(stdout,"\n"); return; }

void PrintSNR (  Results *  res, int  num )

Definition at line 226 of file vid_main.c. References Results, results::SNR_Cb, results::SNR_Cr, and results::SNR_l. Referenced by close_video_codec(), and code_video(). { FILE *fp = fopen("snr.dat","a"); assert(fp!=NULL); fprintf(fp,"%.2f %.2f %.2f\n",res->SNR_l/num,res->SNR_Cb/num,res->SNR_Cr/num); fclose(fp); fprintf(stdout,"SNR_Y : %.2f\n", res->SNR_l/num); fprintf(stdout,"SNR_Cb : %.2f\n", res->SNR_Cb/num); fprintf(stdout,"SNR_Cr : %.2f\n", res->SNR_Cr/num); fprintf(stdout,"--------------\n"); return; }

void putbits (  int  , int  )

Definition at line 73 of file vid_putbits.c. References al_send_byte(), BitPrint(), video_codec::bytecnt, video_codec::label, video_codec::outbfr, video_codec::outcnt, video_codec::output, video_codec::simbuffer, video_codec::streamfile, video_codec::tf, video_codec::trace, and VidSt. Referenced by alignbits(), bit_in_psc_layer(), CodeCoeff(), CountBitsMB(), CountBitsPicture(), CountBitsSlice(), put_cbpcm_inter(), put_cbpcm_intra(), put_cbpy(), put_coeff(), and put_mv(). { int i; unsigned int mask; char bitstring[32]; if ((VidSt->trace)) { if (n > 0) { BitPrint(n,val,bitstring); fprintf((VidSt->tf),bitstring); } } mask = 1 << (n-1); /* selects first (leftmost) bit */ for (i=0; i<n; i++) { (VidSt->outbfr) <<= 1; if (val & mask) (VidSt->outbfr)|= 1; mask >>= 1; /* select next bit */ (VidSt->outcnt)--; if ((VidSt->outcnt)==0) /* 8 bit buffer full */ { putc((VidSt->outbfr),(VidSt->streamfile)); if (al_send_byte((VidSt->output), (VidSt->outbfr)) == 0) printf("!: \"%s\" overwrote AL-buffer!\n", (VidSt->label)); (VidSt->simbuffer)++; (VidSt->outcnt) = 8; (VidSt->bytecnt)++; } } }

void Quant (  int *  coeff, int *  qcoeff, int  QP, int  I )

Definition at line 61 of file vid_quant.c. References mmax, mmin, MODE_INTRA, and sign. Referenced by MB_Encode(). { int i; int level; if (QP) { if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */ qcoeff[0] = mmax(1,mmin(254,coeff[0]/8)); for (i = 1; i < 64; i++) { level = (abs(coeff[i])) / (2*QP); qcoeff[i] = mmin(127,mmax(-127,sign(coeff[i]) * level)); } } else { /* non Intra */ for (i = 0; i < 64; i++) { level = (abs(coeff[i])-QP/2) / (2*QP); qcoeff[i] = mmin(127,mmax(-127,sign(coeff[i]) * level)); } } } else { /* No quantizing. Used only for testing. Bitstream will not be decodable whether clipping is performed or not */ for (i = 0; i < 64; i++) { qcoeff[i] = coeff[i]; } } return; }

unsigned char* ReadImage (  char *  filename, int  frame_no, int  headerlength )

Definition at line 62 of file vid_io.c. References video_codec::lines, video_codec::pels, and VidSt. Referenced by code_video(). { FILE *im_file = NULL; int im_size = (VidSt->pels)*(VidSt->lines)*3/2; unsigned char *raw; int status; if ((raw = (unsigned char *)malloc(sizeof(char)*im_size)) == NULL) { fprintf(stderr,"Couldn't allocate memory to image\n"); exit(-1); } if ((im_file = fopen(filename,"rb")) == NULL) { fprintf(stderr,"Unable to open image_file: %s\n",filename); exit(-1); } rewind(im_file); /* Find the correct image */ status = fseek(im_file,headerlength + (frame_no) * im_size,0); if (status != 0) { fprintf(stderr,"Error in seeking image no: %d\n",frame_no); fprintf(stderr,"From file: %s\n",filename); exit(-1); } /* Read image */ fprintf(stdout,"Reading image no: %d\n",frame_no); if ((status = fread(raw, sizeof(char), im_size, im_file)) != im_size) { fprintf(stderr,"Error in reading image no: %d\n",frame_no); fprintf(stderr,"From file: %s\n",filename); exit(-1); } fclose(im_file); return raw; }

void ReconChromBlock_P (  int  x_curr, int  y_curr, int  dx, int  dy, PictImage *  prev, MB_Structure *  data )

Definition at line 1285 of file vid_pred.c. References mb_structure::Cb, pict_image::Cb, mb_structure::Cr, pict_image::Cr, data, video_codec::long_vectors, MB_Structure, video_codec::mv_outside_frame, video_codec::pels, PictImage, and VidSt. Referenced by MB_Recon_P(). { int m,n; int x, y, ofx, ofy, pel,lx; int xint, yint; int xh, yh; lx = ((VidSt->mv_outside_frame) ? (VidSt->pels)/2 + ((VidSt->long_vectors)?32:16) : (VidSt->pels)/2); x = x_curr>>1; y = y_curr>>1; xint = dx>>1; xh = dx & 1; yint = dy>>1; yh = dy & 1; if (!xh && !yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=*(prev->Cr+ofx + (ofy )*lx); data->Cr[n][m] += pel; pel=*(prev->Cb+ofx + (ofy )*lx); data->Cb[n][m] += pel; } } } else if (!xh && yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx + (ofy+yh)*lx) + 1)>>1; data->Cr[n][m] += pel; pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx + (ofy+yh)*lx) + 1)>>1; data->Cb[n][m] += pel; } } } else if (xh && !yh) { for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx+xh + (ofy )*lx) + 1)>>1; data->Cr[n][m] += pel; pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx+xh + (ofy )*lx) + 1)>>1; data->Cb[n][m] += pel; } } } else { /* xh && yh */ for (n = 0; n < 8; n++) { for (m = 0; m < 8; m++) { ofx = x + xint + m; ofy = y + yint + n; pel=(*(prev->Cr+ofx + (ofy )*lx)+ *(prev->Cr+ofx+xh + (ofy )*lx)+ *(prev->Cr+ofx + (ofy+yh)*lx)+ *(prev->Cr+ofx+xh + (ofy+yh)*lx)+ 2)>>2; data->Cr[n][m] += pel; pel=(*(prev->Cb+ofx + (ofy )*lx)+ *(prev->Cb+ofx+xh + (ofy )*lx)+ *(prev->Cb+ofx + (ofy+yh)*lx)+ *(prev->Cb+ofx+xh + (ofy+yh)*lx)+ 2)>>2; data->Cb[n][m] += pel; } } } return; }

void ReconImage (  int  i, int  j, MB_Structure *  data, PictImage *  recon )

Definition at line 747 of file vid_coder.c. References mb_structure::Cb, pict_image::Cb, video_codec::cpels, mb_structure::Cr, pict_image::Cr, data, mb_structure::lum, pict_image::lum, MB_Structure, video_codec::pels, PictImage, and VidSt. Referenced by CodeOneIntra(), and CodeOneOrTwo(). { int n; register int m; int x_curr, y_curr; x_curr = i * MB_SIZE; y_curr = j * MB_SIZE; /* Fill in luminance data */ for (n = 0; n < MB_SIZE; n++) for (m= 0; m < MB_SIZE; m++) { *(recon->lum + x_curr+m + (y_curr+n)*(VidSt->pels)) = data->lum[n][m]; } /* Fill in chrominance data */ for (n = 0; n < MB_SIZE>>1; n++) for (m = 0; m < MB_SIZE>>1; m++) { *(recon->Cr + (x_curr>>1)+m + ((y_curr>>1)+n)*(VidSt->cpels)) = data->Cr[n][m]; *(recon->Cb + (x_curr>>1)+m + ((y_curr>>1)+n)*(VidSt->cpels)) = data->Cb[n][m]; } return; }

void ReconLumBlock_P (  int  x, int  y, MotionVector *  fr, unsigned char *  prev, int *  data, int  bs, int  comp )

Definition at line 1249 of file vid_pred.c. References data, video_codec::long_vectors, MotionVector, video_codec::mv_outside_frame, video_codec::pels, VidSt, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by MB_Recon_P(). { int m, n; int x1, y1, lx; lx = ((VidSt->mv_outside_frame) ? (VidSt->pels) + ((VidSt->long_vectors)?64:32) : (VidSt->pels)); x1 = 2*(x + fr->x) + fr->x_half; y1 = 2*(y + fr->y) + fr->y_half; x1 += ((comp&1)<<4); y1 += ((comp&2)<<3); for (n = 0; n < bs; n++) { for (m = 0; m < bs; m++) { *(data+m+n*16) += (int)(*(prev+x1+2*m + (y1+2*n)*2*lx)); } } return; }

int SAD_Block (  unsigned char *  ii, unsigned char *  act_block, int  h_length, int  min_sofar )

Definition at line 394 of file vid_mot_est.c. Referenced by MotionEstimation(). { int i; int sad = 0; unsigned char *kk; kk = act_block; i = 8; while (i--) { sad += (abs(*ii - *kk ) +abs(*(ii+1 ) - *(kk+1) ) +abs(*(ii+2) - *(kk+2) ) +abs(*(ii+3 ) - *(kk+3) ) +abs(*(ii+4) - *(kk+4) ) +abs(*(ii+5 ) - *(kk+5) ) +abs(*(ii+6) - *(kk+6) ) +abs(*(ii+7 ) - *(kk+7) )); ii += h_length; kk += 16; if (sad > min_sofar) return INT_MAX; } return sad; }

int SAD_Macroblock (  unsigned char *  ii, unsigned char *  act_block, int  h_length, int  Min_FRAME )

Definition at line 367 of file vid_mot_est.c. Referenced by MotionEstimation(). { int i; int sad = 0; unsigned char *kk; kk = act_block; i = 16; while (i--) { sad += (abs(*ii - *kk ) +abs(*(ii+1 ) - *(kk+1) ) +abs(*(ii+2) - *(kk+2) ) +abs(*(ii+3 ) - *(kk+3) ) +abs(*(ii+4) - *(kk+4) ) +abs(*(ii+5 ) - *(kk+5) ) +abs(*(ii+6) - *(kk+6) ) +abs(*(ii+7 ) - *(kk+7) ) +abs(*(ii+8) - *(kk+8) ) +abs(*(ii+9 ) - *(kk+9) ) +abs(*(ii+10)- *(kk+10)) +abs(*(ii+11) - *(kk+11)) +abs(*(ii+12)- *(kk+12)) +abs(*(ii+13) - *(kk+13)) +abs(*(ii+14)- *(kk+14)) +abs(*(ii+15) - *(kk+15)) ); ii += h_length; kk += 16; if (sad > Min_FRAME) return INT_MAX; } return sad; }

int SAD_MB_Bidir (  unsigned char *  ii, unsigned char *  aa, unsigned char *  bb, int  width, int  min_sofar )

Definition at line 417 of file vid_mot_est.c. Referenced by NextTwoPB(). { int i, sad = 0; unsigned char *ll, *kk; kk = aa; ll = bb; i = 16; while (i--) { sad += (abs(*ii - ((*kk + *ll )>>1)) + abs(*(ii+1) - ((*(kk+1)+ *(ll+1))>>1)) + abs(*(ii+2) - ((*(kk+2)+ *(ll+2))>>1)) + abs(*(ii+3) - ((*(kk+3)+ *(ll+3))>>1)) + abs(*(ii+4) - ((*(kk+4)+ *(ll+4))>>1)) + abs(*(ii+5) - ((*(kk+5)+ *(ll+5))>>1)) + abs(*(ii+6) - ((*(kk+6)+ *(ll+6))>>1)) + abs(*(ii+7) - ((*(kk+7)+ *(ll+7))>>1)) + abs(*(ii+8) - ((*(kk+8)+ *(ll+8))>>1)) + abs(*(ii+9) - ((*(kk+9)+ *(ll+9))>>1)) + abs(*(ii+10) - ((*(kk+10)+ *(ll+10))>>1)) + abs(*(ii+11) - ((*(kk+11)+ *(ll+11))>>1)) + abs(*(ii+12) - ((*(kk+12)+ *(ll+12))>>1)) + abs(*(ii+13) - ((*(kk+13)+ *(ll+13))>>1)) + abs(*(ii+14) - ((*(kk+14)+ *(ll+14))>>1)) + abs(*(ii+15) - ((*(kk+15)+ *(ll+15))>>1))); ii += width; kk += width; ll += width; if (sad > min_sofar) return INT_MAX; } return sad; }

int SAD_MB_integer (  int *  ii, int *  act_block, int  h_length, int  min_sofar )

Definition at line 452 of file vid_mot_est.c. Referenced by Predict_B(). { int i, sad = 0, *kk; kk = act_block; i = 16; while (i--) { sad += (abs(*ii - *kk ) +abs(*(ii+1 ) - *(kk+1) ) +abs(*(ii+2) - *(kk+2) ) +abs(*(ii+3 ) - *(kk+3) ) +abs(*(ii+4) - *(kk+4) ) +abs(*(ii+5 ) - *(kk+5) ) +abs(*(ii+6) - *(kk+6) ) +abs(*(ii+7 ) - *(kk+7) ) +abs(*(ii+8) - *(kk+8) ) +abs(*(ii+9 ) - *(kk+9) ) +abs(*(ii+10)- *(kk+10)) +abs(*(ii+11) - *(kk+11)) +abs(*(ii+12)- *(kk+12)) +abs(*(ii+13) - *(kk+13)) +abs(*(ii+14)- *(kk+14)) +abs(*(ii+15) - *(kk+15)) ); ii += h_length; kk += 16; if (sad > min_sofar) return INT_MAX; } return sad; }

char* StripName (  char *  s  )

int UpdateQuantizer (  int  mb, float  QP_mean, int  pict_type, float  bit_rate, int  mb_width, int  mb_height, int  bitcount )

Definition at line 168 of file vid_ratectrl.c. References video_codec::B_target, bitcount(), video_codec::global_adj, mmax, mmin, and VidSt. Referenced by CodeOneOrTwo(). { int newQP=16; float local_adj, descrepency, projection; if (pict_type == PCT_INTRA) { newQP = 16; /* Changed from newQP = 16;, BD 8/27/96 */ } else if (pict_type == PCT_INTER) { /* compute expected buffer fullness */ projection = mb * ((VidSt->B_target) / (mb_width*mb_height)); /* measure descrepency between current fullness and projection */ descrepency= (bitcount - projection); /* scale */ local_adj = 12 * descrepency / bit_rate; #if(0) printf("mb = %d\n",mb); printf("bit_count = %d projection = %.2f \n",bitcount,projection); printf("B_target = %.2f local_adj = %.2f \n",(VidSt->B_target),local_adj); #endif newQP = (int)(QP_mean * (1 + (VidSt->global_adj) + local_adj) + 0.5); /* the update equation for newQP in TMN4 document section 3.7 */ } else { fprintf(stderr,"Error (UpdateQuantizer): picture type unkown.\n"); } #if(0) printf("mb = %d newQP = %d \n",mb,newQP); #endif newQP = mmax(1,mmin(31,newQP)); return newQP; }

void UpdateRateControl (  int  bits  )

Definition at line 90 of file vid_ratectrl.c. References video_codec::B_prev, and VidSt. Referenced by code_video(). { (VidSt->B_prev) = (float)bits; }

void WriteImage (  PictImage *  image, char *  filename )

Definition at line 142 of file vid_io.c. References pict_image::Cb, pict_image::Cr, video_codec::lines, pict_image::lum, video_codec::pels, PictImage, and VidSt. Referenced by code_video(). { int status; FILE *f_out; /* Opening file */ if ((f_out = fopen(filename,"ab")) == NULL) { fprintf(stderr,"%s%s\n","Error in opening file: ",filename); exit(-1); } /* Writing lum to file */ if ((status = fwrite(image->lum,sizeof(char),(VidSt->pels)*(VidSt->lines),f_out)) != (VidSt->pels)*(VidSt->lines)) { fprintf(stderr,"%s%s\n","Error in writing to file: ",filename); exit(-1); } /* Writing Cb to file */ if ((status = fwrite(image->Cb,sizeof(char),(VidSt->pels)*(VidSt->lines)/4,f_out)) != (VidSt->pels)*(VidSt->lines)/4) { fprintf(stderr,"%s%s\n","Error in writing to file: ",filename); exit(-1); } /* Writing Cr to file */ if ((status = fwrite(image->Cr,sizeof(char),(VidSt->pels)*(VidSt->lines)/4,f_out)) != (VidSt->pels)*(VidSt->lines)/4) { fprintf(stderr,"%s%s\n","Error in writing to file: ",filename); exit(-1); } fclose(f_out); return; }

void ZeroBits (  Bits *  bits  )

Definition at line 1044 of file vid_countbit.c. References Bits, bits_counted::C, bits_counted::CBPB, bits_counted::CBPCM, bits_counted::CBPY, bits_counted::COD, bits_counted::DQUANT, bits_counted::header, bits_counted::MODB, bits_counted::no_inter, bits_counted::no_inter4v, bits_counted::no_intra, bits_counted::total, bits_counted::vec, and bits_counted::Y. Referenced by code_video(), CodeOneIntra(), and CodeOneOrTwo(). { bits->Y = 0; bits->C = 0; bits->vec = 0; bits->CBPY = 0; bits->CBPCM = 0; bits->MODB = 0; bits->CBPB = 0; bits->COD = 0; bits->DQUANT = 0; bits->header = 0; bits->total = 0; bits->no_inter = 0; bits->no_inter4v = 0; bits->no_intra = 0; return; }

void ZeroMBlock (  MB_Structure *  data  )

Definition at line 717 of file vid_coder.c. References mb_structure::Cb, mb_structure::Cr, data, mb_structure::lum, and MB_Structure. Referenced by CodeOneOrTwo(). { int n; register int m; for (n = 0; n < MB_SIZE; n++) for (m = 0; m < MB_SIZE; m++) data->lum[n][m] = 0; for (n = 0; n < (MB_SIZE>>1); n++) for (m = 0; m < (MB_SIZE>>1); m++) { data->Cr[n][m] = 0; data->Cb[n][m] = 0; } return; }

void ZeroRes (  Results *  res  )

Definition at line 1062 of file vid_countbit.c. References results::QP_mean, Results, results::SNR_Cb, results::SNR_Cr, and results::SNR_l. Referenced by code_video(). { res->SNR_l = (float)0; res->SNR_Cr = (float)0; res->SNR_Cb = (float)0; res->QP_mean = (float)0; }

void ZeroVec (  MotionVector *  MV  )

Definition at line 1110 of file vid_countbit.c. References MotionVector, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half. Referenced by CodeOneOrTwo(), and MotionEstimatePicture(). { MV->x = 0; MV->y = 0; MV->x_half = 0; MV->y_half = 0; return; }

---