Subversion Repositories shark

Rev

Rev 1085 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1085 pj 1
/* Predict.c, motion compensation routines                                    */
2
 
3
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
4
 
5
/*
6
 * Disclaimer of Warranty
7
 *
8
 * These software programs are available to the user without any license fee or
9
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
10
 * any and all warranties, whether express, implied, or statuary, including any
11
 * implied warranties or merchantability or of fitness for a particular
12
 * purpose.  In no event shall the copyright-holder be liable for any
13
 * incidental, punitive, or consequential damages of any kind whatsoever
14
 * arising from the use of these programs.
15
 *
16
 * This disclaimer of warranty extends to the user of these programs and user's
17
 * customers, employees, agents, transferees, successors, and assigns.
18
 *
19
 * The MPEG Software Simulation Group does not represent or warrant that the
20
 * programs furnished hereunder are free of infringement of any third-party
21
 * patents.
22
 *
23
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
24
 * are subject to royalty fees to patent holders.  Many of these patents are
25
 * general enough such that they are unavoidable regardless of implementation
26
 * design.
27
 *
28
 */
29
 
30
#include <stdio.h>
31
 
32
#include "config.h"
33
#include "global.h"
34
 
35
/* private prototypes */
36
static void form_prediction _ANSI_ARGS_((unsigned char *src[], int sfield,
37
  unsigned char *dst[], int dfield,
38
  int lx, int lx2, int w, int h, int x, int y, int dx, int dy,
39
  int average_flag));
40
 
41
static void form_component_prediction _ANSI_ARGS_((unsigned char *src, unsigned char *dst,
42
  int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag));
43
 
44
void form_predictions(bx,by,macroblock_type,motion_type,PMV,motion_vertical_field_select,dmvector,stwtype)
45
int bx, by;
46
int macroblock_type;
47
int motion_type;
48
int PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];
49
int stwtype;
50
{
51
  int currentfield;
52
  unsigned char **predframe;
53
  int DMV[2][2];
54
  int stwtop, stwbot;
55
 
56
  stwtop = stwtype%3; /* 0:temporal, 1:(spat+temp)/2, 2:spatial */
57
  stwbot = stwtype/3;
58
 
59
  if ((macroblock_type & MACROBLOCK_MOTION_FORWARD)
60
   || (picture_coding_type==P_TYPE))
61
  {
62
    if (picture_structure==FRAME_PICTURE)
63
    {
64
      if ((motion_type==MC_FRAME)
65
        || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
66
      {
67
        /* frame-based prediction (broken into top and bottom halves
68
             for spatial scalability prediction purposes) */
69
        if (stwtop<2)
70
          form_prediction(forward_reference_frame,0,current_frame,0,
71
            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
72
            PMV[0][0][0],PMV[0][0][1],stwtop);
73
 
74
        if (stwbot<2)
75
          form_prediction(forward_reference_frame,1,current_frame,1,
76
            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
77
            PMV[0][0][0],PMV[0][0][1],stwbot);
78
      }
79
      else if (motion_type==MC_FIELD) /* field-based prediction */
80
      {
81
        /* top field prediction */
82
        if (stwtop<2)
83
          form_prediction(forward_reference_frame,motion_vertical_field_select[0][0],
84
            current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
85
            bx,by>>1,PMV[0][0][0],PMV[0][0][1]>>1,stwtop);
86
 
87
        /* bottom field prediction */
88
        if (stwbot<2)
89
          form_prediction(forward_reference_frame,motion_vertical_field_select[1][0],
90
            current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
91
            bx,by>>1,PMV[1][0][0],PMV[1][0][1]>>1,stwbot);
92
      }
93
      else if (motion_type==MC_DMV) /* dual prime prediction */
94
      {
95
        /* calculate derived motion vectors */
96
        Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]>>1);
97
 
98
        if (stwtop<2)
99
        {
100
          /* predict top field from top field */
101
          form_prediction(forward_reference_frame,0,current_frame,0,
102
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
103
            PMV[0][0][0],PMV[0][0][1]>>1,0);
104
 
105
          /* predict and add to top field from bottom field */
106
          form_prediction(forward_reference_frame,1,current_frame,0,
107
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
108
            DMV[0][0],DMV[0][1],1);
109
        }
110
 
111
        if (stwbot<2)
112
        {
113
          /* predict bottom field from bottom field */
114
          form_prediction(forward_reference_frame,1,current_frame,1,
115
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
116
            PMV[0][0][0],PMV[0][0][1]>>1,0);
117
 
118
          /* predict and add to bottom field from top field */
119
          form_prediction(forward_reference_frame,0,current_frame,1,
120
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
121
            DMV[1][0],DMV[1][1],1);
122
        }
123
      }
124
      else
125
        /* invalid motion_type */
126
        printf("invalid motion_type\n");
127
    }
128
    else /* TOP_FIELD or BOTTOM_FIELD */
129
    {
130
      /* field picture */
131
      currentfield = (picture_structure==BOTTOM_FIELD);
132
 
133
      /* determine which frame to use for prediction */
134
      if ((picture_coding_type==P_TYPE) && Second_Field
135
         && (currentfield!=motion_vertical_field_select[0][0]))
136
        predframe = backward_reference_frame; /* same frame */
137
      else
138
        predframe = forward_reference_frame; /* previous frame */
139
 
140
      if ((motion_type==MC_FIELD)
141
        || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
142
      {
143
        /* field-based prediction */
144
        if (stwtop<2)
145
          form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,
146
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
147
            PMV[0][0][0],PMV[0][0][1],stwtop);
148
      }
149
      else if (motion_type==MC_16X8)
150
      {
151
        if (stwtop<2)
152
        {
153
          form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,
154
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by,
155
            PMV[0][0][0],PMV[0][0][1],stwtop);
156
 
157
          /* determine which frame to use for lower half prediction */
158
          if ((picture_coding_type==P_TYPE) && Second_Field
159
             && (currentfield!=motion_vertical_field_select[1][0]))
160
            predframe = backward_reference_frame; /* same frame */
161
          else
162
            predframe = forward_reference_frame; /* previous frame */
163
 
164
          form_prediction(predframe,motion_vertical_field_select[1][0],current_frame,0,
165
            Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by+8,
166
            PMV[1][0][0],PMV[1][0][1],stwtop);
167
        }
168
      }
169
      else if (motion_type==MC_DMV) /* dual prime prediction */
170
      {
171
        if (Second_Field)
172
          predframe = backward_reference_frame; /* same frame */
173
        else
174
          predframe = forward_reference_frame; /* previous frame */
175
 
176
        /* calculate derived motion vectors */
177
        Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]);
