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

Diff of /xvidcore/src/decoder.c

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

revision 1.1.1.1, Fri Mar 8 02:44:29 2002 UTC revision 1.82, Tue Aug 10 14:17:23 2010 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      decoder main   *  - Decoder Module -
5   *   *
6   *      This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2002      MinChen <chenm001@163.com>
7   *      Video tools as specified in ISO/IEC 14496-2 standard.  Those intending   *               2002-2004 Peter Ross <pross@xvid.org>
  *      to use this software module in hardware or software products are  
  *      advised that its use may infringe existing patents or copyrights, and  
  *      any such use would be at such party's own risk.  The original  
  *      developer of this software module and his/her company, and subsequent  
  *      editors and their companies, will have no liability for use of this  
  *      software or modifications or derivatives thereof.  
8   *   *
9   *      This program is free software; you can redistribute it and/or modify   *      This program is free software; you can redistribute it and/or modify
10   *      it under the terms of the GNU General Public License as published by   *      it under the terms of the GNU General Public License as published by
# Line 24  Line 18 
18   *   *
19   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
20   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
21   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22   *   *
23   *************************************************************************/   * $Id$
   
 /**************************************************************************  
  *  
  *      History:  
  *  
  *      26.12.2001      decoder_mbinter: dequant/idct moved within if(coded) block  
  *      22.12.2001      block based interpolation  
  *      01.12.2001      inital version; (c)2001 peter ross <pross@cs.rmit.edu.au>  
24   *   *
25   *************************************************************************/   ****************************************************************************/
26    
27    #include <stdio.h>
28  #include <stdlib.h>  #include <stdlib.h>
29  #include <string.h>  // memset  #include <string.h>
30    
31    #ifdef BFRAMES_DEC_DEBUG
32    #define BFRAMES_DEC
33    #endif
34    
35  #include "xvid.h"  #include "xvid.h"
36  #include "portab.h"  #include "portab.h"
37    #include "global.h"
38    
39  #include "decoder.h"  #include "decoder.h"
40  #include "bitstream/bitstream.h"  #include "bitstream/bitstream.h"
41  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
42    
43  #include "quant/quant_h263.h"  #include "quant/quant.h"
44  #include "quant/quant_mpeg4.h"  #include "quant/quant_matrix.h"
45  #include "dct/idct.h"  #include "dct/idct.h"
46  #include "dct/fdct.h"  #include "dct/fdct.h"
47  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
48  #include "image/interpolate8x8.h"  #include "image/interpolate8x8.h"
49    #include "image/font.h"
50    #include "image/qpel.h"
51    
52  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
53  #include "prediction/mbprediction.h"  #include "prediction/mbprediction.h"
54  #include "utils/timer.h"  #include "utils/timer.h"
55  #include "utils/emms.h"  #include "utils/emms.h"
56    #include "motion/motion.h"
57    #include "motion/gmc.h"
58    
59  #include "image/image.h"  #include "image/image.h"
60  #include "image/colorspace.h"  #include "image/colorspace.h"
61    #include "image/postprocessing.h"
62    #include "utils/mem_align.h"
63    
64  int decoder_create(XVID_DEC_PARAM * param)  #define DIV2ROUND(n)  (((n)>>1)|((n)&1))
65  {  #define DIV2(n)       ((n)>>1)
66          DECODER * dec;  #define DIVUVMOV(n) (((n) >> 1) + roundtab_79[(n) & 0x3]) //
67    
68          dec = malloc(sizeof(DECODER));  static int
69          if (dec == NULL)  decoder_resize(DECODER * dec)
70          {          {
71                  return XVID_ERR_MEMORY;          /* free existing */
72          }          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
73          param->handle = dec;          image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
74            image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
75          dec->width = param->width;          image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
76          dec->height = param->height;          image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
77    
78            image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
79    
80      image_null(&dec->cur);
81      image_null(&dec->refn[0]);
82      image_null(&dec->refn[1]);
83      image_null(&dec->tmp);
84      image_null(&dec->qtmp);
85      image_null(&dec->gmc);
86    
87    
88      xvid_free(dec->last_mbs);
89      xvid_free(dec->mbs);
90      xvid_free(dec->qscale);
91      dec->last_mbs = NULL;
92      dec->mbs = NULL;
93      dec->qscale = NULL;
94    
95            /* realloc */
96          dec->mb_width = (dec->width + 15) / 16;          dec->mb_width = (dec->width + 15) / 16;
97          dec->mb_height = (dec->height + 15) / 16;          dec->mb_height = (dec->height + 15) / 16;
98    
99          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;          dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;
100          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;          dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;
101    
102          if (image_create(&dec->cur, dec->edged_width, dec->edged_height))          if (   image_create(&dec->cur, dec->edged_width, dec->edged_height)
103          {              || image_create(&dec->refn[0], dec->edged_width, dec->edged_height)
104                  free(dec);              || image_create(&dec->refn[1], dec->edged_width, dec->edged_height)         /* Support B-frame to reference last 2 frame */
105                || image_create(&dec->tmp, dec->edged_width, dec->edged_height)
106                || image_create(&dec->qtmp, dec->edged_width, dec->edged_height)
107          || image_create(&dec->gmc, dec->edged_width, dec->edged_height) )
108        goto memory_error;
109    
110            dec->mbs =
111                    xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
112                                            CACHE_LINE);
113            if (dec->mbs == NULL)
114              goto memory_error;
115            memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
116    
117            /* For skip MB flag */
118            dec->last_mbs =
119                    xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120                                            CACHE_LINE);
121            if (dec->last_mbs == NULL)
122              goto memory_error;
123            memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124    
125            /* nothing happens if that fails */
126            dec->qscale =
127                    xvid_malloc(sizeof(int) * dec->mb_width * dec->mb_height, CACHE_LINE);
128    
129            if (dec->qscale)
130                    memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131    
132            return 0;
133    
134    memory_error:
135            /* Most structures were deallocated / nullifieded, so it should be safe */
136            /* decoder_destroy(dec) minus the write_timer */
137      xvid_free(dec->mbs);
138      image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139      image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140      image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141      image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143    
144      xvid_free(dec);
145                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
146          }          }
147    
148          if (image_create(&dec->refn, dec->edged_width, dec->edged_height))  
149    int
150    decoder_create(xvid_dec_create_t * create)
151          {          {
152                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);    DECODER *dec;
153                  free(dec);  
154      if (XVID_VERSION_MAJOR(create->version) != 1) /* v1.x.x */
155        return XVID_ERR_VERSION;
156    
157      dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);
158      if (dec == NULL) {
159                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
160          }          }
161    
162          dec->mbs = malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);    memset(dec, 0, sizeof(DECODER));
163          if (dec->mbs == NULL)  
164          {    dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
165                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);    if (dec->mpeg_quant_matrices == NULL) {
166                  free(dec);      xvid_free(dec);
167                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
168          }          }
169    
170      create->handle = dec;
171    
172      dec->width = create->width;
173      dec->height = create->height;
174    
175      image_null(&dec->cur);
176      image_null(&dec->refn[0]);
177      image_null(&dec->refn[1]);
178      image_null(&dec->tmp);
179      image_null(&dec->qtmp);
180    
181      /* image based GMC */
182      image_null(&dec->gmc);
183    
184      dec->mbs = NULL;
185      dec->last_mbs = NULL;
186      dec->qscale = NULL;
187    
188          init_timer();          init_timer();
189          create_vlc_tables();    init_postproc(&dec->postproc);
190      init_mpeg_matrix(dec->mpeg_quant_matrices);
191    
192          return XVID_ERR_OK;    /* For B-frame support (used to save reference frame's time */
193      dec->frames = 0;
194      dec->time = dec->time_base = dec->last_time_base = 0;
195      dec->low_delay = 0;
196      dec->packed_mode = 0;
197      dec->time_inc_resolution = 1; /* until VOL header says otherwise */
198      dec->ver_id = 1;
199    
200      if (create->fourcc == ((int)('X')|((int)('V')<<8)|
201                             ((int)('I')<<16)|((int)('D')<<24))) { /* XVID */
202        dec->bs_version = 1; /* Initially assume oldest xvid version */
203      }
204      else {
205            dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
206      }
207    
208      dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
209    
210      if (dec->fixed_dimensions) {
211        int ret = decoder_resize(dec);
212        if (ret == XVID_ERR_MEMORY) create->handle = NULL;
213        return ret;
214      }
215      else
216        return 0;
217  }  }
218    
219    
220  int decoder_destroy(DECODER * dec)  int
221    decoder_destroy(DECODER * dec)
222  {  {
223          free(dec->mbs);    xvid_free(dec->last_mbs);
224          image_destroy(&dec->refn, dec->edged_width, dec->edged_height);    xvid_free(dec->mbs);
225          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);    xvid_free(dec->qscale);
226          free(dec);  
227      /* image based GMC */
228      image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
229    
230          destroy_vlc_tables();    image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
231      image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
232      image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
233      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
234      image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
235      xvid_free(dec->mpeg_quant_matrices);
236      xvid_free(dec);
237    
238          write_timer();          write_timer();
239          return XVID_ERR_OK;    return 0;
240  }  }
241    
242    static const int32_t dquant_table[4] = {
   
 static const int32_t dquant_table[4] =  
 {  
243          -1, -2, 1, 2          -1, -2, 1, 2
244  };  };
245    
246    /* decode an intra macroblock */
247    static void
248    decoder_mbintra(DECODER * dec,
249            MACROBLOCK * pMB,
250            const uint32_t x_pos,
251            const uint32_t y_pos,
252            const uint32_t acpred_flag,
253            const uint32_t cbp,
254            Bitstream * bs,
255            const uint32_t quant,
256            const uint32_t intra_dc_threshold,
257            const unsigned int bound)
258    {
259    
260      DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
261      DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);
262    
263      uint32_t stride = dec->edged_width;
264      uint32_t stride2 = stride / 2;
265      uint32_t next_block = stride * 8;
266      uint32_t i;
267      uint32_t iQuant = pMB->quant;
268      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
269    
270      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
271      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
272      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
273    
274  // decode an intra macroblock    memset(block, 0, 6 * 64 * sizeof(int16_t)); /* clear */
   
 void decoder_mbintra(DECODER * dec, MACROBLOCK * mb, int x, int y, uint32_t acpred_flag, uint32_t cbp, Bitstream * bs, int quant, int intra_dc_threshold)  
 {  
         uint32_t k;  
275    
276          for (k = 0; k < 6; k++)    for (i = 0; i < 6; i++) {
277          {      uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
                 uint32_t dcscalar;  
                 int16_t block[64];  
                 int16_t data[64];  
278                  int16_t predictors[8];                  int16_t predictors[8];
279                  int start_coeff;                  int start_coeff;
280    
                 dcscalar = get_dc_scaler(mb->quant, k < 4);  
   
281                  start_timer();                  start_timer();
282                  predict_acdc(dec->mbs, x, y, dec->mb_width, k, block, mb->quant, dcscalar, predictors);      predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],
283                  if (!acpred_flag)             iQuant, iDcScaler, predictors, bound);
284                  {      if (!acpred_flag) {
285                          mb->acpred_directions[k] = 0;        pMB->acpred_directions[i] = 0;
286                  }                  }
287                  stop_prediction_timer();                  stop_prediction_timer();
288    
289                  memset(block, 0, 64*sizeof(int16_t));           // clear      if (quant < intra_dc_threshold) {
   
                 if (quant < intra_dc_threshold)  
                 {  
290                          int dc_size;                          int dc_size;
291                          int dc_dif;                          int dc_dif;
292    
293                          dc_size = k < 4 ?  get_dc_size_lum(bs) : get_dc_size_chrom(bs);        dc_size = i < 4 ? get_dc_size_lum(bs) : get_dc_size_chrom(bs);
294                          dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0 ;                          dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0 ;
295    
296                          if (dc_size > 8)        if (dc_size > 8) {
297                          {          BitstreamSkip(bs, 1); /* marker */
                                 BitstreamSkip(bs, 1);           // marker  
298                          }                          }
299    
300                          block[0] = dc_dif;        block[i * 64 + 0] = dc_dif;
301                          start_coeff = 1;                          start_coeff = 1;
302                  }  
303                  else        DPRINTF(XVID_DEBUG_COEFF,"block[0] %i\n", dc_dif);
304                  {      } else {
305                          start_coeff = 0;                          start_coeff = 0;
306                  }                  }
307    
308                  start_timer();                  start_timer();
309                  if (cbp & (1 << (5-k)))                 // coded      if (cbp & (1 << (5 - i))) /* coded */
310                  {                  {
311                          get_intra_block(bs, block, mb->acpred_directions[k], start_coeff);        int direction = dec->alternate_vertical_scan ?
312            2 : pMB->acpred_directions[i];
313    
314          get_intra_block(bs, &block[i * 64], direction, start_coeff);
315                  }                  }
316                  stop_coding_timer();                  stop_coding_timer();
317    
318                  start_timer();                  start_timer();
319                  add_acdc(mb, k, block, dcscalar, predictors);      add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors, dec->bs_version);
320                  stop_prediction_timer();                  stop_prediction_timer();
321    
322                  start_timer();                  start_timer();
323                  if (dec->quant_type == 0)      if (dec->quant_type == 0) {
324                  {        dequant_h263_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
325                          dequant_intra(data, block, mb->quant, dcscalar);      } else {
326                  }        dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
                 else  
                 {  
                         dequant4_intra(data, block, mb->quant, dcscalar);  
327                  }                  }
328                  stop_iquant_timer();                  stop_iquant_timer();
329    
330                  start_timer();                  start_timer();
331                  idct(data);      idct((short * const)&data[i * 64]);
332                  stop_idct_timer();                  stop_idct_timer();
333    
                 start_timer();  
                 if (k < 4)  
                 {  
                         transfer_16to8copy(dec->cur.y + (16*y*dec->edged_width) + 16*x + (4*(k&2)*dec->edged_width) + 8*(k&1), data, dec->edged_width);  
334                  }                  }
335                  else if (k == 4)  
336                  {    if (dec->interlacing && pMB->field_dct) {
337                          transfer_16to8copy(dec->cur.u+ 8*y*(dec->edged_width/2) + 8*x, data, (dec->edged_width/2));      next_block = stride;
338                  }      stride *= 2;
                 else    // if (k == 5)  
                 {  
                         transfer_16to8copy(dec->cur.v + 8*y*(dec->edged_width/2) + 8*x, data, (dec->edged_width/2));  
339                  }                  }
340    
341      start_timer();
342      transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
343      transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
344      transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
345      transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
346      transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
347      transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
348                  stop_transfer_timer();                  stop_transfer_timer();
349          }          }
 }  
