Main Page | Class List | File List | Class Members | File Members

vid_countbit.c File Reference

#include "vid_sim.h"
#include "vid_sactbls.h"
#include "vid_indices.h"
#include "vid_putvlc.h"
#include "video_codec.h"

Go to the source code of this file.

Functions

void CountBitsMB (int Mode, int COD, int CBP, int CBPB, Pict *pic, Bits *bits)
void Count_sac_BitsMB (int Mode, int COD, int CBP, int CBPB, Pict *pic, Bits *bits)
int CountBitsSlice (int slice, int quant)
void CountBitsCoeff (int *qcoeff, int Mode, int CBP, Bits *bits, int ncoeffs)
int CodeCoeff (int Mode, int *qcoeff, int block, int ncoeffs)
void Count_sac_BitsCoeff (int *qcoeff, int Mode, 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)
int FindCBP (int *qcoeff, int Mode, int ncoeffs)
void CountBitsVectors (MotionVector *MV[6][MBR+1][MBC+2], Bits *bits, int x, int y, int Mode, int newgob, Pict *pic)
void Count_sac_BitsVectors (MotionVector *MV[6][MBR+1][MBC+2], Bits *bits, int x, int y, int Mode, int newgob, Pict *pic)
void FindPMV (MotionVector *MV[6][MBR+1][MBC+2], int x, int y, int *pmv0, int *pmv1, int block, int newgob, int half_pel)
void ZeroBits (Bits *bits)
void ZeroRes (Results *res)
void AddBits (Bits *total, Bits *bits)
void AddRes (Results *total, Results *res, Pict *pic)
void AddBitsPicture (Bits *bits)
void ZeroVec (MotionVector *MV)
void MarkVec (MotionVector *MV)
void CopyVec (MotionVector *MV2, MotionVector *MV1)
int EqualVec (MotionVector *MV2, MotionVector *MV1)
int CountBitsPicture (Pict *pic)

Variables

video_codecVidSt


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().

01070 {
01071   total->Y += bits->Y;
01072   total->C += bits->C;
01073   total->vec += bits->vec;
01074   total->CBPY += bits->CBPY;
01075   total->CBPCM += bits->CBPCM;
01076   total->MODB += bits->MODB;
01077   total->CBPB += bits->CBPB;
01078   total->COD += bits->COD;
01079   total->DQUANT += bits->DQUANT;
01080   total->header += bits->header;
01081   total->total += bits->total;
01082   total->no_inter += bits->no_inter;
01083   total->no_inter4v += bits->no_inter4v;
01084   total->no_intra += bits->no_intra;
01085   return;
01086 }

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().

01097 {
01098   bits->total = 
01099     bits->Y + 
01100     bits->C + 
01101     bits->vec +  
01102     bits->CBPY + 
01103     bits->CBPCM + 
01104     bits->MODB +
01105     bits->CBPB +
01106     bits->COD + 
01107     bits->DQUANT +
01108     bits->header ;
01109 } 

void AddRes Results total,
Results res,
Pict pic
 

Definition at line 1087 of file vid_countbit.c.

References Pict, results::QP_mean, pict::QP_mean, Results, results::SNR_Cb, results::SNR_Cr, and results::SNR_l.

Referenced by code_video().

01088 {
01089   total->SNR_l += res->SNR_l;
01090   total->SNR_Cr += res->SNR_Cr;
01091   total->SNR_Cb += res->SNR_Cb;
01092   total->QP_mean += pic->QP_mean;
01093   return;
01094 }

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().