178
 
179
        /* predict from field of same parity */
180
        form_prediction(forward_reference_frame,currentfield,current_frame,0,
181
          Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
182
          PMV[0][0][0],PMV[0][0][1],0);
183
 
184
        /* predict from field of opposite parity */
185
        form_prediction(predframe,!currentfield,current_frame,0,
186
          Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
187
          DMV[0][0],DMV[0][1],1);
188
      }
189
      else
190
        /* invalid motion_type */
191
        printf("invalid motion_type\n");
192
    }
193
    stwtop = stwbot = 1;
194
  }
195
 
196
  if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)
197
  {
198
    if (picture_structure==FRAME_PICTURE)
199
    {
200
      if (motion_type==MC_FRAME)
201
      {
202
        /* frame-based prediction */
203
        if (stwtop<2)
204
          form_prediction(backward_reference_frame,0,current_frame,0,
205
            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
206
            PMV[0][1][0],PMV[0][1][1],stwtop);
207
 
208
        if (stwbot<2)
209
          form_prediction(backward_reference_frame,1,current_frame,1,
210
            Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
211
            PMV[0][1][0],PMV[0][1][1],stwbot);
212
      }
213
      else /* field-based prediction */
214
      {
215
        /* top field prediction */
216
        if (stwtop<2)
217
          form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
218
            current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
219
            bx,by>>1,PMV[0][1][0],PMV[0][1][1]>>1,stwtop);
220
 
221
        /* bottom field prediction */
222
        if (stwbot<2)
223
          form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],
224
            current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
225
            bx,by>>1,PMV[1][1][0],PMV[1][1][1]>>1,stwbot);
226
      }
227
    }
