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

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

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

revision 596, Sun Oct 13 13:51:10 2002 UTC revision 600, Thu Oct 17 13:27:22 2002 UTC
# Line 110  Line 110 
110    
111          data->temp[0] = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);          data->temp[0] = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
112    
113            if(data->quarterpel)
114                    t = d_mv_bits(2*x - data->predQMV.x, 2*y - data->predQMV.y, data->iFcode);
115            else
116          t = d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);          t = d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);
117    
118          data->temp[0] += lambda_vec16[data->iQuant] * t;          data->temp[0] += lambda_vec16[data->iQuant] * t;
119          data->temp[1] += lambda_vec8[data->iQuant] * t;          data->temp[1] += lambda_vec8[data->iQuant] * t;
120    
# Line 147  Line 151 
151                  default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break;                  default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break;
152          }          }
153    
154            if(data->quarterpel)
155                    sad = lambda_vec16[data->iQuant] *
156                          d_mv_bits(2*x - data->predQMV.x, 2*y - data->predQMV.y, data->iFcode);
157            else
158          sad = lambda_vec16[data->iQuant] *          sad = lambda_vec16[data->iQuant] *
159                          d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);                          d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);
160    
161          sad += sad16(data->Cur, Reference, data->iEdgedWidth, MV_MAX_ERROR);          sad += sad16(data->Cur, Reference, data->iEdgedWidth, MV_MAX_ERROR);
162    
163          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
# Line 486  Line 495 
495          }          }
496    
497          sad = sad8(data->Cur, Reference, data->iEdgedWidth);          sad = sad8(data->Cur, Reference, data->iEdgedWidth);
498    
499            if(data->quarterpel)
500                    sad += lambda_vec8[data->iQuant] * d_mv_bits(2*x - data->predQMV.x, 2*y - data->predQMV.y, data->iFcode);
501            else
502          sad += lambda_vec8[data->iQuant] * d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);          sad += lambda_vec8[data->iQuant] * d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);
503    
504          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
# Line 808  Line 821 
821          Data.temp = temp;          Data.temp = temp;
822          Data.iFcode = current->fcode;          Data.iFcode = current->fcode;
823          Data.rounding = pParam->m_rounding_type;          Data.rounding = pParam->m_rounding_type;
824            Data.quarterpel = pParam->m_quarterpel;
825    
826          if((qimage = (uint8_t *) malloc(32 * pParam->edged_width)) == NULL)          if((qimage = (uint8_t *) malloc(32 * pParam->edged_width)) == NULL)
827                  return 1; // allocate some mem for qpel interpolated blocks                  return 1; // allocate some mem for qpel interpolated blocks
# Line 994  Line 1008 
1008          for(i = 0;  i < 5; i++)          for(i = 0;  i < 5; i++)
1009                  Data->currentMV[i].x = Data->currentMV[i].y = 0;                  Data->currentMV[i].x = Data->currentMV[i].y = 0;
1010    
1011            if(Data->quarterpel)
1012                    i = d_mv_bits(Data->predQMV.x, Data->predQMV.y, Data->iFcode);
1013            else
1014          i = d_mv_bits(Data->predMV.x, Data->predMV.y, Data->iFcode);          i = d_mv_bits(Data->predMV.x, Data->predMV.y, Data->iFcode);
1015    
1016          Data->iMinSAD[0] = pMB->sad16 + lambda_vec16[iQuant] * i;          Data->iMinSAD[0] = pMB->sad16 + lambda_vec16[iQuant] * i;
1017          Data->iMinSAD[1] = pMB->sad8[0] + lambda_vec8[iQuant] * i;          Data->iMinSAD[1] = pMB->sad8[0] + lambda_vec8[iQuant] * i;
1018          Data->iMinSAD[2] = pMB->sad8[1];          Data->iMinSAD[2] = pMB->sad8[1];
# Line 1083  Line 1101 
1101                  else                  else
1102                          CheckCandidate = CheckCandidate16no4v_qpel;                          CheckCandidate = CheckCandidate16no4v_qpel;
1103    
                         Data->iMinSAD[0] -= lambda_vec16[iQuant] *  
                                 d_mv_bits(Data->predMV.x - Data->currentMV[0].x, Data->predMV.y - Data->currentMV[0].y, Data->iFcode);  
                         Data->iMinSAD[1] -= lambda_vec8[iQuant] *  
                                 d_mv_bits(Data->predMV.x - Data->currentMV[1].x, Data->predMV.y - Data->currentMV[1].y, Data->iFcode);  
   
                         Data->iMinSAD[0] += lambda_vec16[iQuant] *  
                                 d_mv_bits(Data->predQMV.x - Data->currentQMV[0].x, Data->predMV.y - Data->currentQMV[0].y, Data->iFcode);  
                         Data->iMinSAD[1] += lambda_vec8[iQuant] *  
                                 d_mv_bits(Data->predQMV.x - Data->currentQMV[1].x, Data->predMV.y - Data->currentQMV[1].y, Data->iFcode);  
   
