fbui | Framebuffer-based graphical environment |
| download: https://git.y1.nz/archives/fbui.tar.gz | |
| README | Files | Log | Refs |
libfbui/MPEG/recon.c
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 }
This webpage is intended to be an accessible preview of this repository. To get a fuller picture, clone it and use the git CLI.