OpenCores
URL https://opencores.org/ocsvn/mpeg2fpga/mpeg2fpga/trunk

Subversion Repositories mpeg2fpga

[/] [mpeg2fpga/] [trunk/] [tools/] [mpeg2dec/] [spatscal.c] - Blame information for rev 2

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2019 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.