1104                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1105                                  pParam->width, pParam->height, Data->iFcode, 0);                                    pParam->width, pParam->height, Data->iFcode, 0); // get real range
1106    
1107                  QuarterpelRefine(Data);                  QuarterpelRefine(Data);
1108          }          }
# Line 1155  Line 1163 
1163          Data->iMinSAD = OldData->iMinSAD + 1 + block;          Data->iMinSAD = OldData->iMinSAD + 1 + block;
1164          Data->currentMV = OldData->currentMV + 1 + block;          Data->currentMV = OldData->currentMV + 1 + block;
1165          Data->currentQMV = OldData->currentQMV + 1 + block;          Data->currentQMV = OldData->currentQMV + 1 + block;
1166            Data->quarterpel = OldData->quarterpel;
1167    
1168          if(pParam->m_quarterpel) {          if(Data->quarterpel) // add d_mv_bits[qpel] everywhere but not in 0 (it's already there)
1169                  //it is qpel. substract d_mv_bits[qpel] from 0, add d_mv_bits[hpel] everywhere          {
1170                  if (block == 0)                  if (block != 0)
1171                          *(Data->iMinSAD) -= lambda_vec8[Data->iQuant] *                          *(Data->iMinSAD) += lambda_vec8[Data->iQuant] *
1172                                                                          d_mv_bits(      Data->currentQMV->x - Data->predQMV.x,                                                                          d_mv_bits(      Data->currentQMV->x - Data->predQMV.x,
1173                                                                                                  Data->currentQMV->y - Data->predQMV.y,                                                                                                  Data->currentQMV->y - Data->predQMV.y,
1174                                                                                                  Data->iFcode);                                                                                                  Data->iFcode);
1175    
1176            } else // add d_mv_bits[hpel] everywhere but not in 0 (it's already there)
1177                    if (block != 0)
1178                  *(Data->iMinSAD) += lambda_vec8[Data->iQuant] *                  *(Data->iMinSAD) += lambda_vec8[Data->iQuant] *
1179                                                                          d_mv_bits(      Data->currentMV->x - Data->predMV.x,                                                                          d_mv_bits(      Data->currentMV->x - Data->predMV.x,
1180                                                                                                  Data->currentMV->y - Data->predMV.y,                                                                                                  Data->currentMV->y - Data->predMV.y,
1181                                                                                                  Data->iFcode);                                                                                                  Data->iFcode);
         } else //it is not qpel. add d_mv_bits[hpel] everywhere but not in 0 (it's already there)  
                 if (block != 0) *(Data->iMinSAD) += lambda_vec8[Data->iQuant] *  
                                                                         d_mv_bits(      Data->currentMV->x - Data->predMV.x,  
                                                                                                 Data->currentMV->y - Data->predMV.y,  
                                                                                                 Data->iFcode);  
   
1182    
1183          if (MotionFlags & (PMV_EXTSEARCH8|PMV_HALFPELREFINE8)) {          if (MotionFlags & (PMV_EXTSEARCH8|PMV_HALFPELREFINE8)) {
1184    
# Line 1200  Line 1205 
1205    
1206                          (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, 255);                          (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, 255);
1207    
1208                          if(*(Data->iMinSAD) < temp_sad) {                          if(*(Data->iMinSAD) < temp_sad) { //found a better match?
1209                                          Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector                                          Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1210                                          Data->currentQMV->y = 2 * Data->currentMV->y;                                          Data->currentQMV->y = 2 * Data->currentMV->y;
1211                          }                          }
# Line 1217  Line 1222 
1222                          }                          }
1223                  }                  }
1224    
1225                  if(pParam->m_quarterpel) {                  if((Data->quarterpel) && (!(Data->currentQMV->x & 1)) && (!(Data->currentQMV->y & 1)) &&
                         if((!(Data->currentQMV->x & 1)) && (!(Data->currentQMV->y & 1)) &&  
1226                                  (MotionFlags & PMV_QUARTERPELREFINE8)) {                                  (MotionFlags & PMV_QUARTERPELREFINE8)) {
1227    
1228                                  CheckCandidate = CheckCandidate8_qpel;                                  CheckCandidate = CheckCandidate8_qpel;
                         Data->iMinSAD[0] -= lambda_vec8[Data->iQuant] *  
                                 d_mv_bits(Data->predMV.x - Data->currentMV[0].x, Data->predMV.y - Data->currentMV[0].y, Data->iFcode);  
1229    
1230                          Data->iMinSAD[0] += lambda_vec8[Data->iQuant] *                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1231                                  d_mv_bits(Data->predQMV.x - Data->currentQMV[0].x, Data->predQMV.y - Data->currentQMV[0].y, Data->iFcode);                                  pParam->width, pParam->height, OldData->iFcode, 0); // get real range
1232    
1233                                  QuarterpelRefine(Data);                                  QuarterpelRefine(Data);
1234                          }                          }
1235                  }                  }
         }  
