[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 702, Tue Dec 10 11:13:50 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];  
   
                 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+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];  
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];  
                 }  
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                  }                  }
# Line 275  Line 168 
168                  }                  }
169          /* 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 */
170    
171                    if (reduced_resolution)
172                    {
173                            dx = RRV_MV_SCALEUP(dx);
174                            dy = RRV_MV_SCALEUP(dy);
175                    }
176    
177                  compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,                  compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
178                                                    refv->y, refhv->y, 16 * i, 16 * j, dx, dy,                                                    refv->y, refhv->y, 16 * i, 16 * j, dx, dy,
179                                                    edged_width, quarterpel, reduced_resolution, rounding);                                                    edged_width, quarterpel, reduced_resolution, rounding);
# Line 288  Line 187 
187                  dx = (dx >> 1) + roundtab_79[dx & 0x3];                  dx = (dx >> 1) + roundtab_79[dx & 0x3];
188                  dy = (dy >> 1) + roundtab_79[dy & 0x3];                  dy = (dy >> 1) + roundtab_79[dy & 0x3];
189    
190                  /* uv-block-based compensation */                  /* uv-block-based compensation
191                            XXX: rrv doesnt work with 16x16 block-based intepolation.
192                            we need to use 18x18-block interpolation */
193                  if (reduced_resolution)                  if (reduced_resolution)
194                  {                  {
195                          // XXX: todo                          const stride = edged_width/2;
196                            uint8_t * current, * reference;
197    
198                            current = cur->u + 16*j*stride + 16*i;
199                            reference = refv->u + 16*j*stride + 16*i;
200                            interpolate16x16_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
201                            filter_18x18_to_8x8(dct_codes + 4*64, current, stride);
202                            filter_diff_18x18_to_8x8(dct_codes + 4*64, reference, stride);
203                            transfer16x16_copy(current, reference, stride);
204    
205                            current = cur->v + 16*j*stride + 16*i;
206                            reference = refv->v + 16*j*stride + 16*i;
207                            interpolate16x16_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
208                            filter_18x18_to_8x8(dct_codes + 5*64, current, stride);
209                            filter_diff_18x18_to_8x8(dct_codes + 5*64, reference, stride);
210                            transfer16x16_copy(current, reference, stride);
211                  }else{                  }else{
212                          transfer_8to16sub(&dct_codes[4 * 64],                          transfer_8to16sub(&dct_codes[4 * 64],
213                                                                  cur->u + 8 * j * edged_width / 2 + 8 * i,                                                                  cur->u + 8 * j * edged_width / 2 + 8 * i,
# Line 307  Line 223 
223                  }                  }
224    
225          } else {                                        // mode == MODE_INTER4V          } else {                                        // mode == MODE_INTER4V
226                    int i;
227                  int32_t sum, dx, dy;                  int32_t sum, dx, dy;
228                  VECTOR *mvs;                  VECTOR mvs[4];
229    
230                  if(quarterpel)                  if(quarterpel)
231                          mvs = mb->qmvs;                          for (i = 0; i < 4; i++) mvs[i] = mb->qmvs[i];
232                  else                  else
233                          mvs = mb->mvs;                          for (i = 0; i < 4; i++) mvs[i] = mb->mvs[i];
234    
235                  if (reduced_resolution)                  if (reduced_resolution)
236                  {                  {
237                          ///XXX: todo                          for (i = 0; i < 4; i++)
238                  }else{                          {
239                                    mvs[i].x = RRV_MV_SCALEUP(mvs[i].x);
240                                    mvs[i].y = RRV_MV_SCALEUP(mvs[i].y);
241                            }
242                    }
243    
244                          compensate8x8_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,                          compensate8x8_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
245                                                            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 253 
253                          compensate8x8_interpolate(&dct_codes[3 * 64], cur->y, ref->y, refh->y,                          compensate8x8_interpolate(&dct_codes[3 * 64], cur->y, ref->y, refh->y,
254                                                                    refv->y, refhv->y, 16 * i + 8, 16 * j + 8,                                                                    refv->y, refhv->y, 16 * i + 8, 16 * j + 8,
255                                                                    mvs[3].x, mvs[3].y, edged_width, quarterpel, reduced_resolution, rounding);                                                                    mvs[3].x, mvs[3].y, edged_width, quarterpel, reduced_resolution, rounding);
                 }  
256    
257                  if(quarterpel)                  if(quarterpel)
258                          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 268 
268    
269                  dy = (sum >> 3) + roundtab_76[sum & 0xf];                  dy = (sum >> 3) + roundtab_76[sum & 0xf];
270    
271                  /* uv-block-based compensation */  
272                    /* uv-block-based compensation
273                            XXX: rrv doesnt work with 16x16 block-based intepolation.
274                            we need to use 18x18-block interpolation */
275                  if (reduced_resolution)                  if (reduced_resolution)
276                  {                  {
277                          //XXX: todo                          const stride = edged_width/2;
278                            uint8_t * current, * reference;
279    
280                            current = cur->u + 16*j*stride + 16*i;
281                            reference = refv->u + 16*j*stride + 16*i;
282                            interpolate16x16_switch(refv->u, ref->u, 16*i, 16*j, dx, dy, stride, rounding);
283                            filter_18x18_to_8x8(dct_codes + 4*64, current, stride);
284                            filter_diff_18x18_to_8x8(dct_codes + 4*64, reference, stride);
285                            transfer16x16_copy(current, reference, stride);
286    
287                            current = cur->v + 16*j*stride + 16*i;
288                            reference = refv->v + 16*j*stride + 16*i;
289                            interpolate16x16_switch(refv->v, ref->v, 16*i, 16*j, dx, dy, stride, rounding);
290                            filter_18x18_to_8x8(dct_codes + 5*64, current, stride);
291                            filter_diff_18x18_to_8x8(dct_codes + 5*64, reference, stride);
292                            transfer16x16_copy(current, reference, stride);
293    
294                  }else{                  }else{
295                          transfer_8to16sub(&dct_codes[4 * 64],                          transfer_8to16sub(&dct_codes[4 * 64],
296                                                                  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.702

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4