search.c

运动估计

       	if(bound_chk(m,n,x,y)){
         err0=mean_abs_err(cur,prev,x,y,m,n,BLOCK_WIDTH,BLOCK_HEIGHT);
  	 searchedpt[MAX_DISP+m-ox][MAX_DISP+n-oy]=1;
 
         if(err0<(*err)){
            *err=err0;
            tmv=sdia[i];
            k = i;
         }
        }
     }
        
     mv.x=mv.x+tmv.x;
      mv.y=mv.y+tmv.y;
     spt += count_searchedpt();
     return mv;
     
}


MV cir_search(u_char *prev, u_char *cur, int x, int y, int rx, int ry, int *err, int b, int t, int l)
{
   int i,j,k,m,n,o,terr;
   MV mv;
   i=cirmv[b][0]*l;
   j=cirmv[b][1]*l;
   mv.x=0;
   mv.y=0;
   k=b;
   for(o=0;o<t;o++){
      m=x+i;
      n=y+j;
      if(bound_chk(m,n,rx,ry)){
         terr=mean_abs_err(cur,prev,rx,ry,m,n,BLOCK_WIDTH,BLOCK_HEIGHT);
         /* terr=half_stop_mean_abs_err(cur,prev,rx,ry,m,n,BLOCK_WIDTH,BLOCK_HEIGHT,*err); */
         /*terr=npd_mean_abs_err(cur,prev,rx,ry,m,n,BLOCK_WIDTH,BLOCK_HEIGHT,*err);*/
#ifdef OPC
         op.c+=1;
#endif
         if(terr<(*err)){
            *err=terr;
             mv.x=i;
             mv.y=j;
         }
      }
      if(k<2)      i+=l;
      else if(k<4) j+=l;
      else if(k<6) i-=l;
      else         j-=l;
      k=(k+1)%8;
   } 
   return mv;
}

MV coher_search(u_char *prev, u_char *cur, int x, int y, int *err)
{
   int m,n,ix,iy,pmad,smad;
   MV pmv,tmv,mv1,mv2,mv3;
   ix=x/BLOCK_WIDTH;
   iy=y/BLOCK_HEIGHT;
   if(ix>0)
      mv1=imv[iy][ix-1];
   else
      mv1.x=mv1.y=0;
   if(iy==0)
      mv2=mv3=mv1;
   else{
      mv2=imv[iy-1][ix];
      if(ix==(re_width/BLOCK_WIDTH-1))
         mv3.x=mv3.y=0;
      else
         mv3=imv[iy-1][ix+1];
   }
   pmv.x=med(mv1.x,mv2.x,mv3.x);
   pmv.y=med(mv1.y,mv2.y,mv3.y);
   m=x+pmv.x;
   n=y+pmv.y;
   pmad=mean_abs_err(cur,prev,x,y,m,n,BLOCK_WIDTH,BLOCK_HEIGHT);
   smad=MAX_INT;
   tmv=four_step_search(prev,cur,x,y,&smad);
   if((pmad-smad)<100){
      *err=pmad;
      return pmv;
   }
   *err=smad;
   return tmv;
}

void set_param(char *name) //需要改写
{
   if(FIELD){
      if(!strcmp(name,"tt")){
         im_width=720;im_height=486;
      }else if(!strcmp(name,"football")){
         im_width=720;im_height=486;
      }else if(!strcmp(name,"fg")){
         im_width=720;im_height=486;
      }
   }
   else if(CIF){
      if(!strcmp(name,"tennis")){
         im_width=360;im_height=240;
      }else if(!strcmp(name,"football")){
         im_width=360;im_height=240;
      }else if(!strcmp(name,"saleman")){
         im_width=360;im_height=288;
      }else if(!strcmp(name,"missa")){
         im_width=256;im_height=256;
      }else if(!strcmp(name,"garden")){
         im_width=352;im_height=240;
      }else if(!strcmp(name,"claire")){
         im_width=310;im_height=280;
      }
   }
   else{
      if(!strcmp(name,"tennis")){
         im_width=720;im_height=486;
      }else if(!strcmp(name,"football")){
         im_width=720;im_height=486;
      }else if(!strcmp(name,"garden")){
         im_width=720;im_height=486;
      }
   }
   re_width=im_width-(im_width%BLOCK_WIDTH);
   re_height=im_height-(im_height%BLOCK_HEIGHT);
   if(FIELD){
      im_width2=2*im_width;
      im_height2=im_height/2;
      re_width2=re_width*2;
      re_height2=re_height/2;
   }else{
      im_width2=im_width;
      im_height2=im_height;
      re_width2=re_width;
      re_height2=re_height;
   }
   mv_width=im_width/BLOCK_WIDTH;
   mv_height=im_height2/BLOCK_HEIGHT;
}