00527 {
00528   int j, bits, mod_index, intra;
00529   int prev_run, run, prev_level, level, first, prev_position, position;
00530   int prev_ind, ind, prev_s, s, length;
00531  
00532   run = bits = 0;
00533   first = 1; position = 0; intra = 0;
00534  
00535   level = s = ind = 0;
00536   prev_run = prev_level = prev_ind = prev_s = prev_position = 0;
00537  
00538   intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
00539  
00540   for (j = block*ncoeffs; j< (block + 1)*ncoeffs; j++) {
00541  
00542     if (!(j%ncoeffs) && intra) {
00543       if ((VidSt->trace)) {
00544         fprintf((VidSt->tf),"DC: ");
00545       }
00546       if (qcoeff[block*ncoeffs]!=128)
00547         mod_index = indexfn(qcoeff[block*ncoeffs],intradctab,254);
00548       else
00549         mod_index = indexfn(255,intradctab,254);
00550       bits += AR_Encode(mod_index, cumf_INTRADC);
00551     }
00552     else {
00553  
00554       s = 0;
00555       /* Increment run if coeff is zero */
00556       if ((level = qcoeff[j]) == 0) {
00557         run++;
00558       }
00559       else {
00560         /* code run & level and count bits */
00561         if (level < 0) {
00562           s = 1;
00563           level = -level;
00564         }
00565         ind = level | run<<4;
00566         ind = ind | 0<<12; /* Not last coeff */
00567         position++;
00568  
00569         if (!first) {
00570           mod_index = indexfn(prev_ind, tcoeftab, 103);
00571           if (prev_level < 13 && prev_run < 64)
00572             length = CodeTCoef(mod_index, prev_position, intra);
00573           else
00574             length = -1;
00575  
00576           if (length == -1) {  /* Escape coding */
00577             if ((VidSt->trace)) {
00578               fprintf((VidSt->tf),"Escape coding:\n");
00579             }
00580  
00581             if (prev_s == 1) {prev_level = (prev_level^0xff)+1;}
00582  
00583             mod_index = indexfn(ESCAPE, tcoeftab, 103);
00584             bits += CodeTCoef(mod_index, prev_position, intra);
00585  
00586             if (intra)
00587               bits += AR_Encode(indexfn(0, lasttab, 2), cumf_LAST_intra);
00588             else
00589               bits += AR_Encode(indexfn(0, lasttab, 2), cumf_LAST);
00590  
00591             if (intra)
00592               bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN_intra);
00593             else
00594               bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN);
00595  
00596             if (intra)
00597               bits += AR_Encode(indexfn(prev_level, leveltab, 254), 
00598         cumf_LEVEL_intra);
00599             else
00600               bits += AR_Encode(indexfn(prev_level, leveltab, 254), 
00601         cumf_LEVEL);
00602  
00603           }
00604           else {
00605             bits += AR_Encode(indexfn(prev_s, signtab, 2), cumf_SIGN);
00606             bits += length;
00607           }
00608         }
00609  
00610         prev_run = run; prev_s = s;
00611         prev_level = level; prev_ind = ind;
00612         prev_position = position;
00613  
00614         run = first = 0;
00615  
00616       }
00617     }
00618   }
00619  
00620   /* Encode Last Coefficient */
00621  
00622   if (!first) {
00623     if ((VidSt->trace)) {
00624       fprintf((VidSt->tf),"Last coeff: ");
00625     }
00626     prev_ind = prev_ind | 1<<12;   /* last coeff */
00627     mod_index = indexfn(prev_ind, tcoeftab, 103);
00628  
00629     if (prev_level  < 13 && prev_run < 64)
00630       length = CodeTCoef(mod_index, prev_position, intra);
00631     else
00632       length = -1;
00633  
00634     if (length == -1) {  /* Escape coding */
00635       if ((VidSt->trace)) {
00636         fprintf((VidSt->tf),"Escape coding:\n");
00637       }
00638 
00639       if (prev_s == 1) {prev_level = (prev_level^0xff)+1;}
00640  
00641       mod_index = indexfn(ESCAPE, tcoeftab, 103);
00642       bits += CodeTCoef(mod_index, prev_position, intra);
00643  
00644       if (intra)
00645         bits += AR_Encode(indexfn(1, lasttab, 2), cumf_LAST_intra);
00646       else
00647         bits += AR_Encode(indexfn(1, lasttab, 2), cumf_LAST);
00648  
00649       if (intra)
00650         bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN_intra);
00651       else
00652         bits += AR_Encode(indexfn(prev_run, runtab, 64), cumf_RUN);
00653  
00654       if (intra)
00655         bits += AR_Encode(indexfn(prev_level, leveltab, 254), cumf_LEVEL_intra);
00656       else
00657         bits += AR_Encode(indexfn(prev_level, leveltab, 254), cumf_LEVEL);
00658     }
00659     else {
00660       bits += AR_Encode(indexfn(prev_s, signtab, 2), cumf_SIGN);
00661       bits += length;
00662     }
00663   } /* last coeff */
00664  
00665   return bits;
00666 }

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().

00362 {
00363   int j, bits;
00364   int prev_run, run, prev_level, level, first;
00365   int prev_s, s, length;
00366 
00367   run = bits = 0;
00368   first = 1;
00369   prev_run = prev_level = level = s = prev_s = 0;
00370   
00371   if ((VidSt->trace)) {
00372     fprintf((VidSt->tf),"Coeffs block %d:\n",block);
00373   }
00374 
00375   for (j = block*ncoeffs; j< (block + 1)*ncoeffs; j++) {
00376     /* Do this block's DC-coefficient first */
00377     if (!(j%ncoeffs) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)) {
00378       /* DC coeff */
00379       if ((VidSt->trace)) {
00380         fprintf((VidSt->tf),"DC: ");
00381       }
00382       if (qcoeff[block*ncoeffs] != 128)
00383         putbits(8,qcoeff[block*ncoeffs]);
00384       else
00385         putbits(8,255);
00386       bits += 8;
00387     }
00388     else {
00389       /* AC coeff */
00390       s = 0;
00391       /* Increment run if coeff is zero */
00392       if ((level = qcoeff[j]) == 0) {
00393         run++;
00394       }
00395       else {
00396         /* code run & level and count bits */
00397         if (level < 0) {
00398           s = 1;
00399           level = -level;
00400         }
00401 
00402         if (!first) {
00403           /* Encode the previous coefficient */
00404           if (prev_level  < 13 && prev_run < 64)
00405             length = put_coeff (prev_run, prev_level, 0);  
00406           else
00407             length = 0;
00408           if (length == 0) {  /* Escape coding */
00409             if ((VidSt->trace)) {
00410               fprintf((VidSt->tf),"Escape code: ");
00411             }
00412             if (prev_s == 1) {prev_level = (prev_level^0xff)+1;}
00413             putbits(7,3);       /* Escape code */
00414             if ((VidSt->trace))
00415               fprintf((VidSt->tf),"last: ");
00416             putbits(1,0);
00417             if ((VidSt->trace))
00418               fprintf((VidSt->tf),"run: ");
00419             putbits(6,prev_run);
00420             if ((VidSt->trace))
00421               fprintf((VidSt->tf),"level: ");
00422             putbits(8,prev_level);
00423             bits += 22;
00424           }
00425           else {
00426             putbits(1,prev_s);
00427             bits += length + 1;
00428           }
00429         }
00430         prev_run = run; prev_s = s;
00431         prev_level = level; 
00432 
00433         run = first = 0;
00434       }
00435     }
00436   }
00437   /* Encode the last coeff */
00438   if (!first) {
00439     if ((VidSt->trace)) {
00440       fprintf((VidSt->tf),"Last coeff: ");
00441     }
00442     if (prev_level  < 13 && prev_run < 64) 
00443       length = put_coeff (prev_run, prev_level, 1);   
00444     else
00445       length = 0;
00446     if (length == 0) {  /* Escape coding */
00447       if ((VidSt->trace)) {
00448         fprintf((VidSt->tf),"Escape code: ");
00449       }
00450       if (prev_s == 1) {prev_level = (prev_level^0xff)+1;}
00451       putbits (7,3);    /* Escape code */
00452       if ((VidSt->trace))
00453         fprintf((VidSt->tf),"last: ");
00454       putbits(1,1);
00455       if ((VidSt->trace))
00456         fprintf((VidSt->tf),"run: ");
00457       putbits(6,prev_run);
00458       if ((VidSt->trace))
00459         fprintf((VidSt->tf),"level: ");
00460       putbits(8,prev_level);
00461       bits += 22;
00462     }
00463     else {
00464       putbits(1,prev_s);
00465       bits += length + 1;
00466     }
00467   }
00468   return bits;
00469 }

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().

