[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 3, Fri Mar 8 02:46:11 2002 UTC revision 69, Tue Mar 26 11:16:08 2002 UTC
# Line 42  Line 42 
42    *                                                                            *    *                                                                            *
43    *  Revision history:                                                         *    *  Revision history:                                                         *
44    *                                                                            *    *                                                                            *
45      *  26.03.2002 interlacing support - moved transfers outside loops
46    *  22.12.2001 get_dc_scaler() moved to common.h    *  22.12.2001 get_dc_scaler() moved to common.h
47    *  19.11.2001 introduced coefficient thresholding (Isibaar)                  *    *  19.11.2001 introduced coefficient thresholding (Isibaar)                  *
48    *  17.11.2001 initial version                                                *    *  17.11.2001 initial version                                                *
# Line 68  Line 69 
69  /* this isnt pretty, but its better than 20 ifdefs */  /* this isnt pretty, but its better than 20 ifdefs */
70    
71  void MBTransQuantIntra(const MBParam *pParam,  void MBTransQuantIntra(const MBParam *pParam,
72                               MACROBLOCK * pMB,
73                         const uint32_t x_pos,                         const uint32_t x_pos,
74                         const uint32_t y_pos,                         const uint32_t y_pos,
75                         int16_t data[][64],                         int16_t data[][64],
# Line 84  Line 86 
86      pU_Cur = pCurrent->u + (y_pos << 3) * (stride >> 1) + (x_pos << 3);      pU_Cur = pCurrent->u + (y_pos << 3) * (stride >> 1) + (x_pos << 3);
87      pV_Cur = pCurrent->v + (y_pos << 3) * (stride >> 1) + (x_pos << 3);      pV_Cur = pCurrent->v + (y_pos << 3) * (stride >> 1) + (x_pos << 3);
88    
         for(i = 0; i < 6; i++) {  
                 uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);  
   
89                  start_timer();                  start_timer();
   
                 switch(i) {  
                 case 0 :  
90                          transfer_8to16copy(data[0], pY_Cur, stride);                          transfer_8to16copy(data[0], pY_Cur, stride);
                         break;  
                 case 1 :  
91                          transfer_8to16copy(data[1], pY_Cur + 8, stride);                          transfer_8to16copy(data[1], pY_Cur + 8, stride);
                         break;  
                 case 2 :  
92                      transfer_8to16copy(data[2], pY_Cur + 8 * stride, stride);                      transfer_8to16copy(data[2], pY_Cur + 8 * stride, stride);
                         break;  
                 case 3 :  
93                          transfer_8to16copy(data[3], pY_Cur + 8 * stride + 8, stride);                          transfer_8to16copy(data[3], pY_Cur + 8 * stride + 8, stride);
                         break;  
                 case 4 :  
94                          transfer_8to16copy(data[4], pU_Cur, stride / 2);                          transfer_8to16copy(data[4], pU_Cur, stride / 2);
                         break;  
                 case 5 :  
95                          transfer_8to16copy(data[5], pV_Cur, stride / 2);                          transfer_8to16copy(data[5], pV_Cur, stride / 2);
                         break;  
                 }  
96                  stop_transfer_timer();                  stop_transfer_timer();
97    
98                  start_timer();                  start_timer();
99            pMB->field_dct = 0;
100            if (pParam->global_flags & XVID_INTERLACING)
101            {
102                    pMB->field_dct = MBDecideFieldDCT(data);
103            }
104            stop_interlacing_timer();
105    
106            for(i = 0; i < 6; i++)
107            {
108                    uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
109    
110                    start_timer();
111                  fdct(data[i]);                  fdct(data[i]);
112                  stop_dct_timer();                  stop_dct_timer();
113    
# Line 139  Line 135 
135                  start_timer();                  start_timer();
136                  idct(data[i]);                  idct(data[i]);
137                  stop_idct_timer();                  stop_idct_timer();
138        }
139    
140                  start_timer();                  start_timer();
141            if (pMB->field_dct)
142            {
143                    MBFieldToFrame(data);
144            }
145            stop_interlacing_timer();
146    
147                  switch(i) {          start_timer();
                 case 0:  
148                          transfer_16to8copy(pY_Cur, data[0], stride);                          transfer_16to8copy(pY_Cur, data[0], stride);
                         break;  
                 case 1:  
149                          transfer_16to8copy(pY_Cur + 8, data[1], stride);                          transfer_16to8copy(pY_Cur + 8, data[1], stride);
                         break;  
                 case 2:  
150                          transfer_16to8copy(pY_Cur + 8 * stride, data[2], stride);                          transfer_16to8copy(pY_Cur + 8 * stride, data[2], stride);
                         break;  
                 case 3:  
151                          transfer_16to8copy(pY_Cur + 8 + 8 * stride, data[3], stride);                          transfer_16to8copy(pY_Cur + 8 + 8 * stride, data[3], stride);
                         break;  
                 case 4:  
152                          transfer_16to8copy(pU_Cur, data[4], stride / 2);                          transfer_16to8copy(pU_Cur, data[4], stride / 2);
                         break;  
                 case 5:  
153                          transfer_16to8copy(pV_Cur, data[5], stride / 2);                          transfer_16to8copy(pV_Cur, data[5], stride / 2);
                         break;  
                 }  
154                  stop_transfer_timer();                  stop_transfer_timer();
155      }      }
 }  
