[cvs] / xvidcore / src / utils / mbtransquant.c Repository:
ViewVC logotype

Diff of /xvidcore/src/utils/mbtransquant.c

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

revision 1.20, Tue Nov 26 23:44:11 2002 UTC revision 1.21.2.2, Mon Mar 10 00:38:49 2003 UTC
# Line 1  Line 1 
1  /*****************************************************************************   /******************************************************************************
2   *    *                                                                            *
3   *  XVID MPEG-4 VIDEO CODEC    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
4   *  - MacroBlock transfer and quantization -    *                                                                            *
5   *    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
6   *  Copyright(C) 2002-2001 Christoph Lampert <gruel@web.de>    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
7   *               2002-2001 Michael Militzer <isibaar@xvid.org>    *  software module in hardware or software products are advised that its     *
8   *               2002-2001 Peter Ross <pross@xvid.org>    *  use may infringe existing patents or copyrights, and any such use         *
9   *               2002      Daniel Smith <danielsmith@astroboymail.com>    *  would be at such party's own risk.  The original developer of this        *
10   *    *  software module and his/her company, and subsequent editors and their     *
11   *  This file is part of XviD, a free MPEG-4 video encoder/decoder    *  companies, will have no liability for use of this software or             *
12   *    *  modifications or derivatives thereof.                                     *
13   *  XviD is free software; you can redistribute it and/or modify it    *                                                                            *
14   *  under the terms of the GNU General Public License as published by    *  XviD is free software; you can redistribute it and/or modify it           *
15   *  the Free Software Foundation; either version 2 of the License, or    *  under the terms of the GNU General Public License as published by         *
16   *  (at your option) any later version.    *  the Free Software Foundation; either version 2 of the License, or         *
17   *    *  (at your option) any later version.                                       *
18   *  This program is distributed in the hope that it will be useful,    *                                                                            *
19   *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *  XviD is distributed in the hope that it will be useful, but               *
20   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
21   *  GNU General Public License for more details.    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
22   *    *  GNU General Public License for more details.                              *
23   *  You should have received a copy of the GNU General Public License    *                                                                            *
24   *  along with this program; if not, write to the Free Software    *  You should have received a copy of the GNU General Public License         *
25   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA    *  along with this program; if not, write to the Free Software               *
26   *    *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
27   *  Under section 8 of the GNU General Public License, the copyright    *                                                                            *
28   *  holders of XVID explicitly forbid distribution in the following    ******************************************************************************/
29   *  countries:  
30   *   /******************************************************************************
31   *    - Japan    *                                                                            *
32   *    - United States of America    *  mbtransquant.c                                                            *
33   *    *                                                                            *
34   *  Linking XviD statically or dynamically with other modules is making a    *  Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au>                    *
35   *  combined work based on XviD.  Thus, the terms and conditions of the    *  Copyright (C) 2001 - Michael Militzer <isibaar@xvid.org>                  *
36   *  GNU General Public License cover the whole combination.    *                                                                            *
37   *    *  For more information visit the XviD homepage: http://www.xvid.org         *
38   *  As a special exception, the copyright holders of XviD give you    *                                                                            *
39   *  permission to link XviD with independent modules that communicate with    ******************************************************************************/
40   *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the  
41   *  license terms of these independent modules, and to copy and distribute   /******************************************************************************
42   *  the resulting combined work under terms of your choice, provided that    *                                                                            *
43   *  every copy of the combined work is accompanied by a complete copy of    *  Revision history:                                                         *
44   *  the source code of XviD (the version of XviD used to produce the    *                                                                            *
45   *  combined work), being distributed under the terms of the GNU General    *  29.03.2002 interlacing speedup - used transfer strides instead of             *
46   *  Public License plus this exception.  An independent module is a module    *             manual field-to-frame conversion                                                           *
47   *  which is not derived from or based on XviD.    *  26.03.2002 interlacing support - moved transfers outside loops                        *
48   *    *  22.12.2001 get_dc_scaler() moved to common.h                                                          *
49   *  Note that people who make modified versions of XviD are not obligated    *  19.11.2001 introduced coefficient thresholding (Isibaar)                  *
50   *  to grant this special exception for their modified versions; it is    *  17.11.2001 initial version                                                *
51   *  their choice whether to do so.  The GNU General Public License gives    *                                                                            *
52   *  permission to release a modified version without this exception; this    ******************************************************************************/
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
  *  
  * $Id$  
  *  
  ****************************************************************************/  