350    
351    static void
352    decoder_mb_decode(DECODER * dec,
353            const uint32_t cbp,
354            Bitstream * bs,
355            uint8_t * pY_Cur,
356            uint8_t * pU_Cur,
357            uint8_t * pV_Cur,
358            const MACROBLOCK * pMB)
359    {
360      DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
361    
362      int stride = dec->edged_width;
363      int i;
364      const uint32_t iQuant = pMB->quant;
365      const int direction = dec->alternate_vertical_scan ? 2 : 0;
366      typedef void (*get_inter_block_function_t)(
367          Bitstream * bs,
368          int16_t * block,
369          int direction,
370          const int quant,
371          const uint16_t *matrix);
372      typedef void (*add_residual_function_t)(
373          uint8_t *predicted_block,
374          const int16_t *residual,
375          int stride);
376    
377      const get_inter_block_function_t get_inter_block = (dec->quant_type == 0)
378        ? (get_inter_block_function_t)get_inter_block_h263
379        : (get_inter_block_function_t)get_inter_block_mpeg;
380    
381      uint8_t *dst[6];
382      int strides[6];
383    
384    
385      if (dec->interlacing && pMB->field_dct) {
386        dst[0] = pY_Cur;
387        dst[1] = pY_Cur + 8;
388        dst[2] = pY_Cur + stride;
389        dst[3] = dst[2] + 8;
390        dst[4] = pU_Cur;
391        dst[5] = pV_Cur;
392        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
393        strides[4] = stride/2;
394        strides[5] = stride/2;
395      } else {
396        dst[0] = pY_Cur;
397        dst[1] = pY_Cur + 8;
398        dst[2] = pY_Cur + 8*stride;
399        dst[3] = dst[2] + 8;
400        dst[4] = pU_Cur;
401        dst[5] = pV_Cur;
402        strides[0] = strides[1] = strides[2] = strides[3] = stride;
403        strides[4] = stride/2;
404        strides[5] = stride/2;
405      }
406    
407      for (i = 0; i < 6; i++) {
408        /* Process only coded blocks */
409        if (cbp & (1 << (5 - i))) {
410    
411          /* Clear the block */
412          memset(&data[0], 0, 64*sizeof(int16_t));
413    
414          /* Decode coeffs and dequantize on the fly */
415          start_timer();
416          get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
417          stop_coding_timer();
418    
419          /* iDCT */
420          start_timer();
421          idct((short * const)&data[0]);
422          stop_idct_timer();
423    
424  #define SIGN(X) (((X)>0)?1:-1)        /* Add this residual to the predicted block */
425  #define ABS(X) (((X)>0)?(X):-(X))        start_timer();
426  static const uint32_t roundtab[16] =        transfer_16to8add(dst[i], &data[0], strides[i]);
427                  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };        stop_transfer_timer();
428        }
429      }
430    }
431    
432    static void __inline
433    validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
434    {
435      /* clip a vector to valid range
436         prevents crashes if bitstream is broken
437      */
438      int shift = 5 + dec->quarterpel;
439      int xborder_high = (int)(dec->mb_width - x_pos) << shift;
440      int xborder_low = (-(int)x_pos-1) << shift;
441      int yborder_high = (int)(dec->mb_height - y_pos) << shift;
442      int yborder_low = (-(int)y_pos-1) << shift;
443    
444    #define CHECK_MV(mv) \
445      do { \
446      if ((mv).x > xborder_high) { \
447        DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
448        (mv).x = xborder_high; \
449      } else if ((mv).x < xborder_low) { \
450        DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
451        (mv).x = xborder_low; \
452      } \
453      if ((mv).y > yborder_high) { \
454        DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
455        (mv).y = yborder_high; \
456      } else if ((mv).y < yborder_low) { \
457        DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
458        (mv).y = yborder_low; \
459      } \
460      } while (0)
461    
462      CHECK_MV(mv[0]);
463      CHECK_MV(mv[1]);
464      CHECK_MV(mv[2]);
465      CHECK_MV(mv[3]);
466    }
467    
468    /* Up to this version, chroma rounding was wrong with qpel.
469     * So we try to be backward compatible to avoid artifacts */
470    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
471    
472    /* decode an inter macroblock */
473    static void
474    decoder_mbinter(DECODER * dec,
475            const MACROBLOCK * pMB,
476            const uint32_t x_pos,
477            const uint32_t y_pos,
478            const uint32_t cbp,
479            Bitstream * bs,
480            const uint32_t rounding,
481            const int ref,
482                    const int bvop)
483    {
484      uint32_t stride = dec->edged_width;
485      uint32_t stride2 = stride / 2;
486      uint32_t i;
487    
488  // decode an inter macroblock    uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
489    
 void decoder_mbinter(DECODER * dec, MACROBLOCK * mb, int x, int y, uint32_t acpred_flag, uint32_t cbp, Bitstream * bs, int quant, int rounding)  
 {  
         const uint32_t stride = dec->edged_width;  
         const uint32_t stride2 = dec->edged_width / 2;  
490          int uv_dx, uv_dy;          int uv_dx, uv_dy;
491          uint32_t k;    VECTOR mv[4]; /* local copy of mvs */
492    
493          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q)    pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
494          {    pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
495                  uv_dx = mb->mvs[0].x;    pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
496                  uv_dy = mb->mvs[0].y;    for (i = 0; i < 4; i++)
497        mv[i] = pMB->mvs[i];
498    
499                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;    validate_vector(mv, x_pos, y_pos, dec);
500                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;  
501          }    start_timer();
502    
503      if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
504    
505        uv_dx = mv[0].x;
506        uv_dy = mv[0].y;
507        if (dec->quarterpel) {
508                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
509                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
510                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
511                            }
512                            else {
513            uv_dx /= 2;
514            uv_dy /= 2;
515          }
516        }
517        uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
518        uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
519    
520        if (dec->quarterpel)
521          interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,
522                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
523                          mv[0].x, mv[0].y, stride, rounding);
524          else          else
525          {        interpolate16x16_switch(dec->cur.y, dec->refn[ref].y, 16*x_pos, 16*y_pos,
526                  int sum;                    mv[0].x, mv[0].y, stride, rounding);
527                  sum = mb->mvs[0].x + mb->mvs[1].x + mb->mvs[2].x + mb->mvs[3].x;  
528                  uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );    } else {  /* MODE_INTER4V */
529    
530                  sum = mb->mvs[0].y + mb->mvs[1].y + mb->mvs[2].y + mb->mvs[3].y;      if(dec->quarterpel) {
531                  uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) );                          if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
532                                    int z;
533                                    uv_dx = 0; uv_dy = 0;
534                                    for (z = 0; z < 4; z++) {
535                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
536                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
537                                    }
538                            }
539                            else {
540            uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
541            uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
542          }
543        } else {
544          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
545          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
546        }
547    
548        uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
549        uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
550    
551        if (dec->quarterpel) {
552          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
553                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
554                      mv[0].x, mv[0].y, stride, rounding);
555          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
556                      dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
557                      mv[1].x, mv[1].y, stride, rounding);
558          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
559                      dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
560                      mv[2].x, mv[2].y, stride, rounding);
561          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,
562                      dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
563                      mv[3].x, mv[3].y, stride, rounding);
564        } else {
565          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos, 16*y_pos,
566                    mv[0].x, mv[0].y, stride, rounding);
567          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos + 8, 16*y_pos,
568                    mv[1].x, mv[1].y, stride, rounding);
569          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos, 16*y_pos + 8,
570                    mv[2].x, mv[2].y, stride, rounding);
571          interpolate8x8_switch(dec->cur.y, dec->refn[0].y , 16*x_pos + 8, 16*y_pos + 8,
572                    mv[3].x, mv[3].y, stride, rounding);
573        }
574          }          }
575    
576          start_timer();    /* chroma */
577          interpolate8x8_switch(dec->cur.y, dec->refn.y, 16*x,     16*y    , mb->mvs[0].x, mb->mvs[0].y, stride,  rounding);    interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
578          interpolate8x8_switch(dec->cur.y, dec->refn.y, 16*x + 8, 16*y    , mb->mvs[1].x, mb->mvs[1].y, stride,  rounding);                uv_dx, uv_dy, stride2, rounding);
579          interpolate8x8_switch(dec->cur.y, dec->refn.y, 16*x,     16*y + 8, mb->mvs[2].x, mb->mvs[2].y, stride,  rounding);    interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
580          interpolate8x8_switch(dec->cur.y, dec->refn.y, 16*x + 8, 16*y + 8, mb->mvs[3].x, mb->mvs[3].y, stride,  rounding);                uv_dx, uv_dy, stride2, rounding);
581          interpolate8x8_switch(dec->cur.u, dec->refn.u, 8*x, 8*y, uv_dx, uv_dy, stride2, rounding);  
         interpolate8x8_switch(dec->cur.v, dec->refn.v, 8*x, 8*y, uv_dx, uv_dy, stride2, rounding);  