228
    else /* TOP_FIELD or BOTTOM_FIELD */
229
    {
230
      /* field picture */
231
      if (motion_type==MC_FIELD)
232
      {
233
        /* field-based prediction */
234
        form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
235
          current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,
236
          bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
237
      }
238
      else if (motion_type==MC_16X8)
239
      {
240
        form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
241
          current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
242
          bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
243
 
244
        form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],
245
          current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
246
          bx,by+8,PMV[1][1][0],PMV[1][1][1],stwtop);
247
      }
248
      else
249
        /* invalid motion_type */
250
        printf("invalid motion_type\n");
251
    }
252
  }
253
}
254
 
255
static void form_prediction(src,sfield,dst,dfield,lx,lx2,w,h,x,y,dx,dy,average_flag)
256
unsigned char *src[]; /* prediction source buffer */
257
int sfield;           /* prediction source field number (0 or 1) */
258
unsigned char *dst[]; /* prediction destination buffer */
259
int dfield;           /* prediction destination field number (0 or 1)*/
260
int lx,lx2;           /* line strides */
261
int w,h;              /* prediction block/sub-block width, height */
262
int x,y;              /* pixel co-ordinates of top-left sample in current MB */
263
int dx,dy;            /* horizontal, vertical prediction address */
264
int average_flag;     /* add prediction error to prediction ? */
265
{
266
  /* Y */
267
  form_component_prediction(src[0]+(sfield?lx2>>1:0),dst[0]+(dfield?lx2>>1:0),
268
    lx,lx2,w,h,x,y,dx,dy,average_flag);
269
 
270
  if (chroma_format!=CHROMA444)
271
  {
272
    lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
273
  }
274
 
275
  if (chroma_format==CHROMA420)
276
  {
277
    h>>=1; y>>=1; dy/=2;
278
  }
279
 
280
  /* Cb */
281
  form_component_prediction(src[1]+(sfield?lx2>>1:0),dst[1]+(dfield?lx2>>1:0),
282
    lx,lx2,w,h,x,y,dx,dy,average_flag);
283
 
284
  /* Cr */
285
  form_component_prediction(src[2]+(sfield?lx2>>1:0),dst[2]+(dfield?lx2>>1:0),
286
    lx,lx2,w,h,x,y,dx,dy,average_flag);
287
}
288
 
289
/* ISO/IEC 13818-2 section 7.6.4: Forming predictions */
290
/* NOTE: the arithmetic below produces numerically equivalent results
291
 *  to 7.6.4, yet is more elegant. It differs in the following ways:
292
 *
293
 *   1. the vectors (dx, dy) are based on cartesian frame
294
 *      coordiantes along a half-pel grid (always positive numbers)
295
 *      In contrast, vector[r][s][t] are differential (with positive and
296
 *      negative values). As a result, deriving the integer vectors
297
 *      (int_vec[t]) from dx, dy is accomplished by a simple right shift.
298
 *
299
 *   2. Half pel flags (xh, yh) are equivalent to the LSB (Least
300
 *      Significant Bit) of the half-pel coordinates (dx,dy).
301
 *
302
 *
303
 *  NOTE: the work of combining predictions (ISO/IEC 13818-2 section 7.6.7)
304
 *  is distributed among several other stages.  This is accomplished by
305
 *  folding line offsets into the source and destination (src,dst)
306
 *  addresses (note the call arguments to form_prediction() in Predict()),
307
 *  line stride variables lx and lx2, the block dimension variables (w,h),
308
 *  average_flag, and by the very order in which Predict() is called.  
309
 *  This implementation design (implicitly different than the spec)
310
 *  was chosen for its elegance.
311
*/
312
 
313
static void form_component_prediction(src,dst,lx,lx2,w,h,x,y,dx,dy,average_flag)
314
unsigned char *src;
315
unsigned char *dst;
316
int lx;          /* raster line increment */
317
int lx2;
318
int w,h;
319
int x,y;
320
int dx,dy;
321
int average_flag;      /* flag that signals bi-directional or Dual-Prime
322
                          averaging (7.6.7.1 and 7.6.7.4). if average_flag==1,
323
                          a previously formed prediction has been stored in
324
                          pel_pred[] */
