[svn] / branches / dev-api-4 / xvidcore / src / utils / mbtransquant.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/src/utils/mbtransquant.c

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

revision 69, Tue Mar 26 11:16:08 2002 UTC revision 78, Thu Mar 28 20:57:25 2002 UTC
# Line 49  Line 49 
49    *                                                                            *    *                                                                            *
50    ******************************************************************************/    ******************************************************************************/
51    
52    #include <string.h>
53    
54  #include "../portab.h"  #include "../portab.h"
55  #include "mbfunctions.h"  #include "mbfunctions.h"
56    
# Line 72  Line 74 
74                             MACROBLOCK * pMB,                             MACROBLOCK * pMB,
75                         const uint32_t x_pos,                         const uint32_t x_pos,
76                         const uint32_t y_pos,                         const uint32_t y_pos,
77                         int16_t data[][64],                         int16_t data[6*64],
78                             int16_t qcoeff[][64],                         int16_t qcoeff[6*64],
79                             IMAGE * const pCurrent)                             IMAGE * const pCurrent)
80    
81  {  {
82    
83          const uint32_t stride = pParam->edged_width;          const uint32_t stride = pParam->edged_width;
84          uint32_t i;          uint32_t i;
85          uint32_t iQuant = pParam->quant;          uint32_t iQuant = pParam->quant;
# Line 87  Line 90 
90      pV_Cur = pCurrent->v + (y_pos << 3) * (stride >> 1) + (x_pos << 3);      pV_Cur = pCurrent->v + (y_pos << 3) * (stride >> 1) + (x_pos << 3);
91    
92          start_timer();          start_timer();
93          transfer_8to16copy(data[0], pY_Cur, stride);          transfer_8to16copy(&data[0*64], pY_Cur, stride);
94          transfer_8to16copy(data[1], pY_Cur + 8, stride);          transfer_8to16copy(&data[1*64], pY_Cur + 8, stride);
95      transfer_8to16copy(data[2], pY_Cur + 8 * stride, stride);          transfer_8to16copy(&data[2*64], pY_Cur + 8 * stride, stride);
96          transfer_8to16copy(data[3], pY_Cur + 8 * stride + 8, stride);          transfer_8to16copy(&data[3*64], pY_Cur + 8 * stride + 8, stride);
97          transfer_8to16copy(data[4], pU_Cur, stride / 2);          transfer_8to16copy(&data[4*64], pU_Cur, stride / 2);
98          transfer_8to16copy(data[5], pV_Cur, stride / 2);          transfer_8to16copy(&data[5*64], pV_Cur, stride / 2);
99          stop_transfer_timer();          stop_transfer_timer();
100    
101          start_timer();          start_timer();
# Line 108  Line 111 
111                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
112    
113                  start_timer();                  start_timer();
114                  fdct(data[i]);                  fdct(&data[i*64]);
115                  stop_dct_timer();                  stop_dct_timer();
116    
117                  if (pParam->quant_type == H263_QUANT)                  if (pParam->quant_type == H263_QUANT)
118                  {                  {
119                          start_timer();                          start_timer();
120                          quant_intra(qcoeff[i], data[i], iQuant, iDcScaler);                          quant_intra(&qcoeff[i*64], &data[i*64], iQuant, iDcScaler);
121                          stop_quant_timer();                          stop_quant_timer();
122    
123                          start_timer();                          start_timer();
124                          dequant_intra(data[i], qcoeff[i], iQuant, iDcScaler);                          dequant_intra(&data[i*64], &qcoeff[i*64], iQuant, iDcScaler);
125                          stop_iquant_timer();                          stop_iquant_timer();
126                  }                  }
127                  else                  else
128                  {                  {
129                          start_timer();                          start_timer();
130                          quant4_intra(qcoeff[i], data[i], iQuant, iDcScaler);                          quant4_intra(&qcoeff[i*64], &data[i*64], iQuant, iDcScaler);
131                          stop_quant_timer();                          stop_quant_timer();
132    
133                          start_timer();                          start_timer();
134                          dequant4_intra(data[i], qcoeff[i], iQuant, iDcScaler);                          dequant4_intra(&data[i*64], &qcoeff[i*64], iQuant, iDcScaler);
135                          stop_iquant_timer();                          stop_iquant_timer();
136                  }                  }
137    
138                  start_timer();                  start_timer();
139                  idct(data[i]);                  idct(&data[i*64]);
140                  stop_idct_timer();                  stop_idct_timer();
141      }      }
142    
# Line 145  Line 148 
148          stop_interlacing_timer();          stop_interlacing_timer();
149    
150          start_timer();          start_timer();
151          transfer_16to8copy(pY_Cur, data[0], stride);          transfer_16to8copy(pY_Cur,                  &data[0*64], stride);
152          transfer_16to8copy(pY_Cur + 8, data[1], stride);          transfer_16to8copy(pY_Cur + 8,              &data[1*64], stride);
153          transfer_16to8copy(pY_Cur + 8 * stride, data[2], stride);          transfer_16to8copy(pY_Cur + 8 * stride,     &data[2*64], stride);
154          transfer_16to8copy(pY_Cur + 8 + 8 * stride, data[3], stride);          transfer_16to8copy(pY_Cur + 8 + 8 * stride, &data[3*64], stride);
155          transfer_16to8copy(pU_Cur, data[4], stride / 2);          transfer_16to8copy(pU_Cur,                  &data[4*64], stride / 2);
156          transfer_16to8copy(pV_Cur, data[5], stride / 2);          transfer_16to8copy(pV_Cur,                  &data[5*64], stride / 2);
157          stop_transfer_timer();          stop_transfer_timer();
158    
159  }  }
160    
161    
162  uint8_t MBTransQuantInter(const MBParam *pParam,  uint8_t MBTransQuantInter(const MBParam *pParam,
163                                          MACROBLOCK * pMB,                                          MACROBLOCK * pMB,
164                                          const uint32_t x_pos, const uint32_t y_pos,                                          const uint32_t x_pos, const uint32_t y_pos,
165                                          int16_t data[][64],                            int16_t data[6*64],
166                                          int16_t qcoeff[][64],                            int16_t qcoeff[6*64],
167                                          IMAGE * const pCurrent)                                          IMAGE * const pCurrent)
168    
169  {  {
170    
171          const uint32_t stride = pParam->edged_width;          const uint32_t stride = pParam->edged_width;
172      uint32_t i;      uint32_t i;
173      uint32_t iQuant = pParam->quant;      uint32_t iQuant = pParam->quant;
# Line 185  Line 190 
190      for(i = 0; i < 6; i++)      for(i = 0; i < 6; i++)
191          {          {
192                  /*                  /*
193                  no need to transfer 8->16-bit                   *  no need to transfer 8->16-bit
194                  (this is performed already in motion compensation)                   * (this is performed already in motion compensation)
195                  */                  */
196                  start_timer();                  start_timer();
197                  fdct(data[i]);                  fdct(&data[i*64]);
198                  stop_dct_timer();                  stop_dct_timer();
199    
200                  if (pParam->quant_type == 0)                  if (pParam->quant_type == 0)
201                  {                  {
202                          start_timer();                          start_timer();
203                          sum = quant_inter(qcoeff[i], data[i], iQuant);                          sum = quant_inter(&qcoeff[i*64], &data[i*64], iQuant);
204                          stop_quant_timer();                          stop_quant_timer();
205                  }                  }
206                  else                  else
207                  {                  {
208                          start_timer();                          start_timer();
209                          sum = quant4_inter(qcoeff[i], data[i], iQuant);                          sum = quant4_inter(&qcoeff[i*64], &data[i*64], iQuant);
210                          stop_quant_timer();                          stop_quant_timer();
211                  }                  }
212    
# Line 210  Line 215 
215                          if (pParam->quant_type == H263_QUANT)                          if (pParam->quant_type == H263_QUANT)
216                          {                          {
217                                  start_timer();                                  start_timer();
218                                  dequant_inter(data[i], qcoeff[i], iQuant);                                  dequant_inter(&data[i*64], &qcoeff[i*64], iQuant);
219                                  stop_iquant_timer();                                  stop_iquant_timer();
220                          }                          }
221                          else                          else
222                          {                          {
223                                  start_timer();                                  start_timer();
224                                  dequant4_inter(data[i], qcoeff[i], iQuant);                                  dequant4_inter(&data[i*64], &qcoeff[i*64], iQuant);
225                                  stop_iquant_timer();                                  stop_iquant_timer();
226                          }                          }
227    
228                          cbp |= 1 << (5 - i);                          cbp |= 1 << (5 - i);
229    
230                          start_timer();                          start_timer();
231                          idct(data[i]);                          idct(&data[i*64]);
232                          stop_idct_timer();                          stop_idct_timer();
233                  }                  }
234          }          }
# Line 237  Line 242 
242    
243          start_timer();          start_timer();
244          if (cbp & 32)          if (cbp & 32)
245                  transfer_16to8add(pY_Cur, data[0], stride);                  transfer_16to8add(pY_Cur,                  &data[0*64], stride);
246          if (cbp & 16)          if (cbp & 16)
247                  transfer_16to8add(pY_Cur + 8, data[1], stride);                  transfer_16to8add(pY_Cur + 8,              &data[1*64], stride);
248          if (cbp & 8)          if (cbp & 8)
249                  transfer_16to8add(pY_Cur + 8 * stride, data[2], stride);                  transfer_16to8add(pY_Cur + 8 * stride,     &data[2*64], stride);
250          if (cbp & 4)          if (cbp & 4)
251                  transfer_16to8add(pY_Cur + 8 + 8 * stride, data[3], stride);                  transfer_16to8add(pY_Cur + 8 + 8 * stride, &data[3*64], stride);
252          if (cbp & 2)          if (cbp & 2)
253                  transfer_16to8add(pU_Cur, data[4], stride / 2);                  transfer_16to8add(pU_Cur,                  &data[4*64], stride / 2);
254          if (cbp & 1)          if (cbp & 1)
255                  transfer_16to8add(pV_Cur, data[5], stride / 2);                  transfer_16to8add(pV_Cur,                  &data[5*64], stride / 2);
256          stop_transfer_timer();          stop_transfer_timer();
257    
258      return cbp;      return cbp;
259    
260  }  }
261    
262    
# Line 258  Line 264 
264    
265  #define ABS(X) (X)<0 ? -(X) : (X)  #define ABS(X) (X)<0 ? -(X) : (X)
266    
267  uint32_t MBDecideFieldDCT(int16_t data[][64])  uint32_t MBDecideFieldDCT(int16_t data[6*64])
268  {  {
269          const uint8_t blocks[] = {0, 0, 0, 0, 2, 2, 2, 2};  
270            const uint8_t blocks[] = {0*64, 0*64, 0*64, 0*64, 2*64, 2*64, 2*64, 2*64};
271          const uint8_t lines[] = {0, 16, 32, 48, 0, 16, 32, 48};          const uint8_t lines[] = {0, 16, 32, 48, 0, 16, 32, 48};
272    
273          int frame = 0, field = 0;          int frame = 0, field = 0;
# Line 270  Line 277 
277          {          {
278                  for (j=0 ; j<8 ; ++j)                  for (j=0 ; j<8 ; ++j)
279                  {                  {
280                          frame += ABS(data[0][(i+1)*8 + j] - data[0][i*8 + j]);                          frame += ABS(data[0*64 + (i+1)*8 + j] - data[0*64 + i*8 + j]);
281                          frame += ABS(data[1][(i+1)*8 + j] - data[1][i*8 + j]);                          frame += ABS(data[1*64 + (i+1)*8 + j] - data[1*64 + i*8 + j]);
282                          frame += ABS(data[2][(i+1)*8 + j] - data[2][i*8 + j]);                          frame += ABS(data[2*64 + (i+1)*8 + j] - data[2*64 + i*8 + j]);
283                          frame += ABS(data[3][(i+1)*8 + j] - data[3][i*8 + j]);                          frame += ABS(data[3*64 + (i+1)*8 + j] - data[3*64 + i*8 + j]);
284    
285                          field += ABS(data[blocks[i+1]][lines[i+1] + j] - data[blocks[i]][lines[i] + j]);                          field += ABS(data[blocks[i+1] + lines[i+1] + j] -\
286                          field += ABS(data[blocks[i+1]][lines[i+1] + 8 + j] - data[blocks[i]][lines[i] + 8 + j]);                                       data[blocks[i  ] + lines[i  ] + j]);
287                          field += ABS(data[blocks[i+1]+1][lines[i+1] + j] - data[blocks[i]+1][lines[i] + j]);                          field += ABS(data[blocks[i+1] + lines[i+1] + 8 + j] -\
288                          field += ABS(data[blocks[i+1]+1][lines[i+1] + 8 + j] - data[blocks[i]+1][lines[i] + 8 + j]);                                       data[blocks[i  ] + lines[i  ] + 8 + j]);
289                            field += ABS(data[blocks[i+1] + 64 + lines[i+1] + j] -\
290                                         data[blocks[i  ] + 64 + lines[i  ] + j]);
291                            field += ABS(data[blocks[i+1] + 64 + lines[i+1] + 8 + j] -\
292                                         data[blocks[i  ] + 64 + lines[i  ] + 8 + j]);
293                  }                  }
294          }          }
295    
# Line 294  Line 305 
305  /* deinterlace Y blocks vertically */  /* deinterlace Y blocks vertically */
306    
307  #define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))  #define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))
308  #define LINE(X,Y) &data[X][Y*8]  #define LINE(X,Y)    &data[X*64 + Y*8]
309    
310  void MBFrameToField(int16_t data[][64])  void MBFrameToField(int16_t data[6*64])
311  {  {
312          int16_t tmp[8];          int16_t tmp[8];
313    
# Line 360  Line 371 
371    
372  /* interlace Y blocks vertically */  /* interlace Y blocks vertically */
373    
374  void MBFieldToFrame(int16_t data[][64])  void MBFieldToFrame(int16_t data[6*64])
375  {  {
376          uint16_t tmp[8];          uint16_t tmp[8];
377    

Legend:
Removed from v.69  
changed lines
  Added in v.78

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