53    
54  #include <string.h>  #include <string.h>
55    
# Line 71  Line 65 
65  #include "../quant/quant_h263.h"  #include "../quant/quant_h263.h"
66  #include "../encoder.h"  #include "../encoder.h"
67    
68  #define MIN(X, Y) ((X)<(Y)?(X):(Y))  #include "../image/reduced.h"
 #define MAX(X, Y) ((X)>(Y)?(X):(Y))  
69    
70  #define TOOSMALL_LIMIT 3                /* skip blocks having a coefficient sum below this value */  MBFIELDTEST_PTR MBFieldTest;
71    
72  /* this isnt pretty, but its better than 20 ifdefs */  #define TOOSMALL_LIMIT  1       /* skip blocks having a coefficient sum below this value */
73    
74  void  void
75  MBTransQuantIntra(const MBParam * pParam,  MBTransQuantIntra(const MBParam * pParam,
# Line 90  Line 83 
83    
84          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
85          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
86          uint32_t next_block = stride * 8;          uint32_t next_block = stride * ((frame->vop_flags & XVID_REDUCED)?16:8);
87          uint32_t i;          uint32_t i;
88          uint32_t iQuant = frame->quant;          uint32_t iQuant = frame->quant;
89          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
90          IMAGE *pCurrent = &frame->image;          IMAGE *pCurrent = &frame->image;
91    
92            start_timer();
93            if ((frame->vop_flags & XVID_REDUCED))
94            {
95                    pY_Cur = pCurrent->y + (y_pos << 5) * stride + (x_pos << 5);
96                    pU_Cur = pCurrent->u + (y_pos << 4) * stride2 + (x_pos << 4);
97                    pV_Cur = pCurrent->v + (y_pos << 4) * stride2 + (x_pos << 4);
98    
99                    filter_18x18_to_8x8(&data[0 * 64], pY_Cur, stride);
100                    filter_18x18_to_8x8(&data[1 * 64], pY_Cur + 16, stride);
101                    filter_18x18_to_8x8(&data[2 * 64], pY_Cur + next_block, stride);
102                    filter_18x18_to_8x8(&data[3 * 64], pY_Cur + next_block + 16, stride);
103                    filter_18x18_to_8x8(&data[4 * 64], pU_Cur, stride2);
104                    filter_18x18_to_8x8(&data[5 * 64], pV_Cur, stride2);
105            }else{
106          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
107          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
108          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
109    
         start_timer();  
110          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
111          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
112          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
113          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
114          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
115          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
116            }
117          stop_transfer_timer();          stop_transfer_timer();
118    
119            /* XXX: rrv+interlacing is buggy */
120          start_timer();          start_timer();
121          pMB->field_dct = 0;          pMB->field_dct = 0;
122          if ((frame->global_flags & XVID_INTERLACING) &&          if ((frame->vol_flags & XVID_INTERLACING) &&
123                  (x_pos>0) && (x_pos<pParam->mb_width-1) &&                  (x_pos>0) && (x_pos<pParam->mb_width-1) &&
124                  (y_pos>0) && (y_pos<pParam->mb_height-1)) {                  (y_pos>0) && (y_pos<pParam->mb_height-1)) {
125                  pMB->field_dct = MBDecideFieldDCT(data);                  pMB->field_dct = MBDecideFieldDCT(data);
# Line 125  Line 133 
133                  fdct(&data[i * 64]);                  fdct(&data[i * 64]);
134                  stop_dct_timer();                  stop_dct_timer();
135    
136                  if (pParam->m_quant_type == H263_QUANT) {                  if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
137                          start_timer();                          start_timer();
138                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
139                          stop_quant_timer();                          stop_quant_timer();
   
                         start_timer();  
                         dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);  
                         stop_iquant_timer();  
140                  } else {                  } else {
141                          start_timer();                          start_timer();
142                          quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);                          quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
143                          stop_quant_timer();                          stop_quant_timer();
144                    }
145    
146                    /* speedup: dont decode when encoding only ivops */
147                    if (pParam->iMaxKeyInterval != 1 || pParam->max_bframes > 0)
148                    {
149                            if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
150                                    start_timer();
151                                    dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
152                                    stop_iquant_timer();
153                            } else {
154                          start_timer();                          start_timer();
155                          dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);                          dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
156                          stop_iquant_timer();                          stop_iquant_timer();
# Line 147  Line 160 
160                  idct(&data[i * 64]);                  idct(&data[i * 64]);
161                  stop_idct_timer();                  stop_idct_timer();
162          }          }
163            }
164    
165            /* speedup: dont decode when encoding only ivops */
166            if (pParam->iMaxKeyInterval != 1 || pParam->max_bframes > 0)
167            {
168    
169          if (pMB->field_dct) {          if (pMB->field_dct) {
170                  next_block = stride;                  next_block = stride;
# Line 154  Line 172 
172          }          }
173    
174          start_timer();          start_timer();
175                    if ((frame->vop_flags & XVID_REDUCED))
176                    {
177                            copy_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);
178                            copy_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);
179                            copy_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);
180                            copy_upsampled_8x8_16to8(pY_Cur + next_block + 16, &data[3 * 64], stride);
181                            copy_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);
182                            copy_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);
183    
184                    }else{
185          transfer_16to8copy(pY_Cur, &data[0 * 64], stride);          transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
186          transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);          transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
187          transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);          transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
188          transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);          transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);
189          transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);          transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
190          transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);          transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
191                    }
192          stop_transfer_timer();          stop_transfer_timer();
193            }
194    
195  }  }
196    
# Line 177  Line 207 
207    
208          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
209          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
210          uint32_t next_block = stride * 8;          uint32_t next_block = stride * ((frame->vop_flags & XVID_REDUCED)?16:8);
211          uint32_t i;          uint32_t i;
212          uint32_t iQuant = frame->quant;          uint32_t iQuant = frame->quant;
213          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
# Line 185  Line 215 
215          uint32_t sum;          uint32_t sum;
216          IMAGE *pCurrent = &frame->image;          IMAGE *pCurrent = &frame->image;
217    
218            if ((frame->vop_flags & XVID_REDUCED))
219            {
220                    pY_Cur = pCurrent->y + (y_pos << 5) * stride + (x_pos << 5);
221                    pU_Cur = pCurrent->u + (y_pos << 4) * stride2 + (x_pos << 4);
222                    pV_Cur = pCurrent->v + (y_pos << 4) * stride2 + (x_pos << 4);
223            }else{
224          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
225          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
226          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
227            }
228    
229          start_timer();          start_timer();
230          pMB->field_dct = 0;          pMB->field_dct = 0;
231          if ((frame->global_flags & XVID_INTERLACING) &&          if ((frame->vol_flags & XVID_INTERLACING) &&
232                  (x_pos>0) && (x_pos<pParam->mb_width-1) &&                  (x_pos>0) && (x_pos<pParam->mb_width-1) &&
233                  (y_pos>0) && (y_pos<pParam->mb_height-1)) {                  (y_pos>0) && (y_pos<pParam->mb_height-1)) {
234                  pMB->field_dct = MBDecideFieldDCT(data);                  pMB->field_dct = MBDecideFieldDCT(data);
# Line 199  Line 236 
236          stop_interlacing_timer();          stop_interlacing_timer();
237    
238          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
239                    uint32_t increase_limit = (iQuant == 1) ? 1 : 0;
240    
241                  /*                  /*
242                   *  no need to transfer 8->16-bit                   *  no need to transfer 8->16-bit
243                   * (this is performed already in motion compensation)                   * (this is performed already in motion compensation)
# Line 207  Line 246 
246                  fdct(&data[i * 64]);                  fdct(&data[i * 64]);
247                  stop_dct_timer();                  stop_dct_timer();
248    
249                  if (pParam->m_quant_type == 0) {                  if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
250                          start_timer();                          start_timer();
251                          sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);                          sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
252                          stop_quant_timer();                          stop_quant_timer();
# Line 217  Line 256 
256                          stop_quant_timer();                          stop_quant_timer();
257                  }                  }
258    
259                  if ((sum >= TOOSMALL_LIMIT) || (qcoeff[i*64] != 0) ||                  if ((sum >= TOOSMALL_LIMIT + increase_limit) || (qcoeff[i*64] != 0) ||
260                          (qcoeff[i*64+1] != 0) || (qcoeff[i*64+8] != 0)) {                          (qcoeff[i*64+1] != 0) || (qcoeff[i*64+8] != 0)) {
261    
262                          if (pParam->m_quant_type == H263_QUANT) {                          if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
263                                  start_timer();                                  start_timer();
264                                  dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);                                  dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
265                                  stop_iquant_timer();                                  stop_iquant_timer();
# Line 244  Line 283 
283          }          }
284    
285          start_timer();          start_timer();
286            if ((frame->vop_flags & XVID_REDUCED))
287            {
288                    if (cbp & 32)
289                            add_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);
290                    if (cbp & 16)
291                            add_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);
292                    if (cbp & 8)
293                            add_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);
294                    if (cbp & 4)
295                            add_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);
296                    if (cbp & 2)
297                            add_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);
298                    if (cbp & 1)
299                            add_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);
300            }else{
301          if (cbp & 32)          if (cbp & 32)
302                  transfer_16to8add(pY_Cur, &data[0 * 64], stride);                  transfer_16to8add(pY_Cur, &data[0 * 64], stride);
303          if (cbp & 16)          if (cbp & 16)
# Line 256  Line 310 
310                  transfer_16to8add(pU_Cur, &data[4 * 64], stride2);                  transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
311          if (cbp & 1)          if (cbp & 1)
312                  transfer_16to8add(pV_Cur, &data[5 * 64], stride2);                  transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
313            }
314          stop_transfer_timer();          stop_transfer_timer();
315    
316          return cbp;          return cbp;
# Line 306  Line 361 
361  MBTransQuantInterBVOP(const MBParam * pParam,  MBTransQuantInterBVOP(const MBParam * pParam,
362                                    FRAMEINFO * frame,                                    FRAMEINFO * frame,
363                                    MACROBLOCK * pMB,                                    MACROBLOCK * pMB,
364                                      const uint32_t x_pos,
365                                      const uint32_t y_pos,
366                                    int16_t data[6 * 64],                                    int16_t data[6 * 64],
367                                    int16_t qcoeff[6 * 64])                                    int16_t qcoeff[6 * 64])
368  {  {
# Line 316  Line 373 
373          MBfDCT(pParam,frame,pMB,data);          MBfDCT(pParam,frame,pMB,data);
374          cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);          cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);
375    
376  /* we don't have to DeQuant, iDCT and Transfer back data for B-frames */          /*
377             * History comment:
378             * we don't have to DeQuant, iDCT and Transfer back data for B-frames
379             */
380    
381            /*
382             * As an exception to the previous rule, if we are willing to have extra
383             * stats then we have to DeQuant, iDCT and Transfer back the data :-)
384             */
385            if(frame->vop_flags & XVID_EXTRASTATS) {
386                    MBDeQuantInter(pParam,frame->quant,data,qcoeff,cbp);
387                    MBiDCT(data,cbp);
388                    MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,cbp);
389            }
390    
391          return cbp;          return cbp;
392  }  }
# Line 332  Line 402 
402    
403          start_timer();          start_timer();
404          pMB->field_dct = 0;          pMB->field_dct = 0;
405          if ((frame->global_flags & XVID_INTERLACING)) {          if ((frame->vol_flags & XVID_INTERLACING)) {
406                  pMB->field_dct = MBDecideFieldDCT(data);                  pMB->field_dct = MBDecideFieldDCT(data);
407          }          }
408          stop_interlacing_timer();          stop_interlacing_timer();
# Line 356  Line 426 
426    
427          start_timer();          start_timer();
428          pMB->field_dct = 0;          pMB->field_dct = 0;
429          if ((frame->global_flags & XVID_INTERLACING)) {          if ((frame->vol_flags & XVID_INTERLACING)) {
430                  pMB->field_dct = MBDecideFieldDCT(data);                  pMB->field_dct = MBDecideFieldDCT(data);
431          }          }
432          stop_interlacing_timer();          stop_interlacing_timer();
# Line 364  Line 434 
434          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
435                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
436    
437                  if (pParam->m_quant_type == H263_QUANT) {                  if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
438                          start_timer();                          start_timer();
439                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
440                          stop_quant_timer();                          stop_quant_timer();
# Line 388  Line 458 
458  MBQuantIntra(const MBParam * pParam,  MBQuantIntra(const MBParam * pParam,
459                           FRAMEINFO * frame,                           FRAMEINFO * frame,
460                           MACROBLOCK *pMB,                           MACROBLOCK *pMB,
461                           int16_t data[6 * 64],                       int16_t qcoeff[6 * 64],
462                       int16_t qcoeff[6 * 64])                           int16_t data[6*64])
463  {  {
464          int i;          int i;
465          int iQuant = frame->quant;          int iQuant = frame->quant;
466    
467          start_timer();          start_timer();
468          pMB->field_dct = 0;          pMB->field_dct = 0;
469          if ((frame->global_flags & XVID_INTERLACING)) {          if ((frame->vol_flags & XVID_INTERLACING)) {
470                  pMB->field_dct = MBDecideFieldDCT(data);                  pMB->field_dct = MBDecideFieldDCT(data);
471          }          }
472          stop_interlacing_timer();          stop_interlacing_timer();
# Line 404  Line 474 
474          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
475                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
476    
477                  if (pParam->m_quant_type == H263_QUANT) {                  if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
478                          start_timer();                          start_timer();
479                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
480                          stop_quant_timer();                          stop_quant_timer();
# Line 427  Line 497 
497          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
498                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);                  uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
499    
500                  if (pParam->m_quant_type == H263_QUANT) {                  if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
501                          start_timer();                          start_timer();
502                          dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);                          dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
503                          stop_iquant_timer();                          stop_iquant_timer();
# Line 452  Line 522 
522    
523          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
524    
525                  if (pParam->m_quant_type == 0) {                  if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
526                          start_timer();                          start_timer();
527                          sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);                          sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
528                          stop_quant_timer();                          stop_quant_timer();
# Line 462  Line 532 
532                          stop_quant_timer();                          stop_quant_timer();
533                  }                  }
534    
535                  if (sum >= TOOSMALL_LIMIT) {    /* skip block ? */                  if (sum >= TOOSMALL_LIMIT) {    // skip block ?
536                          cbp |= 1 << (5 - i);                          cbp |= 1 << (5 - i);
537                  }                  }
538          }          }
# Line 481  Line 551 
551          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
552                  if (cbp & (1 << (5 - i)))                  if (cbp & (1 << (5 - i)))
553                  {                  {
554                          if (pParam->m_quant_type == H263_QUANT) {                          if (!(pParam->vol_flags & XVID_MPEGQUANT)) {
555                                  start_timer();                                  start_timer();
556                                  dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);                                  dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
557                                  stop_iquant_timer();                                  stop_iquant_timer();
# Line 582  Line 652 
652    
653    
654    
655  /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */  /* permute block and return field dct choice */
656    
657    
658  uint32_t  uint32_t
659  MBDecideFieldDCT(int16_t data[6 * 64])  MBDecideFieldDCT(int16_t data[6 * 64])
660  {  {
661            uint32_t field = MBFieldTest(data);
662    
663            if (field) {
664                    MBFrameToField(data);
665            }
666    
667            return field;
668    }
669    
670    
671    /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */
672    
673    uint32_t
674    MBFieldTest_c(int16_t data[6 * 64])
675    {
676          const uint8_t blocks[] =          const uint8_t blocks[] =
677                  { 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };                  { 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };
678          const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };          const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };
# Line 622  Line 706 
706                  }                  }
707          }          }
708    
709          if (frame > (field + 350)) {          return (frame >= (field + 350));
                 MBFrameToField(data);  
         }  
   
         return (frame > (field + 350));  