582          stop_comp_timer();          stop_comp_timer();
583    
584      if (cbp)
585        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
586    }
587    
588          for (k = 0; k < 6; k++)  /* decode an inter macroblock in field mode */
589          {  static void
590                  int16_t block[64];  decoder_mbinter_field(DECODER * dec,
591                  int16_t data[64];          const MACROBLOCK * pMB,
592            const uint32_t x_pos,
593            const uint32_t y_pos,
594            const uint32_t cbp,
595            Bitstream * bs,
596            const uint32_t rounding,
597            const int ref,
598                    const int bvop)
599    {
600      uint32_t stride = dec->edged_width;
601      uint32_t stride2 = stride / 2;
602    
603      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
604    
605      int uvtop_dx, uvtop_dy;
606      int uvbot_dx, uvbot_dy;
607      VECTOR mv[4]; /* local copy of mvs */
608    
609      /* Get pointer to memory areas */
610      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
611      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
612      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
613    
614      mv[0] = pMB->mvs[0];
615      mv[1] = pMB->mvs[1];
616      memset(&mv[2],0,2*sizeof(VECTOR));
617    
618                  if (cbp & (1 << (5-k)))                 // coded    validate_vector(mv, x_pos, y_pos, dec);
                 {  
                         memset(block, 0, 64 * sizeof(int16_t));         // clear  
619    
620                          start_timer();                          start_timer();
                         get_inter_block(bs, block);  
                         stop_coding_timer();  
621    
622                          start_timer();    if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
                         if (dec->quant_type == 0)  
                         {  
                                 dequant_inter(data, block, mb->quant);  
                         }  
                         else  
623                          {                          {
624                                  dequant4_inter(data, block, mb->quant);      /* Prepare top field vector */
625                          }      uvtop_dx = DIV2ROUND(mv[0].x);
626                          stop_iquant_timer();      uvtop_dy = DIV2ROUND(mv[0].y);
627    
628                          start_timer();      /* Prepare bottom field vector */
629                          idct(data);      uvbot_dx = DIV2ROUND(mv[1].x);
630                          stop_idct_timer();      uvbot_dy = DIV2ROUND(mv[1].y);
631    
632                          start_timer();      if(dec->quarterpel)
                         if (k < 4)  
                         {  
                                 transfer_16to8add(dec->cur.y + (16*y + 4*(k&2))*stride + 16*x + 8*(k&1), data, stride);  
                         }  
                         else if (k == 4)  
633                          {                          {
634                                  transfer_16to8add(dec->cur.u + 8*y*stride2 + 8*x, data, stride2);        /* NOT supported */
635                          }                          }
636                          else // k == 5      else
637                          {                          {
638                                  transfer_16to8add(dec->cur.v + 8*y*stride2 + 8*x, data, stride2);        /* Interpolate top field left part(we use double stride for every 2nd line) */
639          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
640                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
641          /* top field right part */
642          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
643                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
644    
645          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
646          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
647                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
648          /* Bottom field right part */
649          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
650                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
651    
652          /* Interpolate field1 U */
653          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
654                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
655    
656          /* Interpolate field1 V */
657          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
658                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
659    
660          /* Interpolate field2 U */
661          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
662                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
663    
664          /* Interpolate field2 V */
665          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
666                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
667                          }                          }
                         stop_transfer_timer();  
668                  }                  }
669      else
670      {
671        /* We don't expect 4 motion vectors in interlaced mode */
672          }          }
673    
674      stop_comp_timer();
675    
676      /* Must add error correction? */
677      if(cbp)
678       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
679  }  }
680    
681    static void
682    decoder_mbgmc(DECODER * dec,
683            MACROBLOCK * const pMB,
684            const uint32_t x_pos,
685            const uint32_t y_pos,
686            const uint32_t fcode,
687            const uint32_t cbp,
688            Bitstream * bs,
689            const uint32_t rounding)
690    {
691      const uint32_t stride = dec->edged_width;
692      const uint32_t stride2 = stride / 2;
693    
694      uint8_t *const pY_Cur=dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
695      uint8_t *const pU_Cur=dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
696      uint8_t *const pV_Cur=dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
697    
698      NEW_GMC_DATA * gmc_data = &dec->new_gmc_data;
699    
700      pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
701    
702      start_timer();
703    
704    /* this is where the calculations are done */
705    
706  void decoder_iframe(DECODER * dec, Bitstream * bs, int quant, int intra_dc_threshold)    gmc_data->predict_16x16(gmc_data,
707          dec->cur.y + y_pos*16*stride + x_pos*16, dec->refn[0].y,
708          stride, stride, x_pos, y_pos, rounding);
709    
710      gmc_data->predict_8x8(gmc_data,
711          dec->cur.u + y_pos*8*stride2 + x_pos*8, dec->refn[0].u,
712          dec->cur.v + y_pos*8*stride2 + x_pos*8, dec->refn[0].v,
713          stride2, stride2, x_pos, y_pos, rounding);
714    
715      gmc_data->get_average_mv(gmc_data, &pMB->amv, x_pos, y_pos, dec->quarterpel);
716    
717      pMB->amv.x = gmc_sanitize(pMB->amv.x, dec->quarterpel, fcode);
718      pMB->amv.y = gmc_sanitize(pMB->amv.y, dec->quarterpel, fcode);
719    
720      pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
721    
722      stop_transfer_timer();
723    
724      if (cbp)
725        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
726    
727    }
728    
729    
730    static void
731    decoder_iframe(DECODER * dec,
732            Bitstream * bs,
733            int quant,
734            int intra_dc_threshold)
735  {  {
736      uint32_t bound;
737          uint32_t x, y;          uint32_t x, y;
738      const uint32_t mb_width = dec->mb_width;
739      const uint32_t mb_height = dec->mb_height;
740    
741          for (y = 0; y < dec->mb_height; y++)    bound = 0;
         {  
                 for (x = 0; x < dec->mb_width; x++)  
                 {  
                         MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];  
742    
743      for (y = 0; y < mb_height; y++) {
744        for (x = 0; x < mb_width; x++) {
745          MACROBLOCK *mb;
746                          uint32_t mcbpc;                          uint32_t mcbpc;
747                          uint32_t cbpc;                          uint32_t cbpc;
748                          uint32_t acpred_flag;                          uint32_t acpred_flag;
749                          uint32_t cbpy;                          uint32_t cbpy;
750                          uint32_t cbp;                          uint32_t cbp;
751    
752          while (BitstreamShowBits(bs, 9) == 1)
753            BitstreamSkip(bs, 9);
754    
755          if (check_resync_marker(bs, 0))
756          {
757            bound = read_video_packet_header(bs, dec, 0,
758                  &quant, NULL, NULL, &intra_dc_threshold);
759            x = bound % mb_width;
760            y = MIN((bound / mb_width), (mb_height-1));
761          }
762          mb = &dec->mbs[y * dec->mb_width + x];
763    
764          DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
765    
766                          mcbpc = get_mcbpc_intra(bs);                          mcbpc = get_mcbpc_intra(bs);
767                          mb->mode = mcbpc & 7;                          mb->mode = mcbpc & 7;
768                          cbpc = (mcbpc >> 4);                          cbpc = (mcbpc >> 4);
769    
770                          acpred_flag = BitstreamGetBit(bs);                          acpred_flag = BitstreamGetBit(bs);
771    
                         if (mb->mode == MODE_STUFFING)  
                         {  
                                 DEBUG("-- STUFFING ?");  
                                 continue;  
                         }  
   
772                          cbpy = get_cbpy(bs, 1);                          cbpy = get_cbpy(bs, 1);
773                          cbp = (cbpy << 2) | cbpc;                          cbp = (cbpy << 2) | cbpc;
774    
775                          if (mb->mode == MODE_INTRA_Q)        if (mb->mode == MODE_INTRA_Q) {
                         {  
776                                  quant += dquant_table[BitstreamGetBits(bs,2)];                                  quant += dquant_table[BitstreamGetBits(bs,2)];
777                                  if (quant > 31)          if (quant > 31) {
                                 {  
778                                          quant = 31;                                          quant = 31;
779                                  }          } else if (quant < 1) {
                                 else if (quant < 1)  
                                 {  
780                                          quant = 1;                                          quant = 1;
781                                  }                                  }
782                          }                          }
783                          mb->quant = quant;                          mb->quant = quant;
784          mb->mvs[0].x = mb->mvs[0].y =
785          mb->mvs[1].x = mb->mvs[1].y =
786          mb->mvs[2].x = mb->mvs[2].y =
787          mb->mvs[3].x = mb->mvs[3].y =0;
788    
789          if (dec->interlacing) {
790            mb->field_dct = BitstreamGetBit(bs);
791            DPRINTF(XVID_DEBUG_MB,"deci: field_dct: %i\n", mb->field_dct);
792          }
793    
794          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
795                  intra_dc_threshold, bound);
796    
                         decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant, intra_dc_threshold);  
797                  }                  }
798        if(dec->out_frm)
799          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,mb_width);
800          }          }
801    
802  }  }
803    
804    
805  void get_motion_vector(DECODER *dec, Bitstream *bs, int x, int y, int k, VECTOR * mv, int fcode)  static void
806    get_motion_vector(DECODER * dec,
807            Bitstream * bs,
808            int x,
809            int y,
810            int k,
811            VECTOR * ret_mv,
812            int fcode,
813            const int bound)
814  {  {
         int scale_fac = 1 << (fcode - 1);  
         int high = (32 * scale_fac) - 1;  
         int low = ((-32) * scale_fac);  
         int range = (64 * scale_fac);  
815    
816          VECTOR pmv[4];    const int scale_fac = 1 << (fcode - 1);
817          uint32_t psad[4];    const int high = (32 * scale_fac) - 1;
818      const int low = ((-32) * scale_fac);
819      const int range = (64 * scale_fac);
820    
821          int mv_x, mv_y;    const VECTOR pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
822          int pmv_x, pmv_y;    VECTOR mv;
823    
824      mv.x = get_mv(bs, fcode);
825      mv.y = get_mv(bs, fcode);
826    
827          get_pmvdata(dec->mbs, x, y, dec->mb_width, k, pmv, psad);    DPRINTF(XVID_DEBUG_MV,"mv_diff (%i,%i) pred (%i,%i) result (%i,%i)\n", mv.x, mv.y, pmv.x, pmv.y, mv.x+pmv.x, mv.y+pmv.y);
828    
829          pmv_x = pmv[0].x;    mv.x += pmv.x;
830          pmv_y = pmv[0].y;    mv.y += pmv.y;
831    
832          mv_x = get_mv(bs, fcode);    if (mv.x < low) {
833          mv_y = get_mv(bs, fcode);      mv.x += range;
834      } else if (mv.x > high) {
835        mv.x -= range;
836      }
837    
838          mv_x += pmv_x;    if (mv.y < low) {
839          mv_y += pmv_y;      mv.y += range;
840      } else if (mv.y > high) {
841        mv.y -= range;
842      }
843    
844          if (mv_x < low)    ret_mv->x = mv.x;
845          {    ret_mv->y = mv.y;
                 mv_x += range;  
846          }          }
847          else if (mv_x > high)  
848    /* We use this when decoder runs interlaced -> different prediction */
849    
850    static void get_motion_vector_interlaced(DECODER * dec,
851            Bitstream * bs,
852            int x,
853            int y,
854            int k,
855            MACROBLOCK *pMB,
856            int fcode,
857            const int bound)
858          {          {
859                  mv_x -= range;    const int scale_fac = 1 << (fcode - 1);
860          }    const int high = (32 * scale_fac) - 1;
861      const int low = ((-32) * scale_fac);
862      const int range = (64 * scale_fac);
863    
864          if (mv_y < low)    /* Get interlaced prediction */
865      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
866      VECTOR mv,mvf1,mvf2;
867    
868      if(!pMB->field_pred)
869          {          {
870                  mv_y += range;      mv.x = get_mv(bs,fcode);
871        mv.y = get_mv(bs,fcode);
872    
873        mv.x += pmv.x;
874        mv.y += pmv.y;
875    
876        if(mv.x<low) {
877          mv.x += range;
878        } else if (mv.x>high) {
879          mv.x-=range;
880          }          }
881          else if (mv_y > high)  
882        if (mv.y < low) {
883          mv.y += range;
884        } else if (mv.y > high) {
885          mv.y -= range;
886        }
887    
888        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
889      }
890      else
891          {          {
892                  mv_y -= range;      mvf1.x = get_mv(bs, fcode);
893        mvf1.y = get_mv(bs, fcode);
894    
895        mvf1.x += pmv.x;
896        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
897    
898        if (mvf1.x < low) {
899          mvf1.x += range;
900        } else if (mvf1.x > high) {
901          mvf1.x -= range;
902          }          }
903    
904          mv->x = mv_x;      if (mvf1.y < low) {
905          mv->y = mv_y;        mvf1.y += range;
906        } else if (mvf1.y > high) {
907          mvf1.y -= range;
908        }
909    
910        mvf2.x = get_mv(bs, fcode);
911        mvf2.y = get_mv(bs, fcode);
912    
913        mvf2.x += pmv.x;
914        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
915    
916        if (mvf2.x < low) {
917          mvf2.x += range;
918        } else if (mvf2.x > high) {
919          mvf2.x -= range;
920  }  }
921    
922        if (mvf2.y < low) {
923          mvf2.y += range;
924        } else if (mvf2.y > high) {
925          mvf2.y -= range;
926        }
927    
928  void decoder_pframe(DECODER * dec, Bitstream * bs, int rounding, int quant, int fcode, int intra_dc_threshold)      pMB->mvs[0]=mvf1;
929        pMB->mvs[1]=mvf2;
930        pMB->mvs[2].x=pMB->mvs[3].x=0;
931        pMB->mvs[2].y=pMB->mvs[3].y=0;
932    
933        /* Calculate average for as it is field predicted */
934        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
935        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
936      }
937    }
938    
939    /* for P_VOP set gmc_warp to NULL */
940    static void
941    decoder_pframe(DECODER * dec,
942            Bitstream * bs,
943            int rounding,
944            int quant,
945            int fcode,
946            int intra_dc_threshold,
947            const WARPPOINTS *const gmc_warp)
948  {  {
949          uint32_t x, y;          uint32_t x, y;
950      uint32_t bound;
951      int cp_mb, st_mb;
952      const uint32_t mb_width = dec->mb_width;
953      const uint32_t mb_height = dec->mb_height;
954    
955          image_swap(&dec->cur, &dec->refn);    if (!dec->is_edged[0]) {
   
956          start_timer();          start_timer();
957          image_setedges(&dec->refn, dec->edged_width, dec->edged_height, dec->width, dec->height);      image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
958                dec->width, dec->height, dec->bs_version);
959        dec->is_edged[0] = 1;
960          stop_edges_timer();          stop_edges_timer();
961      }
962    
963          for (y = 0; y < dec->mb_height; y++)    if (gmc_warp) {
964          {      /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
965                  for (x = 0; x < dec->mb_width; x++)      generate_GMCparameters( dec->sprite_warping_points,
966                  {          dec->sprite_warping_accuracy, gmc_warp,
967                          MACROBLOCK * mb = &dec->mbs[y*dec->mb_width + x];          dec->width, dec->height, &dec->new_gmc_data);
968    
969                          if (!BitstreamGetBit(bs))                       // not_coded      /* image warping is done block-based in decoder_mbgmc(), now */
970                          {    }
971                                  uint32_t mcbpc;  
972                                  uint32_t cbpc;    bound = 0;
                                 uint32_t acpred_flag;  
                                 uint32_t cbpy;  
                                 uint32_t cbp;  
                                 uint32_t intra;  
973    
974      for (y = 0; y < mb_height; y++) {
975        cp_mb = st_mb = 0;
976        for (x = 0; x < mb_width; x++) {
977          MACROBLOCK *mb;
978    
979          /* skip stuffing */
980          while (BitstreamShowBits(bs, 10) == 1)
981            BitstreamSkip(bs, 10);
982    
983          if (check_resync_marker(bs, fcode - 1)) {
984            bound = read_video_packet_header(bs, dec, fcode - 1,
985              &quant, &fcode, NULL, &intra_dc_threshold);
986            x = bound % mb_width;
987            y = MIN((bound / mb_width), (mb_height-1));
988          }
989          mb = &dec->mbs[y * dec->mb_width + x];
990    
991          DPRINTF(XVID_DEBUG_MB, "macroblock (%i,%i) %08x\n", x, y, BitstreamShowBits(bs, 32));
992    
993          if (!(BitstreamGetBit(bs))) { /* block _is_ coded */
994            uint32_t mcbpc, cbpc, cbpy, cbp;
995            uint32_t intra, acpred_flag = 0;
996            int mcsel = 0;    /* mcsel: '0'=local motion, '1'=GMC */
997    
998            cp_mb++;
999                                  mcbpc = get_mcbpc_inter(bs);                                  mcbpc = get_mcbpc_inter(bs);
1000                                  mb->mode = mcbpc & 7;                                  mb->mode = mcbpc & 7;
1001                                  cbpc = (mcbpc >> 4);                                  cbpc = (mcbpc >> 4);
1002    
1003            DPRINTF(XVID_DEBUG_MB, "mode %i\n", mb->mode);
1004            DPRINTF(XVID_DEBUG_MB, "cbpc %i\n", cbpc);
1005    
1006                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);
1007    
1008                                  if (intra)          if (gmc_warp && (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q))
1009                                  {            mcsel = BitstreamGetBit(bs);
1010            else if (intra)
1011                                          acpred_flag = BitstreamGetBit(bs);                                          acpred_flag = BitstreamGetBit(bs);
                                 }  
   
                                 if (mb->mode == MODE_STUFFING)  
                                 {  
                                         DEBUG("-- STUFFING ?");  
                                         continue;  
                                 }  
1012    
1013                                  cbpy = get_cbpy(bs, intra);                                  cbpy = get_cbpy(bs, intra);
1014            DPRINTF(XVID_DEBUG_MB, "cbpy %i mcsel %i \n", cbpy,mcsel);
1015    
1016                                  cbp = (cbpy << 2) | cbpc;                                  cbp = (cbpy << 2) | cbpc;
1017    
1018                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q)          if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {
1019                                  {            int dquant = dquant_table[BitstreamGetBits(bs, 2)];
1020                                          quant += dquant_table[BitstreamGetBits(bs,2)];            DPRINTF(XVID_DEBUG_MB, "dquant %i\n", dquant);
1021                                          if (quant > 31)            quant += dquant;
1022                                          {            if (quant > 31) {
1023                                                  quant = 31;                                                  quant = 31;
1024                                          }            } else if (quant < 1) {
                                         else if (mb->quant < 1)  
                                         {  
1025                                                  quant = 1;                                                  quant = 1;
1026                                          }                                          }
1027              DPRINTF(XVID_DEBUG_MB, "quant %i\n", quant);
1028                                  }                                  }
1029                                  mb->quant = quant;                                  mb->quant = quant;
1030    
1031                                  if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q)          mb->field_pred=0;
1032                                  {          if (dec->interlacing) {
1033              if (cbp || intra) {
1034                mb->field_dct = BitstreamGetBit(bs);
1035                DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1036              }
1037    
1038                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);            if ((mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) && !mcsel) {
1039                                          mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;              mb->field_pred = BitstreamGetBit(bs);
1040                                          mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;              DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1041    
1042                if (mb->field_pred) {
1043                  mb->field_for_top = BitstreamGetBit(bs);
1044                  DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1045                  mb->field_for_bot = BitstreamGetBit(bs);
1046                  DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1047                                  }                                  }
                                 else if (mb->mode == MODE_INTER4V /* || mb->mode == MODE_INTER4V_Q */)  
                                 {  
                                         get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode);  
                                         get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode);  
                                         get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode);  
                                         get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode);  
1048                                  }                                  }
1049                                  else  // MODE_INTRA, MODE_INTRA_Q          }
1050                                  {  
1051            if (mcsel) {
1052              decoder_mbgmc(dec, mb, x, y, fcode, cbp, bs, rounding);
1053              continue;
1054    
1055            } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1056    
1057              if(dec->interlacing) {
1058                /* Get motion vectors interlaced, field_pred is handled there */
1059                get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1060              } else {
1061                get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1062                mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1063              }
1064            } else if (mb->mode == MODE_INTER4V ) {
1065              /* interlaced missing here */
1066              get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1067              get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
1068              get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
1069              get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
1070            } else { /* MODE_INTRA, MODE_INTRA_Q */
1071                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1072                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1073                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant, intra_dc_threshold);            decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1074                      intra_dc_threshold, bound);
1075                                          continue;                                          continue;
1076                                  }                                  }
1077    
1078                                  decoder_mbinter(dec, mb, x, y, acpred_flag, cbp, bs, quant, rounding);          /* See how to decode */
1079                          }          if(!mb->field_pred)
1080                          else    // not coded           decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1081                          {          else
1082             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1083    
1084          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1085            mb->mode = MODE_NOT_CODED_GMC;
1086            mb->quant = quant;
1087            decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
1088    
1089            if(dec->out_frm && cp_mb > 0) {
1090              output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1091              cp_mb = 0;
1092            }
1093            st_mb = x+1;
1094          } else { /* not coded P_VOP macroblock */
1095                                  mb->mode = MODE_NOT_CODED;                                  mb->mode = MODE_NOT_CODED;
1096            mb->quant = quant;
1097    
1098                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1099                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1100            mb->field_pred=0; /* (!) */
1101    
1102            decoder_mbinter(dec, mb, x, y, 0, bs,
1103                                    rounding, 0, 0);
1104    
1105                                  // copy macroblock directly from ref to cur          if(dec->out_frm && cp_mb > 0) {
1106              output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1107              cp_mb = 0;
1108            }
1109            st_mb = x+1;
1110          }
1111        }
1112    
1113        if(dec->out_frm && cp_mb > 0)
1114          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
1115      }
1116    }
1117    
1118    
1119    /* decode B-frame motion vector */
1120    static void
1121    get_b_motion_vector(Bitstream * bs,
1122              VECTOR * mv,
1123              int fcode,
1124              const VECTOR pmv,
1125              const DECODER * const dec,
1126              const int x, const int y)
1127    {
1128      const int scale_fac = 1 << (fcode - 1);
1129      const int high = (32 * scale_fac) - 1;
1130      const int low = ((-32) * scale_fac);
1131      const int range = (64 * scale_fac);
1132    
1133      int mv_x = get_mv(bs, fcode);
1134      int mv_y = get_mv(bs, fcode);
1135    
1136      mv_x += pmv.x;
1137      mv_y += pmv.y;
1138    
1139      if (mv_x < low)
1140        mv_x += range;
1141      else if (mv_x > high)
1142        mv_x -= range;
1143    
1144      if (mv_y < low)
1145        mv_y += range;
1146      else if (mv_y > high)
1147        mv_y -= range;
1148    
1149      mv->x = mv_x;
1150      mv->y = mv_y;
1151    }
1152    
1153    /* decode an B-frame direct & interpolate macroblock */
1154    static void
1155    decoder_bf_interpolate_mbinter(DECODER * dec,
1156                    IMAGE forward,
1157                    IMAGE backward,
1158                    MACROBLOCK * pMB,
1159                    const uint32_t x_pos,
1160                    const uint32_t y_pos,
1161                    Bitstream * bs,
1162                    const int direct)
1163    {
1164      uint32_t stride = dec->edged_width;
1165      uint32_t stride2 = stride / 2;
1166      int uv_dx, uv_dy;
1167      int b_uv_dx, b_uv_dy;
1168      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
1169      const uint32_t cbp = pMB->cbp;
1170    
1171      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
1172      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
1173      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
1174    
1175      validate_vector(pMB->mvs, x_pos, y_pos, dec);
1176      validate_vector(pMB->b_mvs, x_pos, y_pos, dec);
1177    
1178      if (!direct) {
1179        uv_dx = pMB->mvs[0].x;
1180        uv_dy = pMB->mvs[0].y;
1181        b_uv_dx = pMB->b_mvs[0].x;
1182        b_uv_dy = pMB->b_mvs[0].y;
1183    
1184        if (dec->quarterpel) {
1185                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1186                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1187                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1188                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1189                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1190                            }
1191                            else {
1192            uv_dx /= 2;
1193            uv_dy /= 2;
1194            b_uv_dx /= 2;
1195            b_uv_dy /= 2;
1196          }
1197        }
1198    
1199        uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1200        uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
1201        b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];
1202        b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
1203    
1204      } else {
1205              if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1206                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1207                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1208                            int z;
1209                            uv_dx = 0; uv_dy = 0;
1210                            b_uv_dx = 0; b_uv_dy = 0;
1211                            for (z = 0; z < 4; z++) {
1212                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1213                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1214                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1215                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1216                            }
1217                    }
1218                    else {
1219                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1220                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1221                            b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1222                            b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1223                    }
1224            } else {
1225          uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1226          uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1227          b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1228          b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;
1229        }
1230    
1231        uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
1232        uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
1233        b_uv_dx = (b_uv_dx >> 3) + roundtab_76[b_uv_dx & 0xf];
1234        b_uv_dy = (b_uv_dy >> 3) + roundtab_76[b_uv_dy & 0xf];
1235      }
1236    
1237                                  start_timer();                                  start_timer();
1238      if(dec->quarterpel) {
1239        if(!direct) {
1240          interpolate16x16_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1241                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1242                        pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1243        } else {
1244          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1245                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1246                        pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1247          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1248                        dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1249                        pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1250          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1251                        dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1252                        pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1253          interpolate8x8_quarterpel(dec->cur.y, forward.y, dec->qtmp.y, dec->qtmp.y + 64,
1254                        dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1255                        pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1256        }
1257      } else {
1258        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos,
1259                  pMB->mvs[0].x, pMB->mvs[0].y, stride, 0);
1260        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos,
1261                  pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);
1262        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos, 16 * y_pos + 8,
1263                  pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1264        interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos + 8,
1265                  pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);
1266      }
1267    
1268      interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
1269                uv_dy, stride2, 0);
1270      interpolate8x8_switch(dec->cur.v, forward.v, 8 * x_pos, 8 * y_pos, uv_dx,
1271                uv_dy, stride2, 0);
1272    
1273    
1274      if(dec->quarterpel) {
1275        if(!direct) {
1276          interpolate16x16_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1277              dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1278              pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1279        } else {
1280          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1281              dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1282              pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1283          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1284              dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1285              pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1286          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1287              dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1288              pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1289          interpolate8x8_add_quarterpel(dec->cur.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,
1290              dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1291              pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1292        }
1293      } else {
1294        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos, 16 * y_pos,
1295            pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1296        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1297            16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1298        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos,
1299            16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1300        interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1301            16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1302      }
1303    
1304      interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1305          b_uv_dx, b_uv_dy, stride2, 0);
1306      interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1307          b_uv_dx, b_uv_dy, stride2, 0);
1308    
1309                                  transfer8x8_copy(dec->cur.y + (16*y)*dec->edged_width + (16*x),    stop_comp_timer();
                                                                 dec->refn.y + (16*y)*dec->edged_width + (16*x),  
                                                                 dec->edged_width);  