00687 {
00688   int length;
00689  
00690   switch (position) {
00691     case 1:
00692     {
00693         if (intra)
00694           length = AR_Encode(mod_index, cumf_TCOEF1_intra);
00695         else
00696           length = AR_Encode(mod_index, cumf_TCOEF1);
00697         break;
00698     }
00699     case 2:
00700     {
00701         if (intra)
00702           length = AR_Encode(mod_index, cumf_TCOEF2_intra);
00703         else
00704           length = AR_Encode(mod_index, cumf_TCOEF2);
00705         break;
00706     }
00707     case 3:
00708     {
00709         if (intra)
00710           length = AR_Encode(mod_index, cumf_TCOEF3_intra);
00711         else
00712           length = AR_Encode(mod_index, cumf_TCOEF3);
00713         break;
00714     }
00715     default:
00716     {
00717         if (intra)
00718           length = AR_Encode(mod_index, cumf_TCOEFr_intra);
00719         else
00720           length = AR_Encode(mod_index, cumf_TCOEFr);
00721         break;
00722     }
00723   }
00724  
00725   return length;
00726 }

void CopyVec MotionVector MV2,
MotionVector MV1
 

Definition at line 1127 of file vid_countbit.c.

References MotionVector, motionvector::x, motionvector::x_half, motionvector::y, and motionvector::y_half.

01128 {
01129   MV2->x = MV1->x;
01130   MV2->x_half = MV1->x_half;
01131   MV2->y = MV1->y;
01132   MV2->y_half = MV1->y_half;
01133   return;
01134 }

void Count_sac_BitsCoeff int *  qcoeff,
int  Mode,
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().

00487 {
00488  
00489   int i;
00490  
00491   (VidSt->arith_used) = 1;
00492  
00493   if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) {
00494     for (i = 0; i < 4; i++) {
00495       bits->Y += Code_sac_Coeff(Mode, qcoeff,i,ncoeffs);
00496     }
00497     for (i = 4; i < 6; i++) {
00498       bits->C += Code_sac_Coeff(Mode, qcoeff,i,ncoeffs);
00499     }
00500   }
00501   else {
00502     for (i = 0; i < 4; i++) {
00503       if ((i==0 && CBP&32) ||
00504           (i==1 && CBP&16) ||
00505           (i==2 && CBP&8) ||
00506           (i==3 && CBP&4) ||
00507           (i==4 && CBP&2) ||
00508           (i==5 && CBP&1)) {
00509         bits->Y += Code_sac_Coeff(Mode, qcoeff, i, ncoeffs);
00510       }
00511     }
00512     for (i = 4; i < 6; i++) {
00513       if ((i==0 && CBP&32) ||
00514           (i==1 && CBP&16) ||
00515           (i==2 && CBP&8) ||
00516           (i==3 && CBP&4) ||
00517           (i==4 && CBP&2) ||
00518           (i==5 && CBP&1)) {
00519         bits->C += Code_sac_Coeff(Mode, qcoeff, i, ncoeffs);
00520       }
00521     }
00522   }
00523   return;
00524 }

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, bits_counted::DQUANT, pict::DQUANT, dquanttab, indexfn(), pict::MB, mcbpc_intratab, mcbpctab, pict::MODB, bits_counted::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().

00170 {
00171   int cbpy, cbpcm, length, i;
00172  
00173   (VidSt->arith_used) = 1;
00174  
00175   /* COD */
00176  
00177   if ((VidSt->trace)) {
00178     fprintf((VidSt->tf),"MB-nr: %d",pic->MB);
00179     if (pic->picture_coding_type == PCT_INTER)
00180       fprintf((VidSt->tf),"  COD: %d ",COD);
00181   }
00182  
00183   if (pic->picture_coding_type == PCT_INTER)
00184     bits->COD+=AR_Encode(COD, cumf_COD);
00185  
00186   if (COD)
00187     return;    /* not coded */
00188  
00189   /* CBPCM */
00190  
00191   cbpcm = Mode | ((CBP&3)<<4);
00192   if ((VidSt->trace)) {
00193     fprintf((VidSt->tf),"CBPCM (CBP=%d) (cbpcm=%d): ",CBP,cbpcm);
00194   }
00195   if (pic->picture_coding_type == PCT_INTRA)
00196     length = AR_Encode(indexfn(cbpcm,mcbpc_intratab,9),cumf_MCBPC_intra);
00197   else
00198     length = AR_Encode(indexfn(cbpcm,mcbpctab,21),cumf_MCBPC);
00199  
00200   bits->CBPCM += length;
00201  
00202   /* MODB & CBPB */
00203    if (pic->PB) {
00204      switch (pic->MODB) {
00205      case PBMODE_NORMAL:
00206        bits->MODB += AR_Encode(0, cumf_MODB);
00207        break;
00208      case PBMODE_MVDB:
00209        bits->MODB += AR_Encode(1, cumf_MODB);
00210        break;
00211      case PBMODE_CBPB_MVDB:
00212        bits->MODB += AR_Encode(2, cumf_MODB);
00213        /* CBPB */
00214        for(i=5; i>1; i--)
00215          bits->CBPB += AR_Encode(((CBPB & 1<<i)>>i), cumf_YCBPB);
00216        for(i=1; i>-1; i--)
00217          bits->CBPB += AR_Encode(((CBPB & 1<<i)>>i), cumf_UVCBPB);
00218        break;
00219      }
00220      if ((VidSt->trace)) 
00221        fprintf((VidSt->tf),"MODB: %d, CBPB: %d\n", pic->MODB, CBPB);
00222    }
00223 
00224   /* CBPY */
00225  
00226   cbpy = CBP>>2;
00227   if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */
00228     length = AR_Encode(indexfn(cbpy,cbpy_intratab,16),cumf_CBPY_intra);
00229   } else {
00230     length = AR_Encode(indexfn(cbpy,cbpytab,16),cumf_CBPY);
00231   }
00232   if ((VidSt->trace)) {
00233     fprintf((VidSt->tf),"CBPY (CBP=%d) (cbpy=%d): ",CBP,cbpy);
00234   }
00235   bits->CBPY += length;
00236  
00237   /* DQUANT */
00238  
00239   if ((Mode == MODE_INTER_Q) || (Mode == MODE_INTRA_Q)) {
00240     if ((VidSt->trace)) {
00241       fprintf((VidSt->tf),"DQUANT: ");
00242     }
00243     bits->DQUANT += AR_Encode(indexfn(pic->DQUANT+2,dquanttab,4), cumf_DQUANT);
00244   }
00245   return;
00246 }

