658 lines
10 KiB
C
658 lines
10 KiB
C
|
|
|
|
#include <stdio.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"};
|
|
|
|
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"};
|
|
|
|
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, mpegid, c1, c2, v;
|
|
|
|
short *s1, *s2;
|
|
|
|
unsigned char *d1;
|
|
|
|
|
|
|
|
for (i1=0; i1<lx; i1++)
|
|
|
|
{
|
|
|
|
d1 = d + i1;
|
|
|
|
i = x0 + i1;
|
|
|
|
mpegid = (i*m)/n;
|
|
|
|
s1 = s+mpegid;
|
|
|
|
s2 = (mpegid<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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|