| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "config.h" |
| #include "global.h" |
| |
| /* private prototypes */ |
| static void Read_Lower_Layer_Component_Framewise _ANSI_ARGS_((int comp, int lw, int lh)); |
| static void Read_Lower_Layer_Component_Fieldwise _ANSI_ARGS_((int comp, int lw, int lh)); |
| static void Make_Spatial_Prediction_Frame _ANSI_ARGS_((int progressive_frame, |
| int llprogressive_frame, unsigned char *fld0, unsigned char *fld1, |
| short *tmp, unsigned char *dst, int llx0, int lly0, int llw, int llh, |
| int horizontal_size, int vertical_size, int vm, int vn, int hm, int hn, |
| int aperture)); |
| static void Deinterlace _ANSI_ARGS_((unsigned char *fld0, unsigned char *fld1, |
| int j0, int lx, int ly, int aperture)); |
| static void Subsample_Vertical _ANSI_ARGS_((unsigned char *s, short *d, |
| int lx, int lys, int lyd, int m, int n, int j0, int dj)); |
| static void Subsample_Horizontal _ANSI_ARGS_((short *s, unsigned char *d, |
| int x0, int lx, int lxs, int lxd, int ly, int m, int n)); |
| |
| |
| |
| /* get reference frame */ |
| void Spatial_Prediction() |
| { |
| |
| if(Frame_Store_Flag) |
| { |
| Read_Lower_Layer_Component_Framewise(0,lower_layer_prediction_horizontal_size, |
| lower_layer_prediction_vertical_size); /* Y */ |
| Read_Lower_Layer_Component_Framewise(1,lower_layer_prediction_horizontal_size>>1, |
| lower_layer_prediction_vertical_size>>1); /* Cb ("U") */ |
| Read_Lower_Layer_Component_Framewise(2,lower_layer_prediction_horizontal_size>>1, |
| lower_layer_prediction_vertical_size>>1); /* Cr ("V") */ |
| } |
| else |
| { |
| Read_Lower_Layer_Component_Fieldwise(0,lower_layer_prediction_horizontal_size, |
| lower_layer_prediction_vertical_size); /* Y */ |
| Read_Lower_Layer_Component_Fieldwise(1,lower_layer_prediction_horizontal_size>>1, |
| lower_layer_prediction_vertical_size>>1); /* Cb ("U") */ |
| Read_Lower_Layer_Component_Fieldwise(2,lower_layer_prediction_horizontal_size>>1, |
| lower_layer_prediction_vertical_size>>1); /* Cr ("V") */ |
| } |
| |
| |
| Make_Spatial_Prediction_Frame /* Y */ |
| (progressive_frame,lower_layer_progressive_frame,llframe0[0],llframe1[0], |
| lltmp,current_frame[0],lower_layer_horizontal_offset, |
| lower_layer_vertical_offset, |
| lower_layer_prediction_horizontal_size, |
| lower_layer_prediction_vertical_size, |
| horizontal_size,vertical_size,vertical_subsampling_factor_m, |
| vertical_subsampling_factor_n,horizontal_subsampling_factor_m, |
| horizontal_subsampling_factor_n, |
| picture_structure!=FRAME_PICTURE); /* this changed from CD to DIS */ |
| |
| Make_Spatial_Prediction_Frame /* Cb */ |
| (progressive_frame,lower_layer_progressive_frame,llframe0[1],llframe1[1], |
| lltmp,current_frame[1],lower_layer_horizontal_offset/2, |
| lower_layer_vertical_offset/2, |
| lower_layer_prediction_horizontal_size>>1, |
| lower_layer_prediction_vertical_size>>1, |
| horizontal_size>>1,vertical_size>>1,vertical_subsampling_factor_m, |
| vertical_subsampling_factor_n,horizontal_subsampling_factor_m, |
| horizontal_subsampling_factor_n,1); |
| |
| Make_Spatial_Prediction_Frame /* Cr */ |
| (progressive_frame,lower_layer_progressive_frame,llframe0[2],llframe1[2], |
| lltmp,current_frame[2],lower_layer_horizontal_offset/2, |
| lower_layer_vertical_offset/2, |
| lower_layer_prediction_horizontal_size>>1, |
| lower_layer_prediction_vertical_size>>1, |
| horizontal_size>>1,vertical_size>>1,vertical_subsampling_factor_m, |
| vertical_subsampling_factor_n,horizontal_subsampling_factor_m, |
| horizontal_subsampling_factor_n,1); |
| |
| } |
| |
| static void Read_Lower_Layer_Component_Framewise(comp,lw,lh) |
| int comp; |
| int lw, lh; |
| { |
| FILE *fd; |
| char fname[256]; |
| char ext[3][3] = {".Y",".U",".V"}; |
| /* char *ext = {".Y",".U",".V"}; */ |
| int i,j; |
| |
| sprintf(fname,Lower_Layer_Picture_Filename,True_Framenum); |
| strcat(fname,ext[comp]); |
| #ifdef VERBOSE |
| if (Verbose_Flag>1) |
| printf("reading %s\n",fname); |
| #endif VERBOSE |
| fd=fopen(fname,"rb"); |
| if (fd==NULL) exit(-1); |
| for (j=0; j<lh; j++) { |
| for (i=0; i<lw; i++) |
| llframe0[comp][lw*j+i]=getc(fd); |
| if (! lower_layer_progressive_frame) { |
| j++; |
| for (i=0; i<lw; i++) |
| llframe1[comp][lw*j+i]=getc(fd); |
| } |
| } |
| fclose(fd); |
| } |
| |
| |
| static void Read_Lower_Layer_Component_Fieldwise(comp,lw,lh) |
| int comp; |
| int lw, lh; |
| { |
| FILE *fd; |
| char fname[256]; |
| char ext[3][3] = {".Y",".U",".V"}; |
| /* char *ext = {".Y",".U",".V"}; */ |
| int i,j; |
| |
| sprintf(fname,Lower_Layer_Picture_Filename,True_Framenum,lower_layer_progressive_frame ? 'f':'a'); |
| strcat(fname,ext[comp]); |
| #ifdef VERBOSE |
| if (Verbose_Flag>1) |
| printf("reading %s\n",fname); |
| #endif VERBOSE |
| fd=fopen(fname,"rb"); |
| if (fd==NULL) exit(-1); |
| for (j=0; j<lh; j+=lower_layer_progressive_frame?1:2) |
| for (i=0; i<lw; i++) |
| llframe0[comp][lw*j+i]=getc(fd); |
| fclose(fd); |
| |
| if (! lower_layer_progressive_frame) { |
| sprintf(fname,Lower_Layer_Picture_Filename,True_Framenum,'b'); |
| strcat(fname,ext[comp]); |
| #ifdef VERBOSE |
| if (Verbose_Flag>1) |
| printf("reading %s\n",fname); |
| #endif VERBOSE |
| fd=fopen(fname,"rb"); |
| if (fd==NULL) exit(-1); |
| for (j=1; j<lh; j+=2) |
| for (i=0; i<lw; i++) |
| llframe1[comp][lw*j+i]=getc(fd); |
| fclose(fd); |
| } |
| } |
| |
| |
| /* form spatial prediction */ |
| static void Make_Spatial_Prediction_Frame(progressive_frame, |
| llprogressive_frame,fld0,fld1,tmp,dst,llx0,lly0,llw,llh,horizontal_size, |
| vertical_size,vm,vn,hm,hn,aperture) |
| int progressive_frame,llprogressive_frame; |
| unsigned char *fld0,*fld1; |
| short *tmp; |
| unsigned char *dst; |
| int llx0,lly0,llw,llh,horizontal_size,vertical_size,vm,vn,hm,hn,aperture; |
| { |
| int w, h, x0, llw2, llh2; |
| |
| llw2 = (llw*hn)/hm; |
| llh2 = (llh*vn)/vm; |
| |
| if (llprogressive_frame) |
| { |
| /* progressive -> progressive / interlaced */ |
| Subsample_Vertical(fld0,tmp,llw,llh,llh2,vm,vn,0,1); |
| } |
| else if (progressive_frame) |
| { |
| /* interlaced -> progressive */ |
| if (lower_layer_deinterlaced_field_select) |
| { |
| Deinterlace(fld1,fld0,0,llw,llh,aperture); |
| Subsample_Vertical(fld1,tmp,llw,llh,llh2,vm,vn,0,1); |
| } |
| else |
| { |
| Deinterlace(fld0,fld1,1,llw,llh,aperture); |
| Subsample_Vertical(fld0,tmp,llw,llh,llh2,vm,vn,0,1); |
| } |
| } |
| else |
| { |
| /* interlaced -> interlaced */ |
| Deinterlace(fld0,fld1,1,llw,llh,aperture); |
| Deinterlace(fld1,fld0,0,llw,llh,aperture); |
| Subsample_Vertical(fld0,tmp,llw,llh,llh2,vm,vn,0,2); |
| Subsample_Vertical(fld1,tmp,llw,llh,llh2,vm,vn,1,2); |
| } |
| |
| /* vertical limits */ |
| if (lly0<0) |
| { |
| tmp-= llw*lly0; |
| llh2+= lly0; |
| if (llh2<0) |
| llh2 = 0; |
| h = (vertical_size<llh2) ? vertical_size : llh2; |
| } |
| else |
| { |
| dst+= horizontal_size*lly0; |
| h= vertical_size - lly0; |
| if (h>llh2) |
| h = llh2; |
| } |
| |
| /* horizontal limits */ |
| if (llx0<0) |
| { |
| x0 = -llx0; |
| llw2+= llx0; |
| if (llw2<0) |
| llw2 = 0; |
| w = (horizontal_size<llw2) ? horizontal_size : llw2; |
| } |
| else |
| { |
| dst+= llx0; |
| x0 = 0; |
| w = horizontal_size - llx0; |
| if (w>llw2) |
| w = llw2; |
| } |
| |
| Subsample_Horizontal(tmp,dst,x0,w,llw,horizontal_size,h,hm,hn); |
| } |
| |
| /* deinterlace one field (interpolate opposite parity samples) |
| * |
| * deinterlacing is done in-place: if j0=1, fld0 contains the input field in |
| * its even lines and the odd lines are interpolated by this routine |
| * if j0=0, the input field is in the odd lines and the even lines are |
| * interpolated |
| * |
| * fld0: field to be deinterlaced |
| * fld1: other field (referenced by the two field aperture filter) |
| * j0: 0: interpolate even (top) lines, 1: interpolate odd (bottom) lines |
| * lx: width of fld0 and fld1 |
| * ly: height of the deinterlaced field (has to be even) |
| * aperture: 1: use one field aperture filter (two field otherwise) |
| */ |
| static void Deinterlace(fld0,fld1,j0,lx,ly,aperture) |
| unsigned char *fld0,*fld1; |
| int j0,lx,ly; /* ly has to be even */ |
| int aperture; |
| { |
| int i,j,v; |
| unsigned char *p0, *p0m1, *p0p1, *p1, *p1m2, *p1p2; |
| |
| /* deinterlace one field */ |
| for (j=j0; j<ly; j+=2) |
| { |
| p0 = fld0+lx*j; |
| p0m1 = (j==0) ? p0+lx : p0-lx; |
| p0p1 = (j==ly-1) ? p0-lx : p0+lx; |
| |
| if (aperture) |
| for (i=0; i<lx; i++) |
| p0[i] = (unsigned int)(p0m1[i] + p0p1[i] + 1)>>1; |
| else |
| { |
| p1 = fld1 + lx*j; |
| p1m2 = (j<2) ? p1 : p1-2*lx; |
| p1p2 = (j>=ly-2) ? p1 : p1+2*lx; |
| for (i=0; i<lx; i++) |
| { |
| v = 8*(p0m1[i]+p0p1[i]) + 2*p1[i] - p1m2[i] - p1p2[i]; |
| p0[i] = Clip[(v + ((v>=0) ? 8 : 7))>>4]; |
| } |
| } |
| } |
| } |
| |
| /* vertical resampling */ |
| static void Subsample_Vertical(s,d,lx,lys,lyd,m,n,j0,dj) |
| unsigned char *s; |
| short *d; |
| int lx, lys, lyd, m, n, j0, dj; |
| { |
| int i, j, c1, c2, jd; |
| unsigned char *s1, *s2; |
| short *d1; |
| |
| for (j=j0; j<lyd; j+=dj) |
| { |
| d1 = d + lx*j; |
| jd = (j*m)/n; |
| s1 = s + lx*jd; |
| s2 = (jd<lys-1)? s1+lx : s1; |
| c2 = (16*((j*m)%n) + (n>>1))/n; |
| c1 = 16 - c2; |
| for (i=0; i<lx; i++) |
| d1[i] = c1*s1[i] + c2*s2[i]; |
| } |
| } |
| |
| /* horizontal resampling */ |
| static void Subsample_Horizontal(s,d,x0,lx,lxs,lxd,ly,m,n) |
| short *s; |
| unsigned char *d; |
| int x0, lx, lxs, lxd, ly, m, n; |
| { |
| int i, i1, j, id, c1, c2, v; |
| short *s1, *s2; |
| unsigned char *d1; |
| |
| for (i1=0; i1<lx; i1++) |
| { |
| d1 = d + i1; |
| i = x0 + i1; |
| id = (i*m)/n; |
| s1 = s+id; |
| s2 = (id<lxs-1) ? s1+1 : s1; |
| c2 = (16*((i*m)%n) + (n>>1))/n; |
| c1 = 16 - c2; |
| for (j=0; j<ly; j++) |
| { |
| v = c1*(*s1) + c2*(*s2); |
| *d1 = (v + ((v>=0) ? 128 : 127))>>8; |
| d1+= lxd; |
| s1+= lxs; |
| s2+= lxs; |
| } |
| } |
| } |
| |
| |