void Count_sac_BitsVectors MotionVector MV[6][MBR+1][MBC+2],
Bits bits,
int  x,
int  y,
int  Mode,
int  newgob,
Pict pic
 

Definition at line 862 of file vid_countbit.c.

References AR_Encode(), video_codec::arith_used, Bits, cumf_MVD, FindPMV(), indexfn(), video_codec::long_vectors, pict::MODB, MotionVector, mvdtab, pict::PB, PBMODE_MVDB, Pict, video_codec::tf, video_codec::trace, bits_counted::vec, and VidSt.

00864 {
00865   int y_vec, x_vec;
00866   int pmv0, pmv1;
00867   int start,stop,block;
00868  
00869   (VidSt->arith_used) = 1;
00870   x++;y++;
00871  
00872   if (Mode == MODE_INTER4V) {
00873     start = 1; stop = 4;
00874   }
00875   else {
00876     start = 0; stop = 0;
00877   }
00878  
00879   for (block = start; block <= stop;  block++) {
00880  
00881     FindPMV(MV,x,y,&pmv0,&pmv1, block, newgob, 1);
00882  
00883     x_vec = (2*MV[block][y][x]->x + MV[block][y][x]->x_half) - pmv0;
00884     y_vec = (2*MV[block][y][x]->y + MV[block][y][x]->y_half) - pmv1;
00885  
00886     if (!(VidSt->long_vectors)) {
00887       if (x_vec < -32) x_vec += 64;
00888       else if (x_vec > 31) x_vec -= 64;
00889 
00890       if (y_vec < -32) y_vec += 64;
00891       else if (y_vec > 31) y_vec -= 64;
00892     }
00893     else {
00894       if (pmv0 < -31 && x_vec < -63) x_vec += 64;
00895       else if (pmv0 > 32 && x_vec > 63) x_vec -= 64;
00896 
00897       if (pmv1 < -31 && y_vec < -63) y_vec += 64;
00898       else if (pmv1 > 32 && y_vec > 63) y_vec -= 64;
00899     }
00900 
00901     if (x_vec < 0) x_vec += 64;
00902     if (y_vec < 0) y_vec += 64;
00903  
00904     if ((VidSt->trace)) {
00905       fprintf((VidSt->tf),"Vectors:\n");
00906     }
00907  
00908     bits->vec += AR_Encode(indexfn(x_vec,mvdtab,64),cumf_MVD);
00909     bits->vec += AR_Encode(indexfn(y_vec,mvdtab,64),cumf_MVD);
00910  
00911     if ((VidSt->trace)) {
00912       if (x_vec > 31) x_vec -= 64;
00913       if (y_vec > 31) y_vec -= 64;
00914       fprintf((VidSt->tf),"(x,y) = (%d,%d) - ",
00915               (2*MV[block][y][x]->x + MV[block][y][x]->x_half),
00916               (2*MV[block][y][x]->y + MV[block][y][x]->y_half));
00917       fprintf((VidSt->tf),"(Px,Py) = (%d,%d)\n", pmv0,pmv1);
00918       fprintf((VidSt->tf),"(x_diff,y_diff) = (%d,%d)\n",x_vec,y_vec);
00919     }
00920   }
00921 
00922    /* PB-frames delta vectors */
00923   if (pic->PB)
00924     if (pic->MODB == PBMODE_MVDB || pic->MODB == PBMODE_CBPB_MVDB) {
00925  
00926       x_vec = MV[5][y][x]->x;
00927       y_vec = MV[5][y][x]->y;
00928  
00929       if (x_vec < -32)
00930         x_vec += 64;
00931       else if (x_vec > 31)
00932         x_vec -= 64;
00933       if (y_vec < -32)
00934         y_vec += 64;
00935       else if (y_vec > 31)
00936         y_vec -= 64;
00937       
00938       if (x_vec < 0) x_vec += 64;
00939       if (y_vec < 0) y_vec += 64;
00940       
00941       if ((VidSt->trace)) {
00942         fprintf((VidSt->tf),"PB delta vectors:\n");
00943       }
00944       
00945       bits->vec += AR_Encode(indexfn(x_vec,mvdtab,64),cumf_MVD);
00946       bits->vec += AR_Encode(indexfn(y_vec,mvdtab,64),cumf_MVD);
00947       
00948       if ((VidSt->trace)) {
00949         if (x_vec > 31) x_vec -= 64;
00950         if (y_vec > 31) y_vec -= 64;
00951         fprintf((VidSt->tf),"MVDB (x,y) = (%d,%d)\n",x_vec,y_vec);
00952       }
00953     }
00954   
00955   return;
00956 }

