| /* Predict.c, motion compensation routines */ |
| |
| /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */ |
| |
| /* |
| * Disclaimer of Warranty |
| * |
| * These software programs are available to the user without any license fee or |
| * royalty on an "as is" basis. The MPEG Software Simulation Group disclaims |
| * any and all warranties, whether express, implied, or statuary, including any |
| * implied warranties or merchantability or of fitness for a particular |
| * purpose. In no event shall the copyright-holder be liable for any |
| * incidental, punitive, or consequential damages of any kind whatsoever |
| * arising from the use of these programs. |
| * |
| * This disclaimer of warranty extends to the user of these programs and user's |
| * customers, employees, agents, transferees, successors, and assigns. |
| * |
| * The MPEG Software Simulation Group does not represent or warrant that the |
| * programs furnished hereunder are free of infringement of any third-party |
| * patents. |
| * |
| * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware, |
| * are subject to royalty fees to patent holders. Many of these patents are |
| * general enough such that they are unavoidable regardless of implementation |
| * design. |
| * |
| */ |
| |
| #include <stdio.h> |
| |
| #include "config.h" |
| #include "global.h" |
| |
| /* private prototypes */ |
| static void form_prediction _ANSI_ARGS_((unsigned char *src[], int sfield, |
| unsigned char *dst[], int dfield, |
| int lx, int lx2, int w, int h, int x, int y, int dx, int dy, |
| int average_flag)); |
| |
| static void form_component_prediction _ANSI_ARGS_((unsigned char *src, unsigned char *dst, |
| int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag)); |
| |
| void form_predictions(bx,by,macroblock_type,motion_type,PMV,motion_vertical_field_select,dmvector,stwtype) |
| int bx, by; |
| int macroblock_type; |
| int motion_type; |
| int PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2]; |
| int stwtype; |
| { |
| int currentfield; |
| unsigned char **predframe; |
| int DMV[2][2]; |
| int stwtop, stwbot; |
| |
| stwtop = stwtype%3; /* 0:temporal, 1:(spat+temp)/2, 2:spatial */ |
| stwbot = stwtype/3; |
| |
| if ((macroblock_type & MACROBLOCK_MOTION_FORWARD) |
| || (picture_coding_type==P_TYPE)) |
| { |
| if (picture_structure==FRAME_PICTURE) |
| { |
| if ((motion_type==MC_FRAME) |
| || !(macroblock_type & MACROBLOCK_MOTION_FORWARD)) |
| { |
| /* frame-based prediction (broken into top and bottom halves |
| for spatial scalability prediction purposes) */ |
| if (stwtop<2) |
| form_prediction(forward_reference_frame,0,current_frame,0, |
| Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by, |
| PMV[0][0][0],PMV[0][0][1],stwtop); |
| |
| if (stwbot<2) |
| form_prediction(forward_reference_frame,1,current_frame,1, |
| Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by, |
| PMV[0][0][0],PMV[0][0][1],stwbot); |
| } |
| else if (motion_type==MC_FIELD) /* field-based prediction */ |
| { |
| /* top field prediction */ |
| if (stwtop<2) |
| form_prediction(forward_reference_frame,motion_vertical_field_select[0][0], |
| current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8, |
| bx,by>>1,PMV[0][0][0],PMV[0][0][1]>>1,stwtop); |
| |
| /* bottom field prediction */ |
| if (stwbot<2) |
| form_prediction(forward_reference_frame,motion_vertical_field_select[1][0], |
| current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8, |
| bx,by>>1,PMV[1][0][0],PMV[1][0][1]>>1,stwbot); |
| } |
| else if (motion_type==MC_DMV) /* dual prime prediction */ |
| { |
| /* calculate derived motion vectors */ |
| Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]>>1); |
| |
| if (stwtop<2) |
| { |
| /* predict top field from top field */ |
| form_prediction(forward_reference_frame,0,current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1, |
| PMV[0][0][0],PMV[0][0][1]>>1,0); |
| |
| /* predict and add to top field from bottom field */ |
| form_prediction(forward_reference_frame,1,current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1, |
| DMV[0][0],DMV[0][1],1); |
| } |
| |
| if (stwbot<2) |
| { |
| /* predict bottom field from bottom field */ |
| form_prediction(forward_reference_frame,1,current_frame,1, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1, |
| PMV[0][0][0],PMV[0][0][1]>>1,0); |
| |
| /* predict and add to bottom field from top field */ |
| form_prediction(forward_reference_frame,0,current_frame,1, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1, |
| DMV[1][0],DMV[1][1],1); |
| } |
| } |
| else |
| /* invalid motion_type */ |
| printf("invalid motion_type\n"); |
| } |
| else /* TOP_FIELD or BOTTOM_FIELD */ |
| { |
| /* field picture */ |
| currentfield = (picture_structure==BOTTOM_FIELD); |
| |
| /* determine which frame to use for prediction */ |
| if ((picture_coding_type==P_TYPE) && Second_Field |
| && (currentfield!=motion_vertical_field_select[0][0])) |
| predframe = backward_reference_frame; /* same frame */ |
| else |
| predframe = forward_reference_frame; /* previous frame */ |
| |
| if ((motion_type==MC_FIELD) |
| || !(macroblock_type & MACROBLOCK_MOTION_FORWARD)) |
| { |
| /* field-based prediction */ |
| if (stwtop<2) |
| form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by, |
| PMV[0][0][0],PMV[0][0][1],stwtop); |
| } |
| else if (motion_type==MC_16X8) |
| { |
| if (stwtop<2) |
| { |
| form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by, |
| PMV[0][0][0],PMV[0][0][1],stwtop); |
| |
| /* determine which frame to use for lower half prediction */ |
| if ((picture_coding_type==P_TYPE) && Second_Field |
| && (currentfield!=motion_vertical_field_select[1][0])) |
| predframe = backward_reference_frame; /* same frame */ |
| else |
| predframe = forward_reference_frame; /* previous frame */ |
| |
| form_prediction(predframe,motion_vertical_field_select[1][0],current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by+8, |
| PMV[1][0][0],PMV[1][0][1],stwtop); |
| } |
| } |
| else if (motion_type==MC_DMV) /* dual prime prediction */ |
| { |
| if (Second_Field) |
| predframe = backward_reference_frame; /* same frame */ |
| else |
| predframe = forward_reference_frame; /* previous frame */ |
| |
| /* calculate derived motion vectors */ |
| Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]); |
| |
| /* predict from field of same parity */ |
| form_prediction(forward_reference_frame,currentfield,current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by, |
| PMV[0][0][0],PMV[0][0][1],0); |
| |
| /* predict from field of opposite parity */ |
| form_prediction(predframe,!currentfield,current_frame,0, |
| Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by, |
| DMV[0][0],DMV[0][1],1); |
| } |
| else |
| /* invalid motion_type */ |
| printf("invalid motion_type\n"); |
| } |
| stwtop = stwbot = 1; |
| } |
| |
| if (macroblock_type & MACROBLOCK_MOTION_BACKWARD) |
| { |
| if (picture_structure==FRAME_PICTURE) |
| { |
| if (motion_type==MC_FRAME) |
| { |
| /* frame-based prediction */ |
| if (stwtop<2) |
| form_prediction(backward_reference_frame,0,current_frame,0, |
| Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by, |
| PMV[0][1][0],PMV[0][1][1],stwtop); |
| |
| if (stwbot<2) |
| form_prediction(backward_reference_frame,1,current_frame,1, |
| Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by, |
| PMV[0][1][0],PMV[0][1][1],stwbot); |
| } |
| else /* field-based prediction */ |
| { |
| /* top field prediction */ |
| if (stwtop<2) |
| form_prediction(backward_reference_frame,motion_vertical_field_select[0][1], |
| current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8, |
| bx,by>>1,PMV[0][1][0],PMV[0][1][1]>>1,stwtop); |
| |
| /* bottom field prediction */ |
| if (stwbot<2) |
| form_prediction(backward_reference_frame,motion_vertical_field_select[1][1], |
| current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8, |
| bx,by>>1,PMV[1][1][0],PMV[1][1][1]>>1,stwbot); |
| } |
| } |
| else /* TOP_FIELD or BOTTOM_FIELD */ |
| { |
| /* field picture */ |
| if (motion_type==MC_FIELD) |
| { |
| /* field-based prediction */ |
| form_prediction(backward_reference_frame,motion_vertical_field_select[0][1], |
| current_frame,0,Coded_Picture_Width<<1,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(backward_reference_frame,motion_vertical_field_select[0][1], |
| current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8, |
| bx,by,PMV[0][1][0],PMV[0][1][1],stwtop); |
| |
| form_prediction(backward_reference_frame,motion_vertical_field_select[1][1], |
| current_frame,0,Coded_Picture_Width<<1,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(src,sfield,dst,dfield,lx,lx2,w,h,x,y,dx,dy,average_flag) |
| 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,lx2; /* line strides */ |
| int w,h; /* prediction block/sub-block width, height */ |
| int x,y; /* pixel co-ordinates of top-left sample in current MB */ |
| int dx,dy; /* horizontal, vertical prediction address */ |
| int average_flag; /* add prediction error to prediction ? */ |
| { |
| /* Y */ |
| form_component_prediction(src[0]+(sfield?lx2>>1:0),dst[0]+(dfield?lx2>>1:0), |
| lx,lx2,w,h,x,y,dx,dy,average_flag); |
| |
| if (chroma_format!=CHROMA444) |
| { |
| lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2; |
| } |
| |
| if (chroma_format==CHROMA420) |
| { |
| h>>=1; y>>=1; dy/=2; |
| } |
| |
| /* Cb */ |
| form_component_prediction(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(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() 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(src,dst,lx,lx2,w,h,x,y,dx,dy,average_flag) |
| unsigned char *src; |
| unsigned char *dst; |
| int lx; /* raster line increment */ |
| int lx2; |
| int w,h; |
| int x,y; |
| int dx,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; |
| } |
| } |
| } |
| } |