1236    
1237          if(pParam->m_quarterpel) {          if(pParam->m_quarterpel) {
1238                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predQMV.x;                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predQMV.x;
# Line 1245  Line 1246 
1246          pMB->mvs[block] = *(Data->currentMV);          pMB->mvs[block] = *(Data->currentMV);
1247          pMB->qmvs[block] = *(Data->currentQMV);          pMB->qmvs[block] = *(Data->currentQMV);
1248    
1249          pMB->sad8[block] =  4 * (*Data->iMinSAD);          pMB->sad8[block] =  4 * (*Data->iMinSAD); // Isibaar: why?
1250  }  }
1251    
1252  /* B-frames code starts here */  /* B-frames code starts here */
# Line 1773  Line 1774 
1774          Data->iMinSAD = OldData->iMinSAD + 1 + block;          Data->iMinSAD = OldData->iMinSAD + 1 + block;
1775          Data->currentMV = OldData->currentMV + 1 + block;          Data->currentMV = OldData->currentMV + 1 + block;
1776          Data->currentQMV = OldData->currentQMV + 1 + block;          Data->currentQMV = OldData->currentQMV + 1 + block;
1777            Data->quarterpel = OldData->quarterpel;
1778    
1779          if (block != 0) {          if (block != 0) {
1780                  if(pParam->m_quarterpel) {                  if(pParam->m_quarterpel) {
# Line 1789  Line 1791 
1791                  }                  }
1792          }          }
1793    
   
1794          Data->Ref = OldData->Ref + 8 * ((block&1) + pParam->edged_width*(block>>1));          Data->Ref = OldData->Ref + 8 * ((block&1) + pParam->edged_width*(block>>1));
1795          Data->RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1));          Data->RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1));
1796          Data->RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1));          Data->RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1));
# Line 1827  Line 1828 
1828                  }                  }
1829          }          }
1830    
1831          if(pParam->m_quarterpel) {          if((Data->quarterpel) && (!(Data->currentQMV->x & 1)) && (!(Data->currentQMV->y & 1)) &&
                 if((!(Data->currentQMV->x & 1)) && (!(Data->currentQMV->y & 1)) &&  
1832                          (MotionFlags & PMV_QUARTERPELREFINE8)) {                          (MotionFlags & PMV_QUARTERPELREFINE8)) {
1833    
1834                                  CheckCandidate = CheckCandidate8_qpel;                                  CheckCandidate = CheckCandidate8_qpel;
1835    
1836                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1837                                      pParam->width, pParam->height, OldData->iFcode, 0); // get real range
1838    
1839                                  QuarterpelRefine(Data);                                  QuarterpelRefine(Data);
1840                  }                  }
         }  