void CountBitsCoeff int *  qcoeff,
int  Mode,
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().

00324 {
00325   
00326   int i;
00327 
00328   if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) {
00329     for (i = 0; i < 4; i++) {
00330       bits->Y += CodeCoeff(Mode, qcoeff,i,ncoeffs);
00331     }
00332     for (i = 4; i < 6; i++) {
00333       bits->C += CodeCoeff(Mode, qcoeff,i,ncoeffs);
00334     }
00335   }
00336   else {
00337     for (i = 0; i < 4; i++) {
00338       if ((i==0 && CBP&32) || 
00339           (i==1 && CBP&16) ||
00340           (i==2 && CBP&8) || 
00341           (i==3 && CBP&4) || 
00342           (i==4 && CBP&2) ||
00343           (i==5 && CBP&1)) {
00344         bits->Y += CodeCoeff(Mode, qcoeff, i, ncoeffs);
00345       }
00346     }
00347     for (i = 4; i < 6; i++) {
00348       if ((i==0 && CBP&32) || 
00349           (i==1 && CBP&16) ||
00350           (i==2 && CBP&8) || 
00351           (i==3 && CBP&4) || 
00352           (i==4 && CBP&2) ||
00353           (i==5 && CBP&1)) {
00354         bits->C += CodeCoeff(Mode, qcoeff, i, ncoeffs);
00355       }
00356     }
00357   }
00358   return;
00359 }

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, pict::DQUANT, bits_counted::DQUANT, pict::MB, pict::MODB, bits_counted::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().

00066 {
00067   int cbpy, cbpcm, length;
00068 
00069   /* COD */
00070   if ((VidSt->trace)) {
00071     fprintf((VidSt->tf),"MB-nr: %d",pic->MB);
00072     if (pic->picture_coding_type == PCT_INTER)
00073       fprintf((VidSt->tf),"  COD: %d\n",COD);
00074   }
00075   if (pic->picture_coding_type == PCT_INTER) {
00076     putbits(1,COD);
00077     bits->COD++;
00078   }
00079 
00080   if (COD) 
00081     return;    /* not coded */
00082 
00083   /* CBPCM */
00084   cbpcm = Mode | ((CBP&3)<<4);
00085   if ((VidSt->trace)) {
00086     fprintf((VidSt->tf),"CBPCM (CBP=%d) (cbpcm=%d): ",CBP,cbpcm);
00087   }
00088   if (pic->picture_coding_type == PCT_INTRA)
00089     length = put_cbpcm_intra (CBP, Mode);
00090   else
00091     length = put_cbpcm_inter (CBP, Mode);
00092   bits->CBPCM += length;
00093 
00094     /* MODB & CBPB */
00095   if (pic->PB) {
00096     switch (pic->MODB) {
00097     case PBMODE_NORMAL:
00098       putbits(1,0);
00099       bits->MODB += 1;
00100       break;
00101     case PBMODE_MVDB:
00102       putbits(2,2);
00103       bits->MODB += 2;
00104       break;
00105     case PBMODE_CBPB_MVDB:
00106       putbits(2,3);
00107       bits->MODB += 2;
00108       /* CBPB */
00109       putbits(6,CBPB);
00110       bits->CBPB += 6;
00111       break;
00112     }
00113     if ((VidSt->trace)) 
00114       fprintf((VidSt->tf),"MODB: %d, CBPB: %d\n", pic->MODB, CBPB);
00115   }
00116     
00117   /* CBPY */
00118   cbpy = CBP>>2;
00119   if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) /* Intra */
00120     cbpy = cbpy^15;
00121   if ((VidSt->trace)) {
00122     fprintf((VidSt->tf),"CBPY (CBP=%d) (cbpy=%d): ",CBP,cbpy);
00123   }
00124   length = put_cbpy (CBP, Mode);
00125 
00126   bits->CBPY += length;
00127   
00128   /* DQUANT */
00129   if ((Mode == MODE_INTER_Q) || (Mode == MODE_INTRA_Q)) {
00130     if ((VidSt->trace)) {
00131       fprintf((VidSt->tf),"DQUANT: ");
00132     }
00133     switch (pic->DQUANT) {
00134     case -1:
00135       putbits(2,0);
00136       break;
00137     case -2:
00138       putbits(2,1);
00139       break;
00140     case 1:
00141       putbits(2,2);
00142       break;
00143     case 2:
00144       putbits(2,3);
00145       break;
00146     default:
00147       fprintf(stderr,"Invalid DQUANT\n");
00148       exit(-1);
00149     }
00150     bits->DQUANT += 2;
00151   }
00152   return;
00153 }

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().