void compute_bound(int x, int y, int *ux, int *lx, int *uy, int *ly)
{
   *lx=max(0,x-MAX_DISP);
   *ux=min(im_width-BLOCK_WIDTH,x+MAX_DISP);
   *ly=max(0,y-MAX_DISP);
   *uy=min(im_height2-BLOCK_HEIGHT,y+MAX_DISP);
}

int bound_chk(int m, int n, int cx, int cy)
{
   int ilow,ihigh,jlow,jhigh;
   compute_bound(cx,cy,&ihigh,&ilow,&jhigh,&jlow);
   return(m<=ihigh&&m>=ilow&&n<=jhigh&&n>=jlow);
}

void search(int method, MV **mv, u_char *prev, u_char *cur)
{
   int i,j,err,c=0,s,e,a;
   if(HALF){
      end=clock();
      interpolate_frame(iprev,prev,im_width2,im_height2);
      over+=clock()-end;
   }
   for(j=0;j<mv_height;j++){
      if(method==7){
         if(j%2==0){
            s=0;e=mv_width-1;a=1;
         }else{
            s=mv_width-1;e=0;a=-1;
         }
      }
      else{
         s=0;e=mv_width-1;a=1;
      }
      for(i=s;i*a<=e*a;i+=a){
         err=MAX_INT;
         spt=0;
         nets=clock();
         switch(method){
            case 1:
               mv[j][i]=full_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 2:
               mv[j][i]=new_full_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 3:
               mv[j][i]=three_step_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 4:
               mv[j][i]=four_step_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 5:
               mv[j][i]=new_three_step_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 6:
               mv[j][i]=bbgd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 7:
               mv[j][i]=hsa_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 8:
               mv[j][i]=coher_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 9:
               mv[j][i]=part_full_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 10:
               mv[j][i]=liu_full_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 11:
               mv[j][i]=ucbd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 12:
               mv[j][i]=cd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 13:
               mv[j][i]=scd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 14:
               mv[j][i]=ncd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
            case 15:
               mv[j][i]=kcd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err);
               break;
         }
         net+=clock()-nets;
         point[c++]=spt;
         if(HALF){
            hmv[j][i]=find_halfpel(i*BLOCK_WIDTH,j*BLOCK_HEIGHT,mv[j][i],iprev,cur,BLOCK_WIDTH,&err);
         }
      }
   }
}

