[svn] / branches / dev-api-3 / xvidcore / src / motion / motion_comp.c Repository:
ViewVC logotype

Diff of /branches/dev-api-3/xvidcore/src/motion/motion_comp.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 701, Mon Dec 9 10:47:05 2002 UTC revision 704, Wed Dec 11 10:32:29 2002 UTC
# Line 14  Line 14 
14  #define SIGN(X) (((X)>0)?1:-1)  #define SIGN(X) (((X)>0)?1:-1)
15    
16    
 // decode an inter macroblock  
   
 static void  
 rrv_mv_scaleup(VECTOR * mv)  
 {  
         if (mv->x > 0) {  
                 mv->x = 2*mv->x - 1;  
         } else if (mv->x < 0) {  
                 mv->x = 2*mv->x + 1;  
         }  
   
         if (mv->y > 0) {  
                 mv->y = 2*mv->y - 1;  
         } else if (mv->y < 0) {  
                 mv->y = 2*mv->y + 1;  
         }  
 }  
   
   
17  static __inline void  static __inline void
18  compensate16x16_interpolate(int16_t * const dct_codes,  compensate16x16_interpolate(int16_t * const dct_codes,
19                                                      uint8_t * const cur,                                                      uint8_t * const cur,
# Line 52  Line 33 
33    
34          if (reduced_resolution)          if (reduced_resolution)
35          {          {
36                    const uint8_t * reference;
37                    x*=2; y*=2;
38    
39                  /* XXX: todo */                  reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
   
                 VECTOR mv;  
                 int i,j;  
                 uint8_t tmp[18*18];  
   
                 x*=2;  
                 y*=2;  
   
                 mv.x = dx;  
                 mv.y = dy;  
                 rrv_mv_scaleup(&mv);  
   
                 interpolate32x32_switch(  
                         refv, ref, x, y, mv.x, mv.y, stride, rounding);  
   
                 for (j = 0; j < 32; j++)  
                 for (i = 0; i < 32; i++)  
                         cur[(y+j)*stride + x + i] -= refv[(y+j)*stride + x + i];  
40    
41                  filter_18x18_to_8x8(dct_codes,     cur + y*stride + x, stride);                  filter_18x18_to_8x8(dct_codes,     cur + y*stride + x, stride);
42                  filter_18x18_to_8x8(dct_codes+64,  cur + y*stride + x + 16, stride);                  filter_diff_18x18_to_8x8(dct_codes, reference, stride);
                 filter_18x18_to_8x8(dct_codes+128, cur + (y+16)*stride + x, stride);  
                 filter_18x18_to_8x8(dct_codes+192, cur + (y+16)*stride + x + 16, stride);  
   
                 /*  
                 for (j = 0; j < 16; j++)  
                 for (i = 0; i < 16; i++)  
                         tmp[(j+1)*18 + i+1] = refv[ (y+j)*stride + x+i];  
   
                 for (i = 1; i < 17; i++)  
                 {  
                         tmp[ 0*18 + i] = tmp[ 1*18 + i];  
                         tmp[17*18 + i] = tmp[16*18 + i];  
                 }  
   
                 for (i = 0; i < 18; i++)  
                 {  
                         tmp[ i*18 + 0] = tmp[i*18 + 1];  
                         tmp[ i*18 + 17] = tmp[i*18 + 16];  
                 }  
                 filter_18x18_to_8x8(dct_codes, tmp, 18);  
   
   
                 for (j = 0; j < 16; j++)  
                 for (i = 0; i < 16; i++)  
                         tmp[(j+1)*18 + i+1] = refv[ (y+j)*stride + x+i + 16];  
   
                 for (i = 1; i < 17; i++)  
                 {  
                         tmp[ 0*18 + i] = tmp[ 1*18 + i];  
                         tmp[17*18 + i] = tmp[16*18 + i];  
                 }  
   
                 for (i = 0; i < 18; i++)  
                 {  
                         tmp[ i*18 + 0] = tmp[i*18 + 1];  
                         tmp[ i*18 + 17] = tmp[i*18 + 16];  
                 }  
                 filter_18x18_to_8x8(dct_codes+64, tmp, 18);  
   
                 for (j = 0; j < 16; j++)  
                 for (i = 0; i < 16; i++)  
                         tmp[(j+1)*18 + i+1] = refv[ (y+16+j)*stride + x+i];  
43    
44                  for (i = 1; i < 17; i++)                  filter_18x18_to_8x8(dct_codes+64, cur+y*stride + x + 16, stride);
45                  {                  filter_diff_18x18_to_8x8(dct_codes+64, reference + 16, stride);
                         tmp[ 0*18 + i] = tmp[ 1*18 + i];  
                         tmp[17*18 + i] = tmp[16*18 + i];  
                 }  
   
                 for (i = 0; i < 18; i++)  
                 {  
                         tmp[ i*18 + 0] = tmp[i*18 + 1];  
                         tmp[ i*18 + 17] = tmp[i*18 + 16];  
                 }  
                 filter_18x18_to_8x8(dct_codes+128, tmp, 18);  
   
                 for (j = 0; j < 16; j++)  
                 for (i = 0; i < 16; i++)  
                         tmp[(j+1)*18 + i+1] = refv[ (y+16+j)*stride + x+i + 16];  
   
                 for (i = 1; i < 17; i++)  
                 {  
                         tmp[ 0*18 + i] = tmp[ 1*18 + i];  
                         tmp[17*18 + i] = tmp[16*18 + i];  
                 }  
46    
47                  for (i = 0; i < 18; i++)                  filter_18x18_to_8x8(dct_codes+128, cur+(y+16)*stride + x, stride);
48                  {                  filter_diff_18x18_to_8x8(dct_codes+128, reference + 16*stride, stride);
                         tmp[ i*18 + 0] = tmp[i*18 + 1];  
                         tmp[ i*18 + 17] = tmp[i*18 + 16];  
                 }  
                 filter_18x18_to_8x8(dct_codes+192, tmp, 18);  
                 */  
49    
50                    filter_18x18_to_8x8(dct_codes+192, cur+(y+16)*stride + x + 16, stride);
51                    filter_diff_18x18_to_8x8(dct_codes+192, reference + 16*stride + 16, stride);
52    
53                  //memset(dct_codes, 0, sizeof(uint16_t) * 64 * 4);                  transfer32x32_copy(cur + y*stride + x, reference, stride);
54    
55          }else{          }else{
56                  if(quarterpel) {                  if(quarterpel) {
# Line 169  Line 69 
69                  }                  }
70                  else                  else
71                  {                  {
72                          const uint8_t * reference;                          const uint8_t * reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
73    
                         switch (((dx & 1) << 1) + (dy & 1))     // ((dx%2)?2:0)+((dy%2)?1:0)  
                         {  
                         case 0: reference = ref + ((y + dy / 2) * stride + x + dx / 2); break;  
                         case 1: reference = refv + ((y + (dy-1) / 2) * stride + x + dx / 2); break;  
                         case 2: reference = refh + ((y + dy / 2) * stride + x + (dx-1) / 2); break;  
                         default:                                        // case 3:  
                                 reference = refhv + ((y + (dy-1) / 2) * stride + x + (dx-1) / 2); break;  
                         }  
74                          transfer_8to16sub(dct_codes, cur + y * stride + x,                          transfer_8to16sub(dct_codes, cur + y * stride + x,
75                                                                    reference, stride);                                                                    reference, stride);
76                          transfer_8to16sub(dct_codes+64, cur + y * stride + x + 8,                          transfer_8to16sub(dct_codes+64, cur + y * stride + x + 8,
# Line 198  Line 90 
90                                                    const uint8_t * const refh,                                                    const uint8_t * const refh,
91                                                    const uint8_t * const refv,                                                    const uint8_t * const refv,
92                                                    const uint8_t * const refhv,                                                    const uint8_t * const refhv,
93                                                    const uint32_t x,                                                    uint32_t x,
94                                                    const uint32_t y,                                                    uint32_t y,
95                                                    const int32_t dx,                                                    const int32_t dx,
96                                                    const int32_t dy,                                                    const int32_t dy,
97                                                    const uint32_t stride,                                                    const uint32_t stride,
# Line 209  Line 101 
101  {  {
102          if (reduced_resolution)          if (reduced_resolution)
103          {          {
104                  // XXX: todo                  const uint8_t * reference;
105                    x*=2; y*=2;
106    
107                    reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
108    
109                    filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
110                    filter_diff_18x18_to_8x8(dct_codes, reference, stride);
111    
112                    transfer16x16_copy(cur + y*stride + x, reference, stride);
113    
114          } else {          } else {
115    
116                  if(quarterpel) {                  if(quarterpel) {
# Line 221  Line 122 
122                  }                  }
123                  else                  else
124                  {                  {
125                          const uint8_t * reference;                          const uint8_t * reference = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
126    
                         switch (((dx & 1) << 1) + (dy & 1))     // ((dx%2)?2:0)+((dy%2)?1:0)  
                         {  
                         case 0: reference = ref + ((y + dy / 2) * stride + x + dx / 2); break;  
                         case 1: reference = refv + ((y + (dy-1) / 2) * stride + x + dx / 2); break;  
                         case 2: reference = refh + ((y + dy / 2) * stride + x + (dx-1) / 2); break;  
                         default:                                        // case 3:  
                                 reference = refhv + ((y + (dy-1) / 2) * stride + x + (dx-1) / 2); break;  
                         }  
127                          transfer_8to16sub(dct_codes, cur + y * stride + x,                          transfer_8to16sub(dct_codes, cur + y * stride + x,
128                                                                    reference, stride);                                                                    reference, stride);
129                  }                  }
130          }          }
131  }  }
132    
133    
134    
135    /* XXX: slow, inelegant... */
136    static void
137    interpolate18x18_switch(uint8_t * const cur,
138                                              const uint8_t * const refn,
139                                              const uint32_t x,
140                                              const uint32_t y,
141                                              const int32_t dx,
142                                              const int dy,
143                                              const uint32_t stride,
144                                              const uint32_t rounding)
145    {
146            interpolate8x8_switch(cur, refn, x-1, y-1, dx, dy, stride, rounding);
147            interpolate8x8_switch(cur, refn, x+7, y-1, dx, dy, stride, rounding);
148            interpolate8x8_switch(cur, refn, x+9, y-1, dx, dy, stride, rounding);
149    
150            interpolate8x8_switch(cur, refn, x-1, y+7, dx, dy, stride, rounding);
151            interpolate8x8_switch(cur, refn, x+7, y+7, dx, dy, stride, rounding);
152            interpolate8x8_switch(cur, refn, x+9, y+7, dx, dy, stride, rounding);
153    
154            interpolate8x8_switch(cur, refn, x-1, y+9, dx, dy, stride, rounding);
155            interpolate8x8_switch(cur, refn, x+7, y+9, dx, dy, stride, rounding);
156            interpolate8x8_switch(cur, refn, x+9, y+9, dx, dy, stride, rounding);
157    }
158    
159    
160  void  void
161  MBMotionCompensation(MACROBLOCK * const mb,  MBMotionCompensation(MACROBLOCK * const mb,
162                                           const uint32_t i,                                           const uint32_t i,
# Line 260  Line 180 
180                  int32_t dx = (quarterpel ? mb->qmvs[0].x : mb->mvs[0].x);                  int32_t dx = (quarterpel ? mb->qmvs[0].x : mb->mvs[0].x);
181                  int32_t dy = (quarterpel ? mb->qmvs[0].y : mb->mvs[0].y);                  int32_t dy = (quarterpel ? mb->qmvs[0].y : mb->mvs[0].y);
182    
183                  if ( (mb->mode == MODE_NOT_CODED) && (dx==0) && (dy==0) ) {     /* quick copy */                  if ( (!reduced_resolution) && (mb->mode == MODE_NOT_CODED) && (dx==0) && (dy==0) ) {    /* quick copy */
184                          transfer16x16_copy(cur->y + 16 * (i + j * edged_width),                          transfer16x16_copy(cur->y + 16 * (i + j * edged_width),
185                                                             ref->y + 16 * (i + j * edged_width),                                                             ref->y + 16 * (i + j * edged_width),
186                                                             edged_width);                                                             edged_width);
# Line 275  Line 195 
195                  }                  }
196          /* quick MODE_NOT_CODED for GMC with MV!=(0,0) is still needed */          /* quick MODE_NOT_CODED for GMC with MV!=(0,0) is still needed */
197    
198                    if (reduced_resolution)
199                    {
200                            dx = RRV_MV_SCALEUP(dx);
201                            dy = RRV_MV_SCALEUP(dy);
202                    }
203    
204                  compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,                  compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
205                                                    refv->y, refhv->y, 16 * i, 16 * j, dx, dy,                                                    refv->y, refhv->y, 16 * i, 16 * j, dx, dy,
206                                                    edged_width, quarterpel, reduced_resolution, rounding);                                                    edged_width, quarterpel, reduced_resolution, rounding);
# Line 288  Line 214 
214                  dx = (dx >> 1) + roundtab_79[dx & 0x3];                  dx = (dx >> 1) + roundtab_79[dx & 0x3];
215                  dy = (dy >> 1) + roundtab_79[dy & 0x3];                  dy = (dy >> 1) + roundtab_79[dy & 0x3];
216    
217                  /* uv-block-based compensation */                  /* uv-block-based compensation
218                            XXX: rrv doesnt work with 16x16 block-based intepolation.
219                            we need to use 18x18-block interpolation */
220                  if (reduced_resolution)                  if (reduced_resolution)
221                  {                  {
222                          // XXX: todo                          const stride = edged_width/2;
223                            uint8_t * current, * reference;
224    
225                            current = cur->u + 16*j*stride + 16*i;
226                            reference = refv->u + 16*j*stride + 16*i;
227                            //interpolate16x16_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
228                            interpolate18x18_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
229                            filter_18x18_to_8x8(dct_codes + 4*64, current, stride);
230                            filter_diff_18x18_to_8x8(dct_codes + 4*64, reference, stride);
231                            transfer16x16_copy(current, reference, stride);
232    
233                            current = cur->v + 16*j*stride + 16*i;
234                            reference = refv->v + 16*j*stride + 16*i;
235                            //interpolate16x16_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
236                            interpolate18x18_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
237                            filter_18x18_to_8x8(dct_codes + 5*64, current, stride);
238                            filter_diff_18x18_to_8x8(dct_codes + 5*64, reference, stride);
239                            transfer16x16_copy(current, reference, stride);
240                  }else{                  }else{
241                          transfer_8to16sub(&dct_codes[4 * 64],                          transfer_8to16sub(&dct_codes[4 * 64],
242                                                                  cur->u + 8 * j * edged_width / 2 + 8 * i,                                                                  cur->u + 8 * j * edged_width / 2 + 8 * i,
# Line 307  Line 252 
252                  }                  }
253    
254          } else {                                        // mode == MODE_INTER4V          } else {                                        // mode == MODE_INTER4V
255                    int i;
256                  int32_t sum, dx, dy;                  int32_t sum, dx, dy;
257                  VECTOR *mvs;                  VECTOR mvs[4];
258    
259                  if(quarterpel)                  if(quarterpel)
260                          mvs = mb->qmvs;                          for (i = 0; i < 4; i++) mvs[i] = mb->qmvs[i];
261                  else                  else
262                          mvs = mb->mvs;                          for (i = 0; i < 4; i++) mvs[i] = mb->mvs[i];
263    
264                  if (reduced_resolution)                  if (reduced_resolution)
265                  {                  {
266                          ///XXX: todo                          for (i = 0; i < 4; i++)
267                  }else{                          {
268                                    mvs[i].x = RRV_MV_SCALEUP(mvs[i].x);
269                                    mvs[i].y = RRV_MV_SCALEUP(mvs[i].y);
270                            }
271                    }
272    
273                          compensate8x8_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,                          compensate8x8_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
274                                                            refv->y, refhv->y, 16 * i, 16 * j, mvs[0].x,                                                            refv->y, refhv->y, 16 * i, 16 * j, mvs[0].x,
# Line 332  Line 282 
282                          compensate8x8_interpolate(&dct_codes[3 * 64], cur->y, ref->y, refh->y,                          compensate8x8_interpolate(&dct_codes[3 * 64], cur->y, ref->y, refh->y,
283                                                                    refv->y, refhv->y, 16 * i + 8, 16 * j + 8,                                                                    refv->y, refhv->y, 16 * i + 8, 16 * j + 8,
284                                                                    mvs[3].x, mvs[3].y, edged_width, quarterpel, reduced_resolution, rounding);                                                                    mvs[3].x, mvs[3].y, edged_width, quarterpel, reduced_resolution, rounding);
                 }  
285    
286                  if(quarterpel)                  if(quarterpel)
287                          sum = (mvs[0].x / 2) + (mvs[1].x / 2) + (mvs[2].x / 2) + (mvs[3].x / 2);                          sum = (mvs[0].x / 2) + (mvs[1].x / 2) + (mvs[2].x / 2) + (mvs[3].x / 2);
# Line 348  Line 297 
297    
298                  dy = (sum >> 3) + roundtab_76[sum & 0xf];                  dy = (sum >> 3) + roundtab_76[sum & 0xf];
299    
300                  /* uv-block-based compensation */  
301                    /* uv-block-based compensation
302                            XXX: rrv doesnt work with 16x16 block-based intepolation.
303                            we need to use 18x18-block interpolation */
304                  if (reduced_resolution)                  if (reduced_resolution)
305                  {                  {
306                          //XXX: todo                          const stride = edged_width/2;
307                            uint8_t * current, * reference;
308    
309                            current = cur->u + 16*j*stride + 16*i;
310                            reference = refv->u + 16*j*stride + 16*i;
311                            interpolate16x16_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
312                            filter_18x18_to_8x8(dct_codes + 4*64, current, stride);
313                            filter_diff_18x18_to_8x8(dct_codes + 4*64, reference, stride);
314                            transfer16x16_copy(current, reference, stride);
315    
316                            current = cur->v + 16*j*stride + 16*i;
317                            reference = refv->v + 16*j*stride + 16*i;
318                            interpolate16x16_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
319                            filter_18x18_to_8x8(dct_codes + 5*64, current, stride);
320                            filter_diff_18x18_to_8x8(dct_codes + 5*64, reference, stride);
321                            transfer16x16_copy(current, reference, stride);
322    
323                  }else{                  }else{
324                          transfer_8to16sub(&dct_codes[4 * 64],                          transfer_8to16sub(&dct_codes[4 * 64],
325                                                                  cur->u + 8 * j * edged_width / 2 + 8 * i,                                                                  cur->u + 8 * j * edged_width / 2 + 8 * i,
Legend:
Removed from v.701  
changed lines
  Added in v.704
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4