recon.c

DirectFB-1.0.1可用于linux的嵌入式GUI

          else { /* TOP_FIELD or BOTTOM_FIELD */
               /* field picture */
               if (motion_type==MC_FIELD) {
                    /* field-based prediction */
                    form_prediction(dec, dec->backward_reference_frame,motion_vertical_field_select[0][1],
                                    dec->current_frame,0,dec->Coded_Picture_Width<<1,dec->Coded_Picture_Width<<1,16,16,
                                    bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
               }
               else if (motion_type==MC_16X8) {
                    form_prediction(dec, dec->backward_reference_frame,motion_vertical_field_select[0][1],
                                    dec->current_frame,0,dec->Coded_Picture_Width<<1,dec->Coded_Picture_Width<<1,16,8,
                                    bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);

                    form_prediction(dec, dec->backward_reference_frame,motion_vertical_field_select[1][1],
                                    dec->current_frame,0,dec->Coded_Picture_Width<<1,dec->Coded_Picture_Width<<1,16,8,
                                    bx,by+8,PMV[1][1][0],PMV[1][1][1],stwtop);
               }
               else
                    /* invalid motion_type */
                    printf("invalid motion_type\n");
          }
     }
}

static void
form_prediction(MPEG2_Decoder *dec,
                unsigned char *src[], /* prediction source buffer */
                int sfield,           /* prediction source field number (0 or 1) */
                unsigned char *dst[], /* prediction destination buffer */
                int dfield,           /* prediction destination field number (0 or 1)*/
                int lx,int lx2,       /* line strides */
                int w,int h,          /* prediction block/sub-block width, height */
                int x,int y,          /* pixel co-ordinates of top-left sample in current MB */
                int dx, int dy,       /* horizontal, vertical prediction address */
                int average_flag)     /* add prediction error to prediction ? */
{
     /* Y */
     form_component_prediction(dec, src[0]+(sfield?lx2>>1:0),dst[0]+(dfield?lx2>>1:0),
                               lx,lx2,w,h,x,y,dx,dy,average_flag);

     if (dec->chroma_format!=CHROMA444) {
          lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
     }

     if (dec->chroma_format==CHROMA420) {
          h>>=1; y>>=1; dy/=2;
     }

     /* Cb */
     form_component_prediction(dec, src[1]+(sfield?lx2>>1:0),dst[1]+(dfield?lx2>>1:0),
                               lx,lx2,w,h,x,y,dx,dy,average_flag);

     /* Cr */
     form_component_prediction(dec, src[2]+(sfield?lx2>>1:0),dst[2]+(dfield?lx2>>1:0),
                               lx,lx2,w,h,x,y,dx,dy,average_flag);
}

/* ISO/IEC 13818-2 section 7.6.4: Forming predictions */
/* NOTE: the arithmetic below produces numerically equivalent results
 *  to 7.6.4, yet is more elegant. It differs in the following ways:
 *
 *   1. the vectors (dx, dy) are based on cartesian frame 
 *      coordiantes along a half-pel grid (always positive numbers)
 *      In contrast, vector[r][s][t] are differential (with positive and 
 *      negative values). As a result, deriving the integer vectors 
 *      (int_vec[t]) from dx, dy is accomplished by a simple right shift.
 *
 *   2. Half pel flags (xh, yh) are equivalent to the LSB (Least
 *      Significant Bit) of the half-pel coordinates (dx,dy).
 * 
 *
 *  NOTE: the work of combining predictions (ISO/IEC 13818-2 section 7.6.7)
 *  is distributed among several other stages.  This is accomplished by 
 *  folding line offsets into the source and destination (src,dst)
 *  addresses (note the call arguments to form_prediction(dec, ) in Predict()),
 *  line stride variables lx and lx2, the block dimension variables (w,h), 
 *  average_flag, and by the very order in which Predict() is called.  
 *  This implementation design (implicitly different than the spec) 
 *  was chosen for its elegance.
*/

static void
form_component_prediction(MPEG2_Decoder *dec,
                          unsigned char *src,
                          unsigned char *dst,
                          int lx,          /* raster line increment */ 
                          int lx2,
                          int w,int h,
                          int x,int y,
                          int dx, int dy,
                          int average_flag)      /* flag that signals bi-directional or Dual-Prime 
                                                    averaging (7.6.7.1 and 7.6.7.4). if average_flag==1,
                                                    a previously formed prediction has been stored in 
                                                    pel_pred[] */
{
     int xint;      /* horizontal integer sample vector: analogous to int_vec[0] */
     int yint;      /* vertical integer sample vectors: analogous to int_vec[1] */
     int xh;        /* horizontal half sample flag: analogous to half_flag[0]  */
     int yh;        /* vertical half sample flag: analogous to half_flag[1]  */
     int i, j, v;
     unsigned char *s;    /* source pointer: analogous to pel_ref[][]   */
     unsigned char *d;    /* destination pointer:  analogous to pel_pred[][]  */

     /* half pel scaling for integer vectors */
     xint = dx>>1;
     yint = dy>>1;

     /* derive half pel flags */
     xh = dx & 1;
     yh = dy & 1;

     /* compute the linear address of pel_ref[][] and pel_pred[][] 
        based on cartesian/raster cordinates provided */
     s = src + lx*(y+yint) + x + xint;
     d = dst + lx*y + x;

     if (!xh && !yh) { /* no horizontal nor vertical half-pel */
          if (average_flag) {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         v = d[i]+s[i];
                         d[i] = (v+(v>=0?1:0))>>1;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
          else {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         d[i] = s[i];
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
     }
     else if (!xh && yh) { /* no horizontal but vertical half-pel */
          if (average_flag) {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         v = d[i] + ((unsigned int)(s[i]+s[i+lx]+1)>>1);
                         d[i]=(v+(v>=0?1:0))>>1;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
          else {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         d[i] = (unsigned int)(s[i]+s[i+lx]+1)>>1;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
     }
     else if (xh && !yh) { /* horizontal but no vertical half-pel */
          if (average_flag) {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         v = d[i] + ((unsigned int)(s[i]+s[i+1]+1)>>1);
                         d[i] = (v+(v>=0?1:0))>>1;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
          else {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         d[i] = (unsigned int)(s[i]+s[i+1]+1)>>1;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
     }
     else { /* if (xh && yh) horizontal and vertical half-pel */
          if (average_flag) {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         v = d[i] + ((unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2);
                         d[i] = (v+(v>=0?1:0))>>1;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
          else {
               for (j=0; j<h; j++) {
                    for (i=0; i<w; i++) {
                         d[i] = (unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
                    }

                    s+= lx2;
                    d+= lx2;
               }
          }
     }
}