spatscal.c
上传用户:hkgotone
上传日期:2013-02-17
资源大小:293k
文件大小:9k
源码类别:

Windows Mobile

开发平台:

C/C++

  1. #include <stdio.h>
  2. #include "config.h"
  3. #include "global.h"
  4. /* private prototypes */
  5. static void Read_Lower_Layer_Component_Framewise _ANSI_ARGS_((int comp, int lw, int lh));
  6. static void Read_Lower_Layer_Component_Fieldwise _ANSI_ARGS_((int comp, int lw, int lh));
  7. static void Make_Spatial_Prediction_Frame _ANSI_ARGS_((int progressive_frame,
  8.   int llprogressive_frame, unsigned char *fld0, unsigned char *fld1, 
  9.   short *tmp, unsigned char *dst, int llx0, int lly0, int llw, int llh, 
  10.   int horizontal_size, int vertical_size, int vm, int vn, int hm, int hn, 
  11.   int aperture));
  12. static void Deinterlace _ANSI_ARGS_((unsigned char *fld0, unsigned char *fld1,
  13.   int j0, int lx, int ly, int aperture));
  14. static void Subsample_Vertical _ANSI_ARGS_((unsigned char *s, short *d,
  15.   int lx, int lys, int lyd, int m, int n, int j0, int dj));
  16. static void Subsample_Horizontal _ANSI_ARGS_((short *s, unsigned char *d,
  17.   int x0, int lx, int lxs, int lxd, int ly, int m, int n));
  18. /* get reference frame */
  19. void Spatial_Prediction()
  20. {
  21.   
  22.   if(Frame_Store_Flag)
  23.   {
  24.     Read_Lower_Layer_Component_Framewise(0,lower_layer_prediction_horizontal_size, 
  25.       lower_layer_prediction_vertical_size);      /* Y */
  26.     Read_Lower_Layer_Component_Framewise(1,lower_layer_prediction_horizontal_size>>1,
  27.       lower_layer_prediction_vertical_size>>1);   /* Cb ("U") */
  28.     Read_Lower_Layer_Component_Framewise(2,lower_layer_prediction_horizontal_size>>1,
  29.       lower_layer_prediction_vertical_size>>1);   /* Cr ("V") */
  30.   }
  31.   else
  32.   {
  33.     Read_Lower_Layer_Component_Fieldwise(0,lower_layer_prediction_horizontal_size, 
  34.       lower_layer_prediction_vertical_size);      /* Y */
  35.     Read_Lower_Layer_Component_Fieldwise(1,lower_layer_prediction_horizontal_size>>1,
  36.       lower_layer_prediction_vertical_size>>1);   /* Cb ("U") */
  37.     Read_Lower_Layer_Component_Fieldwise(2,lower_layer_prediction_horizontal_size>>1,
  38.       lower_layer_prediction_vertical_size>>1);   /* Cr ("V") */
  39.   }
  40.   Make_Spatial_Prediction_Frame  /* Y */
  41.     (progressive_frame,lower_layer_progressive_frame,llframe0[0],llframe1[0],
  42.      lltmp,current_frame[0],lower_layer_horizontal_offset,
  43.      lower_layer_vertical_offset,
  44.      lower_layer_prediction_horizontal_size,
  45.      lower_layer_prediction_vertical_size,
  46.      horizontal_size,vertical_size,vertical_subsampling_factor_m,
  47.      vertical_subsampling_factor_n,horizontal_subsampling_factor_m,
  48.      horizontal_subsampling_factor_n,
  49.      picture_structure!=FRAME_PICTURE); /* this changed from CD to DIS */
  50.   Make_Spatial_Prediction_Frame  /* Cb */
  51.     (progressive_frame,lower_layer_progressive_frame,llframe0[1],llframe1[1],
  52.      lltmp,current_frame[1],lower_layer_horizontal_offset/2,
  53.      lower_layer_vertical_offset/2,
  54.      lower_layer_prediction_horizontal_size>>1,
  55.      lower_layer_prediction_vertical_size>>1,
  56.      horizontal_size>>1,vertical_size>>1,vertical_subsampling_factor_m,
  57.      vertical_subsampling_factor_n,horizontal_subsampling_factor_m,
  58.      horizontal_subsampling_factor_n,1);
  59.   Make_Spatial_Prediction_Frame  /* Cr */
  60.     (progressive_frame,lower_layer_progressive_frame,llframe0[2],llframe1[2],
  61.      lltmp,current_frame[2],lower_layer_horizontal_offset/2,
  62.      lower_layer_vertical_offset/2,
  63.      lower_layer_prediction_horizontal_size>>1,
  64.      lower_layer_prediction_vertical_size>>1,
  65.      horizontal_size>>1,vertical_size>>1,vertical_subsampling_factor_m,
  66.      vertical_subsampling_factor_n,horizontal_subsampling_factor_m,
  67.      horizontal_subsampling_factor_n,1);
  68. }
  69. static void Read_Lower_Layer_Component_Framewise(comp,lw,lh)
  70.      int comp;
  71.      int lw, lh;
  72. {
  73.   FILE *fd;
  74.   char fname[256];
  75.   char ext[3][3] = {".Y",".U",".V"}; 
  76. /*  char *ext = {".Y",".U",".V"}; */
  77.   int i,j;
  78.   sprintf(fname,Lower_Layer_Picture_Filename,True_Framenum);
  79.   strcat(fname,ext[comp]);
  80. #ifdef VERBOSE
  81.   if (Verbose_Flag>1)
  82.     printf("reading %sn",fname);
  83. #endif VERBOSE
  84.   fd=fopen(fname,"rb");
  85.   if (fd==NULL) exit(-1);
  86.   for (j=0; j<lh; j++) {
  87.      for (i=0; i<lw; i++)
  88.        llframe0[comp][lw*j+i]=getc(fd);
  89.      if (! lower_layer_progressive_frame) {
  90. j++;
  91. for (i=0; i<lw; i++)
  92.   llframe1[comp][lw*j+i]=getc(fd);
  93.      }
  94.   }
  95.   fclose(fd);
  96. }
  97. static void Read_Lower_Layer_Component_Fieldwise(comp,lw,lh)
  98.      int comp;
  99.      int lw, lh;
  100. {
  101.   FILE *fd;
  102.   char fname[256];
  103.   char ext[3][3] = {".Y",".U",".V"}; 
  104. /*  char *ext = {".Y",".U",".V"}; */
  105.   int i,j;
  106.   sprintf(fname,Lower_Layer_Picture_Filename,True_Framenum,lower_layer_progressive_frame ? 'f':'a');
  107.   strcat(fname,ext[comp]);
  108. #ifdef VERBOSE
  109.   if (Verbose_Flag>1)
  110.     printf("reading %sn",fname);
  111. #endif VERBOSE
  112.   fd=fopen(fname,"rb");
  113.   if (fd==NULL) exit(-1);
  114.   for (j=0; j<lh; j+=lower_layer_progressive_frame?1:2)
  115.     for (i=0; i<lw; i++)
  116.       llframe0[comp][lw*j+i]=getc(fd);
  117.   fclose(fd);
  118.   if (! lower_layer_progressive_frame) {
  119.     sprintf(fname,Lower_Layer_Picture_Filename,True_Framenum,'b');
  120.     strcat(fname,ext[comp]);
  121. #ifdef VERBOSE
  122.     if (Verbose_Flag>1)
  123.       printf("reading %sn",fname);
  124. #endif VERBOSE
  125.     fd=fopen(fname,"rb");
  126.     if (fd==NULL) exit(-1);
  127.     for (j=1; j<lh; j+=2)
  128.       for (i=0; i<lw; i++)
  129.         llframe1[comp][lw*j+i]=getc(fd);
  130.     fclose(fd);
  131.   }
  132. }
  133. /* form spatial prediction */
  134. static void Make_Spatial_Prediction_Frame(progressive_frame,
  135.   llprogressive_frame,fld0,fld1,tmp,dst,llx0,lly0,llw,llh,horizontal_size,
  136.   vertical_size,vm,vn,hm,hn,aperture)
  137. int progressive_frame,llprogressive_frame;
  138. unsigned char *fld0,*fld1;
  139. short *tmp;
  140. unsigned char *dst;
  141. int llx0,lly0,llw,llh,horizontal_size,vertical_size,vm,vn,hm,hn,aperture;
  142. {
  143.   int w, h, x0, llw2, llh2;
  144.   llw2 = (llw*hn)/hm;
  145.   llh2 = (llh*vn)/vm;
  146.   if (llprogressive_frame)
  147.   {
  148.     /* progressive -> progressive / interlaced */
  149.     Subsample_Vertical(fld0,tmp,llw,llh,llh2,vm,vn,0,1);
  150.   }
  151.   else if (progressive_frame)
  152.   {
  153.     /* interlaced -> progressive */
  154.     if (lower_layer_deinterlaced_field_select)
  155.     {
  156.       Deinterlace(fld1,fld0,0,llw,llh,aperture);
  157.       Subsample_Vertical(fld1,tmp,llw,llh,llh2,vm,vn,0,1);
  158.     }
  159.     else
  160.     {
  161.       Deinterlace(fld0,fld1,1,llw,llh,aperture);
  162.       Subsample_Vertical(fld0,tmp,llw,llh,llh2,vm,vn,0,1);
  163.     }
  164.   }
  165.   else
  166.   {
  167.     /* interlaced -> interlaced */
  168.     Deinterlace(fld0,fld1,1,llw,llh,aperture);
  169.     Deinterlace(fld1,fld0,0,llw,llh,aperture);
  170.     Subsample_Vertical(fld0,tmp,llw,llh,llh2,vm,vn,0,2);
  171.     Subsample_Vertical(fld1,tmp,llw,llh,llh2,vm,vn,1,2);
  172.   }
  173.     /* vertical limits */
  174.     if (lly0<0)
  175.     {
  176.       tmp-= llw*lly0;
  177.       llh2+= lly0;
  178.       if (llh2<0)
  179.         llh2 = 0;
  180.       h = (vertical_size<llh2) ? vertical_size : llh2;
  181.     }
  182.     else
  183.     {
  184.       dst+= horizontal_size*lly0;
  185.       h= vertical_size - lly0;
  186.       if (h>llh2)
  187.         h = llh2;
  188.     }
  189.     /* horizontal limits */
  190.     if (llx0<0)
  191.     {
  192.       x0 = -llx0;
  193.       llw2+= llx0;
  194.       if (llw2<0)
  195.         llw2 = 0;
  196.       w = (horizontal_size<llw2) ? horizontal_size : llw2;
  197.     }
  198.     else
  199.     {
  200.       dst+= llx0;
  201.       x0 = 0;
  202.       w = horizontal_size - llx0;
  203.       if (w>llw2)
  204.         w = llw2;
  205.     }
  206.   
  207.   Subsample_Horizontal(tmp,dst,x0,w,llw,horizontal_size,h,hm,hn);
  208. }
  209. /* deinterlace one field (interpolate opposite parity samples)
  210.  *
  211.  * deinterlacing is done in-place: if j0=1, fld0 contains the input field in
  212.  * its even lines and the odd lines are interpolated by this routine
  213.  * if j0=0, the input field is in the odd lines and the even lines are
  214.  * interpolated
  215.  *
  216.  * fld0: field to be deinterlaced
  217.  * fld1: other field (referenced by the two field aperture filter)
  218.  * j0:   0: interpolate even (top) lines, 1: interpolate odd (bottom) lines
  219.  * lx:   width of fld0 and fld1
  220.  * ly:   height of the deinterlaced field (has to be even)
  221.  * aperture: 1: use one field aperture filter (two field otherwise)
  222.  */
  223. static void Deinterlace(fld0,fld1,j0,lx,ly,aperture)
  224. unsigned char *fld0,*fld1;
  225. int j0,lx,ly; /* ly has to be even */
  226. int aperture;
  227. {
  228.   int i,j,v;
  229.   unsigned char *p0, *p0m1, *p0p1, *p1, *p1m2, *p1p2;
  230.   /* deinterlace one field */
  231.   for (j=j0; j<ly; j+=2)
  232.   {
  233.     p0 = fld0+lx*j;
  234.     p0m1 = (j==0)    ? p0+lx : p0-lx;
  235.     p0p1 = (j==ly-1) ? p0-lx : p0+lx;
  236.     if (aperture)
  237.       for (i=0; i<lx; i++)
  238.         p0[i] = (unsigned int)(p0m1[i] + p0p1[i] + 1)>>1;
  239.     else
  240.     {
  241.       p1 = fld1 + lx*j;
  242.       p1m2 = (j<2)     ? p1 : p1-2*lx;
  243.       p1p2 = (j>=ly-2) ? p1 : p1+2*lx;
  244.       for (i=0; i<lx; i++)
  245.       {
  246.         v = 8*(p0m1[i]+p0p1[i]) + 2*p1[i] - p1m2[i] - p1p2[i];
  247.         p0[i] = Clip[(v + ((v>=0) ? 8 : 7))>>4];
  248.       }
  249.     }
  250.   }
  251. }
  252. /* vertical resampling */
  253. static void Subsample_Vertical(s,d,lx,lys,lyd,m,n,j0,dj)
  254. unsigned char *s;
  255. short *d;
  256. int lx, lys, lyd, m, n, j0, dj;
  257. {
  258.   int i, j, c1, c2, jd;
  259.   unsigned char *s1, *s2;
  260.   short *d1;
  261.   for (j=j0; j<lyd; j+=dj)
  262.   {
  263.     d1 = d + lx*j;
  264.     jd = (j*m)/n;
  265.     s1 = s + lx*jd;
  266.     s2 = (jd<lys-1)? s1+lx : s1;
  267.     c2 = (16*((j*m)%n) + (n>>1))/n;
  268.     c1 = 16 - c2;
  269.     for (i=0; i<lx; i++)
  270.       d1[i] = c1*s1[i] + c2*s2[i];
  271.   }
  272. }
  273. /* horizontal resampling */
  274. static void Subsample_Horizontal(s,d,x0,lx,lxs,lxd,ly,m,n)
  275. short *s;
  276. unsigned char *d;
  277. int x0, lx, lxs, lxd, ly, m, n;
  278. {
  279.   int i, i1, j, id, c1, c2, v;
  280.   short *s1, *s2;
  281.   unsigned char *d1;
  282.   for (i1=0; i1<lx; i1++)
  283.   {
  284.     d1 = d + i1;
  285.     i = x0 + i1;
  286.     id = (i*m)/n;
  287.     s1 = s+id;
  288.     s2 = (id<lxs-1) ? s1+1 : s1;
  289.     c2 = (16*((i*m)%n) + (n>>1))/n;
  290.     c1 = 16 - c2;
  291.     for (j=0; j<ly; j++)
  292.     {
  293.       v = c1*(*s1) + c2*(*s2);
  294.       *d1 = (v + ((v>=0) ? 128 : 127))>>8;
  295.       d1+= lxd;
  296.       s1+= lxs;
  297.       s2+= lxs;
  298.     }
  299.   }
  300. }