156    
157    
158  uint8_t MBTransQuantInter(const MBParam *pParam,  uint8_t MBTransQuantInter(const MBParam *pParam,
159                                            MACROBLOCK * pMB,
160                                          const uint32_t x_pos, const uint32_t y_pos,                                          const uint32_t x_pos, const uint32_t y_pos,
161                                          int16_t data[][64],                                          int16_t data[][64],
162                                          int16_t qcoeff[][64],                                          int16_t qcoeff[][64],
# Line 175  Line 164 
164    
165  {  {
166          const uint32_t stride = pParam->edged_width;          const uint32_t stride = pParam->edged_width;
167      uint8_t i;      uint32_t i;
168      uint8_t iQuant = pParam->quant;      uint32_t iQuant = pParam->quant;
169          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
170      uint8_t cbp = 0;      uint8_t cbp = 0;
171          uint32_t sum;          uint32_t sum;
# Line 185  Line 174 
174      pU_Cur = pCurrent->u + (y_pos << 3) * (stride >> 1) + (x_pos << 3);      pU_Cur = pCurrent->u + (y_pos << 3) * (stride >> 1) + (x_pos << 3);
175      pV_Cur = pCurrent->v + (y_pos << 3) * (stride >> 1) + (x_pos << 3);      pV_Cur = pCurrent->v + (y_pos << 3) * (stride >> 1) + (x_pos << 3);
176    
177      for(i = 0; i < 6; i++) {          start_timer();
178            pMB->field_dct = 0;
179            if (pParam->global_flags & XVID_INTERLACING)
180            {
181                    pMB->field_dct = MBDecideFieldDCT(data);
182            }
183            stop_interlacing_timer();
184    
185        for(i = 0; i < 6; i++)
186            {
187                  /*                  /*
188                  no need to transfer 8->16-bit                  no need to transfer 8->16-bit
189                  (this is performed already in motion compensation)                  (this is performed already in motion compensation)
# Line 227  Line 225 
225                          start_timer();                          start_timer();
226                          idct(data[i]);                          idct(data[i]);
227                          stop_idct_timer();                          stop_idct_timer();
228                    }
229            }
230    
231                          start_timer();                          start_timer();
232            if (pMB->field_dct)
233            {
234                    MBFieldToFrame(data);
235            }
236            stop_interlacing_timer();
237    
238                          switch(i) {          start_timer();
239                          case 0:          if (cbp & 32)
240                                  transfer_16to8add(pY_Cur, data[0], stride);                                  transfer_16to8add(pY_Cur, data[0], stride);
241                                  break;          if (cbp & 16)
                         case 1:  
242                                  transfer_16to8add(pY_Cur + 8, data[1], stride);                                  transfer_16to8add(pY_Cur + 8, data[1], stride);
243                                  break;          if (cbp & 8)
                         case 2:  
244                                  transfer_16to8add(pY_Cur + 8 * stride, data[2], stride);                                  transfer_16to8add(pY_Cur + 8 * stride, data[2], stride);
245                                  break;          if (cbp & 4)
                         case 3:  
246                                  transfer_16to8add(pY_Cur + 8 + 8 * stride, data[3], stride);                                  transfer_16to8add(pY_Cur + 8 + 8 * stride, data[3], stride);
247                                  break;          if (cbp & 2)
                         case 4:  
248                                  transfer_16to8add(pU_Cur, data[4], stride / 2);                                  transfer_16to8add(pU_Cur, data[4], stride / 2);
249                                  break;          if (cbp & 1)
                         case 5:  
250                                  transfer_16to8add(pV_Cur, data[5], stride / 2);                                  transfer_16to8add(pV_Cur, data[5], stride / 2);
                                 break;  
                         }  
251                          stop_transfer_timer();                          stop_transfer_timer();
252    
253        return cbp;
254                  }                  }
255    
256    
257    /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */
258    
259    #define ABS(X) (X)<0 ? -(X) : (X)
260    
261    uint32_t MBDecideFieldDCT(int16_t data[][64])
262    {
263            const uint8_t blocks[] = {0, 0, 0, 0, 2, 2, 2, 2};
264            const uint8_t lines[] = {0, 16, 32, 48, 0, 16, 32, 48};
265    
266            int frame = 0, field = 0;
267            int i, j;
268    
269            for (i=0 ; i<7 ; ++i)
270            {
271                    for (j=0 ; j<8 ; ++j)
272                    {
273                            frame += ABS(data[0][(i+1)*8 + j] - data[0][i*8 + j]);
274                            frame += ABS(data[1][(i+1)*8 + j] - data[1][i*8 + j]);
275                            frame += ABS(data[2][(i+1)*8 + j] - data[2][i*8 + j]);
276                            frame += ABS(data[3][(i+1)*8 + j] - data[3][i*8 + j]);
277    
278                            field += ABS(data[blocks[i+1]][lines[i+1] + j] - data[blocks[i]][lines[i] + j]);
279                            field += ABS(data[blocks[i+1]][lines[i+1] + 8 + j] - data[blocks[i]][lines[i] + 8 + j]);
280                            field += ABS(data[blocks[i+1]+1][lines[i+1] + j] - data[blocks[i]+1][lines[i] + j]);
281                            field += ABS(data[blocks[i+1]+1][lines[i+1] + 8 + j] - data[blocks[i]+1][lines[i] + 8 + j]);
282          }          }
283      return cbp;          }
284    
285            if (frame > field)
286            {
287                    MBFrameToField(data);
288            }
289    
290            return (frame > field);
291    }
292    
293    
294    /* deinterlace Y blocks vertically */
295    
296    #define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))
297    #define LINE(X,Y) &data[X][Y*8]
298    
299    void MBFrameToField(int16_t data[][64])
300    {
301            int16_t tmp[8];
302    
303            /* left blocks */
304    
305            // 1=2, 2=4, 4=8, 8=1
306            MOVLINE(tmp,            LINE(0,1));
307            MOVLINE(LINE(0,1),      LINE(0,2));
308            MOVLINE(LINE(0,2),      LINE(0,4));
309            MOVLINE(LINE(0,4),      LINE(2,0));
310            MOVLINE(LINE(2,0),      tmp);
311    
312            // 3=6, 6=12, 12=9, 9=3
313            MOVLINE(tmp,            LINE(0,3));
314            MOVLINE(LINE(0,3),      LINE(0,6));
315            MOVLINE(LINE(0,6),      LINE(2,4));
316            MOVLINE(LINE(2,4),      LINE(2,1));
317            MOVLINE(LINE(2,1),      tmp);
318    
319            // 5=10, 10=5
320            MOVLINE(tmp,            LINE(0,5));
321            MOVLINE(LINE(0,5),      LINE(2,2));
322            MOVLINE(LINE(2,2),      tmp);
323    
324            // 7=14, 14=13, 13=11, 11=7
325            MOVLINE(tmp,            LINE(0,7));
326            MOVLINE(LINE(0,7),      LINE(2,6));
327            MOVLINE(LINE(2,6),      LINE(2,5));
328            MOVLINE(LINE(2,5),      LINE(2,3));
329            MOVLINE(LINE(2,3),      tmp);
330    
331            /* right blocks */
332    
333            // 1=2, 2=4, 4=8, 8=1
334            MOVLINE(tmp,            LINE(1,1));
335            MOVLINE(LINE(1,1),      LINE(1,2));
336            MOVLINE(LINE(1,2),      LINE(1,4));
337            MOVLINE(LINE(1,4),      LINE(3,0));
338            MOVLINE(LINE(3,0),      tmp);
339    
340            // 3=6, 6=12, 12=9, 9=3
341            MOVLINE(tmp,            LINE(1,3));
342            MOVLINE(LINE(1,3),      LINE(1,6));
343            MOVLINE(LINE(1,6),      LINE(3,4));
344            MOVLINE(LINE(3,4),      LINE(3,1));
345            MOVLINE(LINE(3,1),      tmp);
346    
347            // 5=10, 10=5
348            MOVLINE(tmp,            LINE(1,5));
349            MOVLINE(LINE(1,5),      LINE(3,2));
350            MOVLINE(LINE(3,2),      tmp);
351    
352            // 7=14, 14=13, 13=11, 11=7
353            MOVLINE(tmp,            LINE(1,7));
354            MOVLINE(LINE(1,7),      LINE(3,6));
355            MOVLINE(LINE(3,6),      LINE(3,5));
356            MOVLINE(LINE(3,5),      LINE(3,3));
357            MOVLINE(LINE(3,3),      tmp);
358    }
359    
360    
361    /* interlace Y blocks vertically */
362    
363    void MBFieldToFrame(int16_t data[][64])
364    {
365            uint16_t tmp[8];
366    
367            /* left blocks */
368    
369            // 1=8, 8=4, 4=2, 2=1
370            MOVLINE(tmp,            LINE(0,1));
371            MOVLINE(LINE(0,1),      LINE(2,0));
372            MOVLINE(LINE(2,0),      LINE(0,4));
373            MOVLINE(LINE(0,4),      LINE(0,2));
374            MOVLINE(LINE(0,2),      tmp);
375    
376            // 3=9, 9=12, 12=6, 6=3
377            MOVLINE(tmp,            LINE(0,3));
378            MOVLINE(LINE(0,3),      LINE(2,1));
379            MOVLINE(LINE(2,1),      LINE(2,4));
380            MOVLINE(LINE(2,4),      LINE(0,6));
381            MOVLINE(LINE(0,6),      tmp);
382    
383            // 5=10, 10=5
384            MOVLINE(tmp,            LINE(0,5));
385            MOVLINE(LINE(0,5),      LINE(2,2));
386            MOVLINE(LINE(2,2),      tmp);
387    
388            // 7=11, 11=13, 13=14, 14=7
389            MOVLINE(tmp,            LINE(0,7));
390            MOVLINE(LINE(0,7),      LINE(2,3));
391            MOVLINE(LINE(2,3),      LINE(2,5));
392            MOVLINE(LINE(2,5),      LINE(2,6));
393            MOVLINE(LINE(2,6),      tmp);
394    
395            /* right blocks */
396    
397            // 1=8, 8=4, 4=2, 2=1
398            MOVLINE(tmp,            LINE(1,1));
399            MOVLINE(LINE(1,1),      LINE(3,0));
400            MOVLINE(LINE(3,0),      LINE(1,4));
401            MOVLINE(LINE(1,4),      LINE(1,2));
402            MOVLINE(LINE(1,2),      tmp);
403    
404            // 3=9, 9=12, 12=6, 6=3
405            MOVLINE(tmp,            LINE(1,3));
406            MOVLINE(LINE(1,3),      LINE(3,1));
407            MOVLINE(LINE(3,1),      LINE(3,4));
408            MOVLINE(LINE(3,4),      LINE(1,6));
409            MOVLINE(LINE(1,6),      tmp);
410    
411            // 5=10, 10=5
412            MOVLINE(tmp,            LINE(1,5));
413            MOVLINE(LINE(1,5),      LINE(3,2));
414            MOVLINE(LINE(3,2),      tmp);
415    
416            // 7=11, 11=13, 13=14, 14=7
417            MOVLINE(tmp,            LINE(1,7));
418            MOVLINE(LINE(1,7),      LINE(3,3));
419            MOVLINE(LINE(3,3),      LINE(3,5));
420            MOVLINE(LINE(3,5),      LINE(3,6));
421            MOVLINE(LINE(3,6),      tmp);
422  }  }

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

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