01164 {
01165   int bits = 0;
01166 
01167   /* in case of arithmetic coding, encoder_flush() has been called before
01168      zeroflush() in vid_main.c */
01169 
01170   /* Picture start code */
01171   if ((VidSt->trace)) {
01172     fprintf((VidSt->tf),"picture_start_code: ");
01173   }
01174   putbits(PSC_LENGTH,PSC);
01175   bits += PSC_LENGTH;
01176 
01177   /* Group number */
01178   if ((VidSt->trace)) {
01179     fprintf((VidSt->tf),"Group number in picture header: ");
01180   }
01181   putbits(5,0); 
01182   bits += 5;
01183   
01184   /* Time reference */
01185   if ((VidSt->trace)) {
01186     fprintf((VidSt->tf),"Time reference: ");
01187   }
01188   putbits(8,pic->TR);
01189   bits += 8;
01190 
01191  /* bit 1 */
01192   if ((VidSt->trace)) {
01193     fprintf((VidSt->tf),"spare: ");
01194   }
01195   pic->spare = 1; /* always 1 to avoid start code emulation */
01196   putbits(1,pic->spare);
01197   bits += 1;
01198 
01199   /* bit 2 */
01200   if ((VidSt->trace)) {
01201     fprintf((VidSt->tf),"always zero for distinction with H.261\n");
01202   }
01203   putbits(1,0);
01204   bits += 1;
01205   
01206   /* bit 3 */
01207   if ((VidSt->trace)) {
01208     fprintf((VidSt->tf),"split_screen_indicator: ");
01209   }
01210   putbits(1,0);     /* no support for split-screen in this software */
01211   bits += 1;
01212 
01213   /* bit 4 */
01214   if ((VidSt->trace)) {
01215     fprintf((VidSt->tf),"document_camera_indicator: ");
01216   }
01217   putbits(1,0);
01218   bits += 1;
01219 
01220   /* bit 5 */
01221   if ((VidSt->trace)) {
01222     fprintf((VidSt->tf),"freeze_picture_release: ");
01223   }
01224   putbits(1,0);
01225   bits += 1;
01226 
01227   /* bit 6-8 */
01228   if ((VidSt->trace)) {
01229     fprintf((VidSt->tf),"source_format: ");
01230   }
01231   putbits(3,pic->source_format);
01232   bits += 3;
01233 
01234   /* bit 9 */
01235   if ((VidSt->trace)) {
01236     fprintf((VidSt->tf),"picture_coding_type: ");
01237   }
01238   putbits(1,pic->picture_coding_type);
01239   bits += 1;
01240 
01241   /* bit 10 */
01242   if ((VidSt->trace)) {
01243     fprintf((VidSt->tf),"mv_outside_frame: ");
01244   }
01245   putbits(1,pic->unrestricted_mv_mode);  /* Unrestricted Motion Vector mode */
01246   bits += 1;
01247 
01248   /* bit 11 */
01249   if ((VidSt->trace)) {
01250     fprintf((VidSt->tf),"sac_coding: ");
01251   }
01252   putbits(1,(VidSt->syntax_arith_coding)); /* Syntax-based Arithmetic Coding mode */
01253   bits += 1;
01254 
01255   /* bit 12 */
01256   if ((VidSt->trace)) {
01257     fprintf((VidSt->tf),"adv_pred_mode: ");
01258   }
01259   putbits(1,(VidSt->advanced)); /* Advanced Prediction mode */
01260   bits += 1;
01261 
01262   /* bit 13 */
01263   if ((VidSt->trace)) {
01264     fprintf((VidSt->tf),"PB-coded: "); /* PB-frames mode */
01265   }
01266   putbits(1,pic->PB);
01267   bits += 1;
01268 
01269 
01270   /* QUANT */
01271   if ((VidSt->trace)) {
01272     fprintf((VidSt->tf),"QUANT: ");
01273   }
01274   putbits(5,pic->QUANT);
01275   bits += 5;
01276 
01277   /* Continuous Presence Multipoint (CPM) */
01278   putbits(1,0); /* CPM is not supported in this software */
01279   bits += 1;
01280 
01281   /* Picture Sub Bitstream Indicator (PSBI) */
01282   /* if CPM == 1: 2 bits PSBI */
01283   /* not supported */
01284 
01285   /* extra information for PB-frames */
01286   if (pic->PB) {
01287     if ((VidSt->trace)) {
01288       fprintf((VidSt->tf),"TRB: ");
01289     }
01290     putbits(3,pic->TRB);
01291     bits += 3;
01292 
01293     if ((VidSt->trace)) {
01294       fprintf((VidSt->tf),"BQUANT: ");
01295     }
01296     putbits(2,pic->BQUANT);
01297     bits += 2;
01298     
01299   }
01300 
01301   /* PEI (extra information) */
01302   if ((VidSt->trace)) {
01303     fprintf((VidSt->tf),"PEI: ");
01304   }
01305   /* "Encoders shall not insert PSPARE until specified by the ITU" */
01306   putbits(1,0); 
01307   bits += 1;
01308 
01309   /* PSPARE */
01310   /* if PEI == 1: 8 bits PSPARE + another PEI bit */
01311   /* not supported */
01312 
01313   return bits;
01314 }

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().

00261 {
00262   int bits = 0;
00263 
00264   if ((VidSt->arith_used)) {
00265     bits+=encoder_flush(); /* Need to call before fixed length string output */
00266     (VidSt->arith_used) = 0;
00267   }
00268 
00269   /* Picture Start Code */
00270   if ((VidSt->trace))
00271     fprintf((VidSt->tf),"GOB sync (GBSC): ");
00272   putbits(PSC_LENGTH,PSC); /* PSC */
00273   bits += PSC_LENGTH;
00274 
00275   /* Group Number */
00276   if ((VidSt->trace))
00277     fprintf((VidSt->tf),"GN: ");
00278   putbits(5,slice);
00279   bits += 5;
00280 
00281   /* GOB Sub Bitstream Indicator */
00282   /* if CPM == 1: read 2 bits GSBI */
00283   /* not supported in this version */
00284 
00285   /* GOB Frame ID */
00286   if ((VidSt->trace))
00287     fprintf((VidSt->tf),"GFID: ");
00288   putbits(2, 0);  
00289   /* NB: in error-prone environments this value should change if 
00290      PTYPE in picture header changes. In this version of the encoder
00291      PTYPE only changes when PB-frames are used in the following cases:
00292      (i) after the first intra frame
00293      (ii) if the distance between two P-frames is very large 
00294      Therefore I haven't implemented this GFID change */
00295   /* GFID is not allowed to change unless PTYPE changes */
00296   bits += 2;
00297 
00298   /* Gquant */
00299   if ((VidSt->trace))
00300     fprintf((VidSt->tf),"GQUANT: ");
00301   putbits(5,quant);
00302   bits += 5;
00303 
00304   return bits;
00305 }