710  }  }
711    
712    
# Line 642  Line 722 
722    
723          /* left blocks */          /* left blocks */
724    
725          /* 1=2, 2=4, 4=8, 8=1 */          // 1=2, 2=4, 4=8, 8=1
726          MOVLINE(tmp, LINE(0, 1));          MOVLINE(tmp, LINE(0, 1));
727          MOVLINE(LINE(0, 1), LINE(0, 2));          MOVLINE(LINE(0, 1), LINE(0, 2));
728          MOVLINE(LINE(0, 2), LINE(0, 4));          MOVLINE(LINE(0, 2), LINE(0, 4));
729          MOVLINE(LINE(0, 4), LINE(2, 0));          MOVLINE(LINE(0, 4), LINE(2, 0));
730          MOVLINE(LINE(2, 0), tmp);          MOVLINE(LINE(2, 0), tmp);
731    
732          /* 3=6, 6=12, 12=9, 9=3 */          // 3=6, 6=12, 12=9, 9=3
733          MOVLINE(tmp, LINE(0, 3));          MOVLINE(tmp, LINE(0, 3));
734          MOVLINE(LINE(0, 3), LINE(0, 6));          MOVLINE(LINE(0, 3), LINE(0, 6));
735          MOVLINE(LINE(0, 6), LINE(2, 4));          MOVLINE(LINE(0, 6), LINE(2, 4));
736          MOVLINE(LINE(2, 4), LINE(2, 1));          MOVLINE(LINE(2, 4), LINE(2, 1));
737          MOVLINE(LINE(2, 1), tmp);          MOVLINE(LINE(2, 1), tmp);
738    
739          /* 5=10, 10=5 */          // 5=10, 10=5
740          MOVLINE(tmp, LINE(0, 5));          MOVLINE(tmp, LINE(0, 5));
741          MOVLINE(LINE(0, 5), LINE(2, 2));          MOVLINE(LINE(0, 5), LINE(2, 2));
742          MOVLINE(LINE(2, 2), tmp);          MOVLINE(LINE(2, 2), tmp);
743    
744          /* 7=14, 14=13, 13=11, 11=7 */          // 7=14, 14=13, 13=11, 11=7
745          MOVLINE(tmp, LINE(0, 7));          MOVLINE(tmp, LINE(0, 7));
746          MOVLINE(LINE(0, 7), LINE(2, 6));          MOVLINE(LINE(0, 7), LINE(2, 6));
747          MOVLINE(LINE(2, 6), LINE(2, 5));          MOVLINE(LINE(2, 6), LINE(2, 5));
# Line 670  Line 750 
750    
751          /* right blocks */          /* right blocks */
752    
753          /* 1=2, 2=4, 4=8, 8=1 */          // 1=2, 2=4, 4=8, 8=1
754          MOVLINE(tmp, LINE(1, 1));          MOVLINE(tmp, LINE(1, 1));
755          MOVLINE(LINE(1, 1), LINE(1, 2));          MOVLINE(LINE(1, 1), LINE(1, 2));
756          MOVLINE(LINE(1, 2), LINE(1, 4));          MOVLINE(LINE(1, 2), LINE(1, 4));
757          MOVLINE(LINE(1, 4), LINE(3, 0));          MOVLINE(LINE(1, 4), LINE(3, 0));
758          MOVLINE(LINE(3, 0), tmp);          MOVLINE(LINE(3, 0), tmp);
759    
760          /* 3=6, 6=12, 12=9, 9=3 */          // 3=6, 6=12, 12=9, 9=3
761          MOVLINE(tmp, LINE(1, 3));          MOVLINE(tmp, LINE(1, 3));
762          MOVLINE(LINE(1, 3), LINE(1, 6));          MOVLINE(LINE(1, 3), LINE(1, 6));
763          MOVLINE(LINE(1, 6), LINE(3, 4));          MOVLINE(LINE(1, 6), LINE(3, 4));
764          MOVLINE(LINE(3, 4), LINE(3, 1));          MOVLINE(LINE(3, 4), LINE(3, 1));
765          MOVLINE(LINE(3, 1), tmp);          MOVLINE(LINE(3, 1), tmp);
766    
767          /* 5=10, 10=5 */          // 5=10, 10=5
768          MOVLINE(tmp, LINE(1, 5));          MOVLINE(tmp, LINE(1, 5));
769          MOVLINE(LINE(1, 5), LINE(3, 2));          MOVLINE(LINE(1, 5), LINE(3, 2));
770          MOVLINE(LINE(3, 2), tmp);          MOVLINE(LINE(3, 2), tmp);
771    
772          /* 7=14, 14=13, 13=11, 11=7 */          // 7=14, 14=13, 13=11, 11=7
773          MOVLINE(tmp, LINE(1, 7));          MOVLINE(tmp, LINE(1, 7));
774          MOVLINE(LINE(1, 7), LINE(3, 6));          MOVLINE(LINE(1, 7), LINE(3, 6));
775          MOVLINE(LINE(3, 6), LINE(3, 5));          MOVLINE(LINE(3, 6), LINE(3, 5));
Legend:
Removed from v.1.20  
changed lines
  Added in v.1.21.2.2
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4