1841    
1842          if(pParam->m_quarterpel) {          if(pParam->m_quarterpel) {
1843                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predQMV.x;                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predQMV.x;
# Line 1856  Line 1860 
1860                                  const uint8_t * const pRefH,                                  const uint8_t * const pRefH,
1861                                  const uint8_t * const pRefV,                                  const uint8_t * const pRefV,
1862                                  const uint8_t * const pRefHV,                                  const uint8_t * const pRefHV,
1863                                    const uint8_t * const pRefQ,
1864                                  const IMAGE * const pCur,                                  const IMAGE * const pCur,
1865                                  const int x,                                  const int x,
1866                                  const int y,                                  const int y,
# Line 1873  Line 1878 
1878          int i, t;          int i, t;
1879          MainSearchFunc * MainSearchPtr;          MainSearchFunc * MainSearchPtr;
1880    
1881            Data->predQMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);
1882          Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);
1883          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1884                                  pParam->width, pParam->height, Data->iFcode, pParam->m_quarterpel);                                  pParam->width, pParam->height, Data->iFcode, pParam->m_quarterpel);
# Line 1882  Line 1888 
1888          Data->RefH = pRefH + (x + iEdgedWidth*y) * 16;          Data->RefH = pRefH + (x + iEdgedWidth*y) * 16;
1889          Data->RefV = pRefV + (x + iEdgedWidth*y) * 16;          Data->RefV = pRefV + (x + iEdgedWidth*y) * 16;
1890          Data->RefHV = pRefHV + (x + iEdgedWidth*y) * 16;          Data->RefHV = pRefHV + (x + iEdgedWidth*y) * 16;
1891            Data->RefQ = pRefQ;
1892    
1893          Data->iQuant = iQuant;          Data->iQuant = iQuant;
1894    
1895          if (!(MotionFlags & PMV_HALFPEL16)) {          if (!(MotionFlags & PMV_HALFPEL16)) {
# Line 1933  Line 1941 
1941          }          }
1942    
1943          if((pParam->m_quarterpel) && (MotionFlags & PMV_QUARTERPELREFINE16)) {          if((pParam->m_quarterpel) && (MotionFlags & PMV_QUARTERPELREFINE16)) {
   
1944                  if(inter4v)                  if(inter4v)
1945                          CheckCandidate = CheckCandidate16_qpel;                          CheckCandidate = CheckCandidate16_qpel;
1946                  else                  else
1947                          CheckCandidate = CheckCandidate16no4v_qpel;                          CheckCandidate = CheckCandidate16no4v_qpel;
1948    
1949                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1950                                      pParam->width, pParam->height, Data->iFcode, 0); // get real range
1951    
1952                  QuarterpelRefine(Data);                  QuarterpelRefine(Data);
1953          }          }
1954    
   
1955          if (inter4v) {          if (inter4v) {
1956                  SearchData Data8;                  SearchData Data8;
1957                  Data8.iFcode = Data->iFcode;                  Data8.iFcode = Data->iFcode;
# Line 1990  Line 1999 
1999          const IMAGE *const pRef = &reference->image;          const IMAGE *const pRef = &reference->image;
2000    
2001          uint32_t x, y;          uint32_t x, y;
2002          int8_t * qimage;          uint8_t *qimage;
2003          int32_t temp[5], quant = current->quant;          int32_t temp[5], quant = current->quant;
2004          int32_t iMinSAD[5];          int32_t iMinSAD[5];
2005          VECTOR currentMV[5];          VECTOR currentMV[5];
2006            VECTOR currentQMV[5];
2007          SearchData Data;          SearchData Data;
2008          Data.iEdgedWidth = pParam->edged_width;          Data.iEdgedWidth = pParam->edged_width;
2009          Data.currentMV = currentMV;          Data.currentMV = currentMV;
2010            Data.currentQMV = currentQMV;
2011          Data.iMinSAD = iMinSAD;          Data.iMinSAD = iMinSAD;
2012          Data.temp = temp;          Data.temp = temp;
2013          Data.iFcode = current->fcode;          Data.iFcode = current->fcode;
# Line 2007  Line 2018 
2018                                    // somehow this is dirty since I think we shouldn't use malloc outside                                    // somehow this is dirty since I think we shouldn't use malloc outside
2019                                    // encoder_create() - so please fix me!                                    // encoder_create() - so please fix me!
2020    
         Data.RefQ = qimage;  
   
2021          if (sadInit) (*sadInit) ();          if (sadInit) (*sadInit) ();
2022    
2023          for (y = 0; y < pParam->mb_height; y++) {          for (y = 0; y < pParam->mb_height; y++) {
# Line 2031  Line 2040 
2040                                          pMB->quant = quant;                                          pMB->quant = quant;
2041                                  }                                  }
2042    
2043                          SearchPhinted(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                          SearchPhinted(pRef->y, pRefH->y, pRefV->y, pRefHV->y, qimage, pCurrent, x,
2044                                                          y, current->motion_flags, pMB->quant,                                                          y, current->motion_flags, pMB->quant,
2045                                                          pParam, pMBs, current->global_flags & XVID_INTER4V, pMB,                                                          pParam, pMBs, current->global_flags & XVID_INTER4V, pMB,
2046                                                          &Data);                                                          &Data);

Legend:
Removed from v.596  
changed lines
  Added in v.600

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