void CountBitsVectors MotionVector MV[6][MBR+1][MBC+2],
Bits bits,
int  x,
int  y,
int  Mode,
int  newgob,
Pict pic
 

Definition at line 773 of file vid_countbit.c.

References Bits, FindPMV(), video_codec::long_vectors, pict::MODB, MotionVector, pict::PB, PBMODE_MVDB, Pict, put_mv(), video_codec::tf, video_codec::trace, bits_counted::vec, and VidSt.

00775 {
00776   int y_vec, x_vec;
00777   int pmv0, pmv1;
00778   int start,stop,block;
00779 
00780   x++;y++;
00781 
00782   if (Mode == MODE_INTER4V) {
00783     start = 1; stop = 4;
00784   }
00785   else {
00786     start = 0; stop = 0;
00787   }
00788 
00789   for (block = start; block <= stop;  block++) {
00790 
00791     FindPMV(MV,x,y,&pmv0,&pmv1, block, newgob, 1);
00792 
00793     x_vec = (2*MV[block][y][x]->x + MV[block][y][x]->x_half) - pmv0;
00794     y_vec = (2*MV[block][y][x]->y + MV[block][y][x]->y_half) - pmv1;
00795 
00796     if (!(VidSt->long_vectors)) {
00797       if (x_vec < -32) x_vec += 64;
00798       else if (x_vec > 31) x_vec -= 64;
00799 
00800       if (y_vec < -32) y_vec += 64;
00801       else if (y_vec > 31) y_vec -= 64;
00802     }
00803     else {
00804       if (pmv0 < -31 && x_vec < -63) x_vec += 64;
00805       else if (pmv0 > 32 && x_vec > 63) x_vec -= 64;
00806 
00807       if (pmv1 < -31 && y_vec < -63) y_vec += 64;
00808       else if (pmv1 > 32 && y_vec > 63) y_vec -= 64;
00809     }
00810     
00811     if ((VidSt->trace)) {
00812       fprintf((VidSt->tf),"Vectors:\n");
00813     }
00814 
00815     if (x_vec < 0) x_vec += 64;
00816     if (y_vec < 0) y_vec += 64;
00817 
00818     bits->vec += put_mv (x_vec);
00819     bits->vec += put_mv (y_vec);
00820 
00821     if ((VidSt->trace)) {
00822       if (x_vec > 31) x_vec -= 64;
00823       if (y_vec > 31) y_vec -= 64;
00824       fprintf((VidSt->tf),"(x,y) = (%d,%d) - ",
00825               (2*MV[block][y][x]->x + MV[block][y][x]->x_half),
00826               (2*MV[block][y][x]->y + MV[block][y][x]->y_half));
00827       fprintf((VidSt->tf),"(Px,Py) = (%d,%d)\n", pmv0,pmv1);
00828       fprintf((VidSt->tf),"(x_diff,y_diff) = (%d,%d)\n",x_vec,y_vec);
00829     }
00830   }
00831 
00832   /* PB-frames delta vectors */
00833   if (pic->PB)
00834     if (pic->MODB == PBMODE_MVDB || pic->MODB == PBMODE_CBPB_MVDB) {
00835 
00836       x_vec = MV[5][y][x]->x;
00837       y_vec = MV[5][y][x]->y;
00838 
00839       /* x_vec and y_vec are the PB-delta vectors */
00840     
00841       if (x_vec < 0) x_vec += 64;
00842       if (y_vec < 0) y_vec += 64;
00843 
00844       if ((VidSt->trace)) {
00845         fprintf((VidSt->tf),"PB delta vectors:\n");
00846       }
00847 
00848       bits->vec += put_mv (x_vec);
00849       bits->vec += put_mv (y_vec);
00850 
00851       if ((VidSt->trace)) {
00852         if (x_vec > 31) x_vec -= 64;
00853         if (y_vec > 31) y_vec -= 64;
00854         fprintf((VidSt->tf),"MVDB (x,y) = (%d,%d)\n",x_vec,y_vec);
00855       }
00856     }
00857 
00858 
00859   return;
00860 }

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().

01137 {
01138   if (MV1->x != MV2->x)
01139     return 0;
01140   if (MV1->y != MV2->y)
01141     return 0;
01142   if (MV1->x_half != MV2->x_half)
01143     return 0;
01144   if (MV1->y_half != MV2->y_half)
01145     return 0;
01146   return 1;
01147 }

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().

00744 {
00745   
00746   int i,j;
00747   int CBP = 0;
00748   int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
00749 
00750   /* Set CBP for this Macroblock */
00751   for (i = 0; i < 6; i++) {
00752     for (j = i*ncoeffs + intra; j < (i+1)*ncoeffs; j++) {
00753       if (qcoeff[j]) {
00754         if (i == 0) {CBP |= 32;}
00755         else if (i == 1) {CBP |= 16;}
00756         else if (i == 2) {CBP |= 8;}
00757         else if (i == 3) {CBP |= 4;}
00758         else if (i == 4) {CBP |= 2;}
00759         else if (i == 5) {CBP |= 1;}
00760         else {
00761           fprintf(stderr,"Error in CBP assignment\n");
00762           exit(-1);
00763         }
00764         break;
00765       }
00766     }
00767   }
00768 
00769   return CBP;
00770 }