325
{
326
  int xint;      /* horizontal integer sample vector: analogous to int_vec[0] */
327
  int yint;      /* vertical integer sample vectors: analogous to int_vec[1] */
328
  int xh;        /* horizontal half sample flag: analogous to half_flag[0]  */
329
  int yh;        /* vertical half sample flag: analogous to half_flag[1]  */
330
  int i, j, v;
331
  unsigned char *s;    /* source pointer: analogous to pel_ref[][]   */
332
  unsigned char *d;    /* destination pointer:  analogous to pel_pred[][]  */
333
 
334
  /* half pel scaling for integer vectors */
335
  xint = dx>>1;
336
  yint = dy>>1;
337
 
338
  /* derive half pel flags */
339
  xh = dx & 1;
340
  yh = dy & 1;
341
 
342
  /* compute the linear address of pel_ref[][] and pel_pred[][]
343
     based on cartesian/raster cordinates provided */
344
  s = src + lx*(y+yint) + x + xint;
345
  d = dst + lx*y + x;
346
 
347
  if (!xh && !yh) /* no horizontal nor vertical half-pel */
348
  {
349
    if (average_flag)
350
    {
351
      for (j=0; j<h; j++)
352
      {
353
        for (i=0; i<w; i++)
354
        {
355
          v = d[i]+s[i];
356
          d[i] = (v+(v>=0?1:0))>>1;
357
        }
358
 
359
        s+= lx2;
360
        d+= lx2;
361
      }
362
    }
363
    else
364
    {
365
      for (j=0; j<h; j++)
366
      {
367
        for (i=0; i<w; i++)
368
        {
369
          d[i] = s[i];
370
        }
371
 
372
        s+= lx2;
373
        d+= lx2;
374
      }
375
    }
376
  }
377
  else if (!xh && yh) /* no horizontal but vertical half-pel */
378
  {
379
    if (average_flag)
380
    {
381
      for (j=0; j<h; j++)
382
      {
383
        for (i=0; i<w; i++)
384
        {
385
          v = d[i] + ((unsigned int)(s[i]+s[i+lx]+1)>>1);
386
          d[i]=(v+(v>=0?1:0))>>1;
387
        }
388
 
389
        s+= lx2;
390
        d+= lx2;
391
      }
392
    }
393
    else
394
    {
395
      for (j=0; j<h; j++)
396
      {
397
        for (i=0; i<w; i++)
398
        {
399
          d[i] = (unsigned int)(s[i]+s[i+lx]+1)>>1;
400
        }
401
 
402
        s+= lx2;
403
        d+= lx2;
404
      }
405
    }
406
  }
407
  else if (xh && !yh) /* horizontal but no vertical half-pel */
408
  {
409
    if (average_flag)
410
    {
411
      for (j=0; j<h; j++)
412
      {
413
        for (i=0; i<w; i++)
414
        {
415
          v = d[i] + ((unsigned int)(s[i]+s[i+1]+1)>>1);
416
          d[i] = (v+(v>=0?1:0))>>1;
417
        }
418
 
419
        s+= lx2;
420
        d+= lx2;
421
      }
422
    }
423
    else
424
    {
425
      for (j=0; j<h; j++)
426
      {
427
        for (i=0; i<w; i++)
428
        {
429
          d[i] = (unsigned int)(s[i]+s[i+1]+1)>>1;
430
        }
431
 
432
        s+= lx2;
433
        d+= lx2;
434
      }
435
    }
436
  }
437
  else /* if (xh && yh) horizontal and vertical half-pel */
438
  {
439
    if (average_flag)
440
    {
441
      for (j=0; j<h; j++)
442
      {
443
        for (i=0; i<w; i++)
444
        {
445
          v = d[i] + ((unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2);
446
          d[i] = (v+(v>=0?1:0))>>1;
447
        }
448
 
449
        s+= lx2;
450
        d+= lx2;
451
      }
452
    }
453
    else
454
    {
455
      for (j=0; j<h; j++)
456
      {
457
        for (i=0; i<w; i++)
458
        {
459
          d[i] = (unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
460
        }
461
 
462
        s+= lx2;
463
        d+= lx2;
464
      }
465
    }
466
  }
467
}