1310    
1311                                  transfer8x8_copy(dec->cur.y + (16*y)*dec->edged_width + (16*x+8),    if (cbp)
1312                                                                  dec->refn.y + (16*y)*dec->edged_width + (16*x+8),      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1313                                                                  dec->edged_width);  }
1314    
1315                                  transfer8x8_copy(dec->cur.y + (16*y+8)*dec->edged_width + (16*x),  /* for decode B-frame dbquant */
1316                                                                  dec->refn.y + (16*y+8)*dec->edged_width + (16*x),  static __inline int32_t
1317                                                                  dec->edged_width);  get_dbquant(Bitstream * bs)
1318    {
1319      if (!BitstreamGetBit(bs))   /*  '0' */
1320        return (0);
1321      else if (!BitstreamGetBit(bs))  /* '10' */
1322        return (-2);
1323      else              /* '11' */
1324        return (2);
1325    }
1326    
1327    /*
1328     * decode B-frame mb_type
1329     * bit    ret_value
1330     * 1    0
1331     * 01   1
1332     * 001    2
1333     * 0001   3
1334     */
1335    static int32_t __inline
1336    get_mbtype(Bitstream * bs)
1337    {
1338      int32_t mb_type;
1339    
1340      for (mb_type = 0; mb_type <= 3; mb_type++)
1341        if (BitstreamGetBit(bs))
1342          return (mb_type);
1343    
1344      return -1;
1345    }
1346    
1347    static int __inline get_resync_len_b(const int fcode_backward,
1348                                         const int fcode_forward) {
1349      int resync_len = ((fcode_forward>fcode_backward) ? fcode_forward : fcode_backward) - 1;
1350      if (resync_len < 1) resync_len = 1;
1351      return resync_len;
1352    }
1353    
1354    static void
1355    decoder_bframe(DECODER * dec,
1356            Bitstream * bs,
1357            int quant,
1358            int fcode_forward,
1359            int fcode_backward)
1360    {
1361      uint32_t x, y;
1362      VECTOR mv;
1363      const VECTOR zeromv = {0,0};
1364      int i;
1365      int resync_len;
1366    
1367                                  transfer8x8_copy(dec->cur.y + (16*y+8)*dec->edged_width + (16*x+8),    if (!dec->is_edged[0]) {
1368                                                                  dec->refn.y + (16*y+8)*dec->edged_width + (16*x+8),      start_timer();
1369                                                                  dec->edged_width);      image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1370                dec->width, dec->height, dec->bs_version);
1371        dec->is_edged[0] = 1;
1372        stop_edges_timer();
1373      }
1374    
1375                                  transfer8x8_copy(dec->cur.u + (8*y)*dec->edged_width/2 + (8*x),    if (!dec->is_edged[1]) {
1376                                                                  dec->refn.u + (8*y)*dec->edged_width/2 + (8*x),      start_timer();
1377                                                                  dec->edged_width/2);      image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1378                dec->width, dec->height, dec->bs_version);
1379        dec->is_edged[1] = 1;
1380        stop_edges_timer();
1381      }
1382    
1383                                  transfer8x8_copy(dec->cur.v + (8*y)*dec->edged_width/2 + (8*x),    resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1384                                                                  dec->refn.v + (8*y)*dec->edged_width/2 + (8*x),    for (y = 0; y < dec->mb_height; y++) {
1385                                                                  dec->edged_width/2);      /* Initialize Pred Motion Vector */
1386        dec->p_fmv = dec->p_bmv = zeromv;
1387        for (x = 0; x < dec->mb_width; x++) {
1388          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1389          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1390          int intra_dc_threshold; /* fake variable */
1391    
1392                                  stop_transfer_timer();        if (check_resync_marker(bs, resync_len)) {
1393            int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1394                               &fcode_forward, &fcode_backward, &intra_dc_threshold);
1395            x = bound % dec->mb_width;
1396            y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1397            /* reset predicted macroblocks */
1398            dec->p_fmv = dec->p_bmv = zeromv;
1399            /* update resync len with new fcodes */
1400            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1401          }
1402    
1403          mv =
1404          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1405          mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1406          mb->quant = quant;
1407    
1408          /*
1409           * skip if the co-located P_VOP macroblock is not coded
1410           * if not codec in co-located S_VOP macroblock is _not_
1411           * automatically skipped
1412           */
1413    
1414          if (last_mb->mode == MODE_NOT_CODED) {
1415            mb->cbp = 0;
1416            mb->mode = MODE_FORWARD;
1417            decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1418            continue;
1419                          }                          }
1420    
1421          if (!BitstreamGetBit(bs)) { /* modb=='0' */
1422            const uint8_t modb2 = BitstreamGetBit(bs);
1423    
1424            mb->mode = get_mbtype(bs);
1425    
1426            if (!modb2)   /* modb=='00' */
1427              mb->cbp = BitstreamGetBits(bs, 6);
1428            else
1429              mb->cbp = 0;
1430    
1431            if (mb->mode && mb->cbp) {
1432              quant += get_dbquant(bs);
1433              if (quant > 31)
1434                quant = 31;
1435              else if (quant < 1)
1436                quant = 1;
1437                  }                  }
1438            mb->quant = quant;
1439    
1440            if (dec->interlacing) {
1441              if (mb->cbp) {
1442                mb->field_dct = BitstreamGetBit(bs);
1443                DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1444          }          }
1445    
1446              if (mb->mode) {
1447                mb->field_pred = BitstreamGetBit(bs);
1448                DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1449    
1450                if (mb->field_pred) {
1451                  mb->field_for_top = BitstreamGetBit(bs);
1452                  DPRINTF(XVID_DEBUG_MB,"decp: field_for_top: %i\n", mb->field_for_top);
1453                  mb->field_for_bot = BitstreamGetBit(bs);
1454                  DPRINTF(XVID_DEBUG_MB,"decp: field_for_bot: %i\n", mb->field_for_bot);
1455  }  }
1456              }
1457            }
1458    
1459          } else {
1460            mb->mode = MODE_DIRECT_NONE_MV;
1461            mb->cbp = 0;
1462          }
1463    
1464          switch (mb->mode) {
1465          case MODE_DIRECT:
1466            get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);
1467    
1468  int decoder_decode(DECODER * dec, XVID_DEC_FRAME * frame)        case MODE_DIRECT_NONE_MV:
1469            for (i = 0; i < 4; i++) {
1470              mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1471              mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1472    
1473              mb->b_mvs[i].x = (mv.x)
1474                ?  mb->mvs[i].x - last_mb->mvs[i].x
1475                : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1476              mb->b_mvs[i].y = (mv.y)
1477                ? mb->mvs[i].y - last_mb->mvs[i].y
1478                : last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
1479            }
1480    
1481            decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1482                            mb, x, y, bs, 1);
1483            break;
1484    
1485          case MODE_INTERPOLATE:
1486            get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1487            dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1488    
1489            get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1490            dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] = mb->b_mvs[0];
1491    
1492            decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1493                          mb, x, y, bs, 0);
1494            break;
1495    
1496          case MODE_BACKWARD:
1497            get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1498            dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1499    
1500            decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1501            break;
1502    
1503          case MODE_FORWARD:
1504            get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1505            dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1506    
1507            decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1508            break;
1509    
1510          default:
1511            DPRINTF(XVID_DEBUG_ERROR,"Not supported B-frame mb_type = %i\n", mb->mode);
1512          }
1513        } /* End of for */
1514      }
1515    }
1516    
1517    /* perform post processing if necessary, and output the image */
1518    static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1519              xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1520              int coding_type, int quant)
1521  {  {
1522      const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1523    
1524      if (dec->cartoon_mode)
1525        frame->general &= ~XVID_FILMEFFECT;
1526    
1527      if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1528        && mbs != NULL) /* post process */
1529      {
1530        /* note: image is stored to tmp */
1531        image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1532        image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1533                 mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1534                 frame->general, brightness, dec->frames, (coding_type == B_VOP));
1535        img = &dec->tmp;
1536      }
1537    
1538      image_output(img, dec->width, dec->height,
1539             dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,
1540             frame->output.csp, dec->interlacing);
1541    
1542      if (stats) {
1543        stats->type = coding2type(coding_type);
1544        stats->data.vop.time_base = (int)dec->time_base;
1545        stats->data.vop.time_increment = 0; /* XXX: todo */
1546        stats->data.vop.qscale_stride = dec->mb_width;
1547        stats->data.vop.qscale = dec->qscale;
1548        if (stats->data.vop.qscale != NULL && mbs != NULL) {
1549          unsigned int i;
1550          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1551            stats->data.vop.qscale[i] = mbs[i].quant;
1552        } else
1553          stats->data.vop.qscale = NULL;
1554      }
1555    }
1556    
1557    int
1558    decoder_decode(DECODER * dec,
1559            xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
1560    {
1561    
1562          Bitstream bs;          Bitstream bs;
1563          uint32_t rounding;          uint32_t rounding;
1564          uint32_t quant;    uint32_t quant = 2;
1565          uint32_t fcode;    uint32_t fcode_forward;
1566      uint32_t fcode_backward;
1567          uint32_t intra_dc_threshold;          uint32_t intra_dc_threshold;
1568      WARPPOINTS gmc_warp;
1569      int coding_type;
1570      int success, output, seen_something;
1571    
1572      if (XVID_VERSION_MAJOR(frame->version) != 1 || (stats && XVID_VERSION_MAJOR(stats->version) != 1))  /* v1.x.x */
1573        return XVID_ERR_VERSION;
1574    
1575          start_global_timer();          start_global_timer();
1576    
1577      dec->low_delay_default = (frame->general & XVID_LOWDELAY);
1578      if ((frame->general & XVID_DISCONTINUITY))
1579        dec->frames = 0;
1580      dec->out_frm = (frame->output.csp == XVID_CSP_SLICE) ? &frame->output : NULL;
1581    
1582      if(frame->length<0) {  /* decoder flush */
1583        int ret;
1584        /* if not decoding "low_delay/packed", and this isn't low_delay and
1585          we have a reference frame, then outout the reference frame */
1586        if (!(dec->low_delay_default && dec->packed_mode) && !dec->low_delay && dec->frames>0) {
1587          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1588          dec->frames = 0;
1589          ret = 0;
1590        } else {
1591          if (stats) stats->type = XVID_TYPE_NOTHING;
1592          ret = XVID_ERR_END;
1593        }
1594    
1595        emms();
1596        stop_global_timer();
1597        return ret;
1598      }
1599    
1600          BitstreamInit(&bs, frame->bitstream, frame->length);          BitstreamInit(&bs, frame->bitstream, frame->length);
1601    
1602          switch (BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode, &intra_dc_threshold))    /* XXX: 0x7f is only valid whilst decoding vfw xvid/divx5 avi's */
1603      if(dec->low_delay_default && frame->length == 1 && BitstreamShowBits(&bs, 8) == 0x7f)
1604          {          {
1605          case P_VOP :      image_output(&dec->refn[0], dec->width, dec->height, dec->edged_width,
1606                  decoder_pframe(dec, &bs, rounding, quant, fcode, intra_dc_threshold);             (uint8_t**)frame->output.plane, frame->output.stride, frame->output.csp, dec->interlacing);
1607                  break;      if (stats) stats->type = XVID_TYPE_NOTHING;
1608        emms();
1609        return 1; /* one byte consumed */
1610      }
1611    
1612      success = 0;
1613      output = 0;
1614      seen_something = 0;
1615    
1616    repeat:
1617    
1618      coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1619          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1620    
1621      DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%"
1622    #if defined(_MSC_VER)
1623        "I64"
1624    #else
1625        "ll"
1626    #endif
1627        "i,  time_pp=%i,  time_bp=%i\n",
1628                  coding_type,  dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1629    
1630      if (coding_type == -1) { /* nothing */
1631        if (success) goto done;
1632        if (stats) stats->type = XVID_TYPE_NOTHING;
1633        emms();
1634        return BitstreamPos(&bs)/8;
1635      }
1636    
1637      if (coding_type == -2 || coding_type == -3) { /* vol and/or resize */
1638    
1639        if (coding_type == -3)
1640          if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1641    
1642        if(stats) {
1643          stats->type = XVID_TYPE_VOL;
1644          stats->data.vol.general = 0;
1645          /*XXX: if (dec->interlacing)
1646            stats->data.vol.general |= ++INTERLACING; */
1647          stats->data.vol.width = dec->width;
1648          stats->data.vol.height = dec->height;
1649          stats->data.vol.par = dec->aspect_ratio;
1650          stats->data.vol.par_width = dec->par_width;
1651          stats->data.vol.par_height = dec->par_height;
1652          emms();
1653          return BitstreamPos(&bs)/8; /* number of bytes consumed */
1654        }
1655        goto repeat;
1656      }
1657    
1658      if(dec->frames == 0 && coding_type != I_VOP) {
1659        /* 1st frame is not an i-vop */
1660        goto repeat;
1661      }
1662    
1663      dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1664    
1665      /* packed_mode: special-N_VOP treament */
1666      if (dec->packed_mode && coding_type == N_VOP) {
1667        if (dec->low_delay_default && dec->frames > 0) {
1668          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1669          output = 1;
1670        }
1671        /* ignore otherwise */
1672      } else if (coding_type != B_VOP) {
1673        switch(coding_type) {
1674          case I_VOP :          case I_VOP :
                 //DEBUG1("",intra_dc_threshold);  
1675                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1676                  break;                  break;
1677        case P_VOP :
1678          case B_VOP :    // ignore        decoder_pframe(dec, &bs, rounding, quant,
1679                            fcode_forward, intra_dc_threshold, NULL);
1680                  break;                  break;
1681        case S_VOP :
1682          case N_VOP :    // vop not coded        decoder_pframe(dec, &bs, rounding, quant,
1683                            fcode_forward, intra_dc_threshold, &gmc_warp);
1684          break;
1685        case N_VOP :
1686          /* XXX: not_coded vops are not used for forward prediction */
1687          /* we should not swap(last_mbs,mbs) */
1688          image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1689          SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs); /* it will be swapped back */
1690                  break;                  break;
   
         default :  
                 return XVID_ERR_FAIL;  
1691          }          }
1692    
1693          frame->length = BitstreamPos(&bs) / 8;      /* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1694        if (!(dec->low_delay_default && dec->packed_mode)) {
1695          start_timer();        if(dec->low_delay) {
1696          image_output(&dec->cur, dec->width, dec->height, dec->edged_width,          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1697                                  frame->image, frame->stride, frame->colorspace);          output = 1;
1698          stop_conv_timer();        } else if (dec->frames > 0) { /* is the reference frame valid? */
1699            /* output the reference frame */
1700            decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1701            output = 1;
1702          }
1703        }
1704    
1705        image_swap(&dec->refn[0], &dec->refn[1]);
1706        dec->is_edged[1] = dec->is_edged[0];
1707        image_swap(&dec->cur, &dec->refn[0]);
1708        dec->is_edged[0] = 0;
1709        SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
1710        dec->last_coding_type = coding_type;
1711    
1712        dec->frames++;
1713        seen_something = 1;
1714    
1715      } else {  /* B_VOP */
1716    
1717        if (dec->low_delay) {
1718          DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1719          dec->low_delay = 0;
1720        }
1721    
1722        if (dec->frames < 2) {
1723          /* attemping to decode a bvop without atleast 2 reference frames */
1724          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1725                "broken b-frame, mising ref frames");
1726          if (stats) stats->type = XVID_TYPE_NOTHING;
1727        } else if (dec->time_pp <= dec->time_bp) {
1728          /* this occurs when dx50_bvop_compatibility==0 sequences are
1729          decoded in vfw. */
1730          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1731                "broken b-frame, tpp=%i tbp=%i", dec->time_pp, dec->time_bp);
1732          if (stats) stats->type = XVID_TYPE_NOTHING;
1733        } else {
1734          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1735          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1736        }
1737    
1738        output = 1;
1739        dec->frames++;
1740      }
1741    
1742    #if 0 /* Avoids to read to much data because of 32bit reads in our BS functions */
1743       BitstreamByteAlign(&bs);
1744    #endif
1745    
1746      /* low_delay_default mode: repeat in packed_mode */
1747      if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {
1748        success = 1;
1749        goto repeat;
1750      }
1751    
1752    done :
1753    
1754      /* if we reach here without outputing anything _and_
1755         the calling application has specified low_delay_default,
1756         we *must* output something.
1757         this always occurs on the first call to decode() call
1758         when bframes are present in the bitstream. it may also
1759         occur if no vops  were seen in the bitstream
1760    
1761         if packed_mode is enabled, then we output the recently
1762         decoded frame (the very first ivop). otherwise we have
1763         nothing to display, and therefore output a black screen.
1764      */
1765      if (dec->low_delay_default && output == 0) {
1766        if (dec->packed_mode && seen_something) {
1767          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1768        } else {
1769          image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);
1770          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1771          if (stats) stats->type = XVID_TYPE_NOTHING;
1772        }
1773      }
1774    
1775          emms();          emms();
   
1776          stop_global_timer();          stop_global_timer();
1777    
1778          return XVID_ERR_OK;    return (BitstreamPos(&bs)+7)/8; /* number of bytes consumed */
1779  }  }

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.82

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