void fsearch(int method, MVF **mvt, MVF **mvb, u_char *prev, u_char *cur)
{
   int i,j,err1,err2;
   MVF t,b;
   t.f=ODD;
   b.f=EVEN;
   for(i=0;i<mv_width;i++)
      for(j=0;j<mv_height;j++){
         err1=err2=MAX_INT;
         switch(method){
            case 1:
               t.mv=full_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=full_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT, &err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=full_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=full_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
            case 2:
               t.mv=new_full_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=new_full_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=new_full_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=new_full_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
            case 3:
               t.mv=three_step_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=three_step_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=three_step_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=three_step_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
            case 4:
               t.mv=four_step_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=four_step_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=four_step_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=four_step_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
            case 5:
               t.mv=new_three_step_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=new_three_step_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=new_three_step_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=new_three_step_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
            case 6:
               t.mv=bbgd_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=bbgd_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=bbgd_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=bbgd_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
            case 7:
               t.mv=hsa_search(prev,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=hsa_search(prev+im_width,cur,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvt[j][i]=(err2<err1)?b:t;
               t.mv=hsa_search(prev,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err1);
               b.mv=hsa_search(prev+im_width,cur+im_width,i*BLOCK_WIDTH,j*BLOCK_HEIGHT,&err2);
               mvb[j][i]=(err2<err1)?b:t;
               break;
         }
      }
}

MV find_halfpel(int x, int y, MV mv, u_char *prev, u_char *cur, int bs, int *err)
{
 int i, m, n;
 int half_pel,mae;
 int start_x,start_y,stop_x,stop_y,new_x,new_y;
 MV search[9],hmv;
 /*static int l[16]={0,3,3,0,1,2,2,1,1,2,3,0,2,1,3,0};
 static int k[16]={0,3,0,3,1,2,1,2,0,3,1,2,0,3,2,1};
 int z;*/
 start_x=start_y=-1;
 stop_x=stop_y=1;
 new_x=x+mv.x;
 new_y=y+mv.y;
 if ((new_x) <= 0)
    start_x = 0;
 if ((new_y) <= 0)
    start_y = 0;
 if ((new_x) >= (im_width2-bs))
    stop_x = 0;
 if ((new_y) >= (im_height2-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;
 hmv=search[0];
 spt+=8;
 for(i=1;i<9;i++){
    mae=0;
#ifdef OPC
    op.p--;
#endif
    for(n=0;n<bs;n++)
       for(m=0;m<bs;m++){
          half_pel=*(prev+(new_x+m)*2+search[i].x+((new_y+n)*2+search[i].y)\
                   *im_width2*2);
          mae+=abs(half_pel-*(cur+x+m+(y+n)*im_width2));
       }
#ifdef OPC
    op.p+=512;
    op.a+=256;
    op.c++;
#endif
    if(mae<(*err)){
       hmv=search[i];
       *err=mae;
    }
 }
/* Start of PFS halfpel */
 /*for(i=1;i<9;i++){
    mae=0;
#ifdef OPC
    op.p--;
#endif
    for(z=0;z<16;z++){
     for(n=k[z];n<bs;n+=4)
       for(m=l[z];m<bs;m+=4){
          half_pel=*(prev+(new_x+m)*2+search[i].x+((new_y+n)*2+search[i].y)\
                   *im_width2*2);
          mae+=abs(half_pel-*(cur+m+n*im_width2));
       }
#ifdef OPC
     op.p+=32;
     op.a+=16;
     op.c++;
#endif
     if(((mae<<4)/(z+1))>(*err)){
       mae=MAX_INT;
       break;
     }
    }
#ifdef OPC
    op.c++;
#endif
    if(mae<(*err)){
       hmv=search[i];
       *err=mae;
    }
 }*/
/* End of PFS halfpel */
 return hmv;
}

void v_init(void)
{
   res=block_alloc(mv_width*BLOCK_WIDTH,mv_height*(BLOCK_HEIGHT<<FIELD));
   prev=block_alloc(im_width2,im_height2);
   cur=block_alloc(im_width2,im_height2);
   point=(int*)malloc(mv_width*mv_height*sizeof(int));
   if(FIELD){
      mvt=mvf_alloc(mv_width,mv_height);
      mvb=mvf_alloc(mv_width,mv_height);
   }else
      imv=mv_alloc(mv_width,mv_height);
   if(HALF){
      iprev=block_alloc(im_width2*2,im_height2*2);
      hmv=mv_alloc(mv_width,mv_height);
   }
/* new_full_search's stuff */
   b1=me_alloc(1,N1);
   b10=b1[0];
   b2=(ME **)malloc(N1*sizeof(ME *));
}


void v_end(void)
{
   free(res);
   free(prev);
   free(cur);
   free(point);
   if(FIELD){
      block_free((void**)mvt);
      block_free((void**)mvb);
   }else
      block_free((void**)imv);
   if(HALF){
      free(iprev);
      block_free((void**)hmv);
   }
/* new_full_search's variable */
   b1[0]=b10;
   block_free((void**)b1);
   free(b2);
}