void FindPMV MotionVector MV[6][MBR+1][MBC+2],
int  x,
int  y,
int *  pmv0,
int *  pmv1,
int  block,
int  newgob,
int  half_pel
 

Definition at line 958 of file vid_countbit.c.

References mmax, mmin, and MotionVector.

00960 {
00961   int p1,p2,p3;
00962   int xin1,xin2,xin3;
00963   int yin1,yin2,yin3;
00964   int vec1,vec2,vec3;
00965   int l8,o8,or8;
00966 
00967 
00968   l8 = o8 = or8 = 0;
00969   if (MV[0][y][x-1]->Mode == MODE_INTER4V)
00970     l8 = 1;
00971   if (MV[0][y-1][x]->Mode == MODE_INTER4V)
00972     o8 = 1;
00973   if (MV[0][y-1][x+1]->Mode == MODE_INTER4V)
00974     or8 = 1;
00975 
00976   switch (block) {
00977   case 0: 
00978     vec1 = (l8 ? 2 : 0) ; yin1 = y  ; xin1 = x-1;
00979     vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
00980     vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
00981     break;
00982   case 1:
00983     vec1 = (l8 ? 2 : 0) ; yin1 = y  ; xin1 = x-1;
00984     vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
00985     vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
00986     break;
00987   case 2:
00988     vec1 = 1            ; yin1 = y  ; xin1 = x;
00989     vec2 = (o8 ? 4 : 0) ; yin2 = y-1; xin2 = x;
00990     vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
00991     break;
00992   case 3:
00993     vec1 = (l8 ? 4 : 0) ; yin1 = y  ; xin1 = x-1;
00994     vec2 = 1            ; yin2 = y  ; xin2 = x;
00995     vec3 = 2            ; yin3 = y  ; xin3 = x;
00996     break;
00997   case 4:
00998     vec1 = 3            ; yin1 = y  ; xin1 = x;
00999     vec2 = 1            ; yin2 = y  ; xin2 = x;
01000     vec3 = 2            ; yin3 = y  ; xin3 = x;
01001     break;
01002   default:
01003     fprintf(stderr,"Illegal block number in FindPMV (vid_countbit.c)\n");
01004     exit(-1);
01005     break;
01006   }
01007   if (half_pel) {
01008     p1 = 2*MV[vec1][yin1][xin1]->x + MV[vec1][yin1][xin1]->x_half;
01009     p2 = 2*MV[vec2][yin2][xin2]->x + MV[vec2][yin2][xin2]->x_half;
01010     p3 = 2*MV[vec3][yin3][xin3]->x + MV[vec3][yin3][xin3]->x_half;
01011   }
01012   else {
01013     p1 = 2*MV[vec1][yin1][xin1]->x;
01014     p2 = 2*MV[vec2][yin2][xin2]->x;
01015     p3 = 2*MV[vec3][yin3][xin3]->x;
01016   }
01017   if (newgob && (block == 0 || block == 1 || block == 2))
01018     p2 = 2*NO_VEC;
01019 
01020   if (p2 == 2*NO_VEC) { p2 = p3 = p1; }
01021 
01022   *pmv0 = p1+p2+p3 - mmax(p1,mmax(p2,p3)) - mmin(p1,mmin(p2,p3));
01023     
01024   if (half_pel) {
01025     p1 = 2*MV[vec1][yin1][xin1]->y + MV[vec1][yin1][xin1]->y_half;
01026     p2 = 2*MV[vec2][yin2][xin2]->y + MV[vec2][yin2][xin2]->y_half;
01027     p3 = 2*MV[vec3][yin3][xin3]->y + MV[vec3][yin3][xin3]->y_half;
01028   }
01029   else {
01030     p1 = 2*MV[vec1][yin1][xin1]->y;
01031     p2 = 2*MV[vec2][yin2][xin2]->y;
01032     p3 = 2*MV[vec3][yin3][xin3]->y;
01033   }    
01034   if (newgob && (block == 0 || block == 1 || block == 2))
01035     p2 = 2*NO_VEC;
01036 
01037   if (p2 == 2*NO_VEC) { p2 = p3 = p1; }
01038 
01039   *pmv1 = p1+p2+p3 - mmax(p1,mmax(p2,p3)) - mmin(p1,mmin(p2,p3));
01040   
01041   return;
01042 }

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().

01119 {
01120   MV->x = NO_VEC;
01121   MV->y = NO_VEC;
01122   MV->x_half = 0;
01123   MV->y_half = 0;
01124   return;
01125 }

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().

01045 {
01046   bits->Y = 0;
01047   bits->C = 0;
01048   bits->vec = 0;
01049   bits->CBPY = 0;
01050   bits->CBPCM = 0;
01051   bits->MODB = 0;
01052   bits->CBPB = 0;
01053   bits->COD = 0;
01054   bits->DQUANT = 0;
01055   bits->header = 0;
01056   bits->total = 0;
01057   bits->no_inter = 0;
01058   bits->no_inter4v = 0;
01059   bits->no_intra = 0;
01060   return;
01061 }

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().

01063 {
01064   res->SNR_l = (float)0;
01065   res->SNR_Cr = (float)0;
01066   res->SNR_Cb = (float)0;
01067   res->QP_mean = (float)0;
01068 }

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().

01111 {
01112   MV->x = 0;
01113   MV->y = 0;
01114   MV->x_half = 0;
01115   MV->y_half = 0;
01116   return;
01117 }


Variable Documentation

video_codec* VidSt
 

Definition at line 16 of file vid_wrapper.c.


Generated on Sun Jul 16 16:27:47 2006 by  doxygen 1.3.9.1