[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.49.2.19, Thu Nov 13 22:35:30 2003 UTC revision 1.84, Fri Nov 12 10:10:40 2010 UTC
# Line 4  Line 4 
4   *  - Decoder Module -   *  - Decoder Module -
5   *   *
6   *  Copyright(C) 2002      MinChen <chenm001@163.com>   *  Copyright(C) 2002      MinChen <chenm001@163.com>
7   *               2002-2003 Peter Ross <pross@xvid.org>   *               2002-2004 Peter Ross <pross@xvid.org>
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 41  Line 41 
41  #include "bitstream/mbcoding.h"  #include "bitstream/mbcoding.h"
42    
43  #include "quant/quant.h"  #include "quant/quant.h"
44    #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"
 #include "image/reduced.h"  
49  #include "image/font.h"  #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"
# Line 57  Line 58 
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"  #include "utils/mem_align.h"
63    
64    #define DIV2ROUND(n)  (((n)>>1)|((n)&1))
65    #define DIV2(n)       ((n)>>1)
66    #define DIVUVMOV(n) (((n) >> 1) + roundtab_79[(n) & 0x3]) //
67    
68  static int  static int
69  decoder_resize(DECODER * dec)  decoder_resize(DECODER * dec)
70  {  {
# Line 71  Line 77 
77    
78          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
79    
80          if (dec->last_mbs)    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);                  xvid_free(dec->last_mbs);
         if (dec->mbs)  
89                  xvid_free(dec->mbs);                  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 */          /* realloc */
96          dec->mb_width = (dec->width + 15) / 16;          dec->mb_width = (dec->width + 15) / 16;
# Line 83  Line 99 
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                  xvid_free(dec);              || image_create(&dec->refn[0], dec->edged_width, dec->edged_height)
104                  return XVID_ERR_MEMORY;              || 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          if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {        || image_create(&dec->gmc, dec->edged_width, dec->edged_height) )
108                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);      goto memory_error;
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         /* Support B-frame to reference last 2 frame */  
         if (image_create(&dec->refn[1], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
         if (image_create(&dec->tmp, dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         if (image_create(&dec->qtmp, dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         if (image_create(&dec->gmc, dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
109    
110          dec->mbs =          dec->mbs =
111                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
112                                          CACHE_LINE);                                          CACHE_LINE);
113          if (dec->mbs == NULL) {          if (dec->mbs == NULL)
114                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);            goto memory_error;
                 image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);  
                 image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
115          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
116    
117          /* For skip MB flag */          /* For skip MB flag */
118          dec->last_mbs =          dec->last_mbs =
119                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,                  xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,
120                                          CACHE_LINE);                                          CACHE_LINE);
121          if (dec->last_mbs == NULL) {          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);                  xvid_free(dec->mbs);
138                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);                  image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);                  image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141                  image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);                  image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142                  image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);                  image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143    
144                  xvid_free(dec);                  xvid_free(dec);
145                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
146          }          }
147    
         memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);  
   
         return 0;  
 }  
   
148    
149  int  int
150  decoder_create(xvid_dec_create_t * create)  decoder_create(xvid_dec_create_t * create)
# Line 175  Line 158 
158          if (dec == NULL) {          if (dec == NULL) {
159                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
160          }          }
161    
162          memset(dec, 0, sizeof(DECODER));          memset(dec, 0, sizeof(DECODER));
163    
164      dec->mpeg_quant_matrices = xvid_malloc(sizeof(uint16_t) * 64 * 8, CACHE_LINE);
165      if (dec->mpeg_quant_matrices == NULL) {
166        xvid_free(dec);
167        return XVID_ERR_MEMORY;
168      }
169    
170          create->handle = dec;          create->handle = dec;
171    
172          dec->width = create->width;          dec->width = create->width;
# Line 191  Line 181 
181          /* image based GMC */          /* image based GMC */
182          image_null(&dec->gmc);          image_null(&dec->gmc);
183    
   
184          dec->mbs = NULL;          dec->mbs = NULL;
185          dec->last_mbs = NULL;          dec->last_mbs = NULL;
186      dec->qscale = NULL;
187    
188          init_timer();          init_timer();
189      init_postproc(&dec->postproc);
190      init_mpeg_matrix(dec->mpeg_quant_matrices);
191    
192          /* For B-frame support (used to save reference frame's time */          /* For B-frame support (used to save reference frame's time */
193          dec->frames = 0;          dec->frames = 0;
194          dec->time = dec->time_base = dec->last_time_base = 0;          dec->time = dec->time_base = dec->last_time_base = 0;
195          dec->low_delay = 0;          dec->low_delay = 0;
196          dec->packed_mode = 0;          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 = 0; /* 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);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
209    
210          if (dec->fixed_dimensions)    if (dec->fixed_dimensions) {
211                  return decoder_resize(dec);      int ret = decoder_resize(dec);
212        if (ret == XVID_ERR_MEMORY) create->handle = NULL;
213        return ret;
214      }
215          else          else
216                  return 0;                  return 0;
217  }  }
# Line 217  Line 222 
222  {  {
223          xvid_free(dec->last_mbs);          xvid_free(dec->last_mbs);
224          xvid_free(dec->mbs);          xvid_free(dec->mbs);
225      xvid_free(dec->qscale);
226    
227          /* image based GMC */          /* image based GMC */
228          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);          image_destroy(&dec->gmc, dec->edged_width, dec->edged_height);
# Line 226  Line 232 
232          image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);          image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
233          image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);          image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
234          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);          image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
235      xvid_free(dec->mpeg_quant_matrices);
236          xvid_free(dec);          xvid_free(dec);
237    
238          write_timer();          write_timer();
# Line 247  Line 254 
254                                  Bitstream * bs,                                  Bitstream * bs,
255                                  const uint32_t quant,                                  const uint32_t quant,
256                                  const uint32_t intra_dc_threshold,                                  const uint32_t intra_dc_threshold,
257                                  const unsigned int bound,          const unsigned int bound)
                                 const int reduced_resolution)  
258  {  {
259    
260          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
# Line 261  Line 267 
267          uint32_t iQuant = pMB->quant;          uint32_t iQuant = pMB->quant;
268          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
269    
         if (reduced_resolution) {  
                 pY_Cur = dec->cur.y + (y_pos << 5) * stride + (x_pos << 5);  
                 pU_Cur = dec->cur.u + (y_pos << 4) * stride2 + (x_pos << 4);  
                 pV_Cur = dec->cur.v + (y_pos << 4) * stride2 + (x_pos << 4);  
         }else{  
270                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  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);                  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);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
         }  
273    
274          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */
275    
# Line 316  Line 316 
316                  stop_coding_timer();                  stop_coding_timer();
317    
318                  start_timer();                  start_timer();
319                  add_acdc(pMB, i, &block[i * 64], iDcScaler, 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);        dequant_h263_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
325                  } else {                  } else {
326                          dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);        dequant_mpeg_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler, dec->mpeg_quant_matrices);
327                  }                  }
328                  stop_iquant_timer();                  stop_iquant_timer();
329    
330                  start_timer();                  start_timer();
331                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
332                  stop_idct_timer();                  stop_idct_timer();
333    
334          }          }
# Line 339  Line 339 
339          }          }
340    
341          start_timer();          start_timer();
   
         if (reduced_resolution)  
         {  
                 next_block*=2;  
                 copy_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);  
                 copy_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);  
                 copy_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);  
                 copy_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);  
                 copy_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);  
                 copy_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);  
         }else{  
342                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
343                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
344                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
345                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
346                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
347                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
         }  
348          stop_transfer_timer();          stop_transfer_timer();
349  }  }
350    
# Line 367  Line 355 
355                                  uint8_t * pY_Cur,                                  uint8_t * pY_Cur,
356                                  uint8_t * pU_Cur,                                  uint8_t * pU_Cur,
357                                  uint8_t * pV_Cur,                                  uint8_t * pV_Cur,
                                 const int reduced_resolution,  
358                                  const MACROBLOCK * pMB)                                  const MACROBLOCK * pMB)
359  {  {
360          DECLARE_ALIGNED_MATRIX(block, 1, 64, int16_t, CACHE_LINE);    DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
         DECLARE_ALIGNED_MATRIX(data, 6, 64, int16_t, CACHE_LINE);  
361    
362          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * (reduced_resolution ? 16 : 8);  
         const int stride2 = stride/2;  
363          int i;          int i;
364          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
365          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
366          const quant_interFuncPtr dequant = dec->quant_type == 0 ? dequant_h263_inter : dequant_mpeg_inter;    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          for (i = 0; i < 6; i++) {    uint8_t *dst[6];
382      int strides[6];
383    
                 if (cbp & (1 << (5 - i))) {     /* coded */  
384    
385                          memset(block, 0, 64 * sizeof(int16_t)); /* clear */    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();                          start_timer();
416                          get_inter_block(bs, block, direction);        get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
417                          stop_coding_timer();                          stop_coding_timer();
418    
419          /* iDCT */
420                          start_timer();                          start_timer();
421                          dequant(&data[i * 64], block, iQuant);        idct((short * const)&data[0]);
422                          stop_iquant_timer();        stop_idct_timer();
423    
424          /* Add this residual to the predicted block */
425                          start_timer();                          start_timer();
426                          idct(&data[i * 64]);        transfer_16to8add(dst[i], &data[0], strides[i]);
427                          stop_idct_timer();        stop_transfer_timer();
428                  }                  }
429          }          }
   
         if (dec->interlacing && pMB->field_dct) {  
                 next_block = stride;  
                 stride *= 2;  
430          }          }
431    
432          start_timer();  static void __inline
433          if (reduced_resolution) {  validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
434                  if (cbp & 32)  {
435                          add_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);    /* clip a vector to valid range
436                  if (cbp & 16)       prevents crashes if bitstream is broken
437                          add_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);    */
438                  if (cbp & 8)    int shift = 5 + dec->quarterpel;
439                          add_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);    int xborder_high = (int)(dec->mb_width - x_pos) << shift;
440                  if (cbp & 4)    int xborder_low = (-(int)x_pos-1) << shift;
441                          add_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);    int yborder_high = (int)(dec->mb_height - y_pos) << shift;
442                  if (cbp & 2)    int yborder_low = (-(int)y_pos-1) << shift;
443                          add_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);  
444                  if (cbp & 1)  #define CHECK_MV(mv) \
445                          add_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);    do { \
446          } else {    if ((mv).x > xborder_high) { \
447                  if (cbp & 32)      DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
448                          transfer_16to8add(pY_Cur, &data[0 * 64], stride);      (mv).x = xborder_high; \
449                  if (cbp & 16)    } else if ((mv).x < xborder_low) { \
450                          transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);      DPRINTF(XVID_DEBUG_MV, "mv.x < min -- %d < %d, MB %d, %d", (mv).x, xborder_low, x_pos, y_pos); \
451                  if (cbp & 8)      (mv).x = xborder_low; \
452                          transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);    } \
453                  if (cbp & 4)    if ((mv).y > yborder_high) { \
454                          transfer_16to8add(pY_Cur + 8 + next_block, &data[3 * 64], stride);      DPRINTF(XVID_DEBUG_MV, "mv.y > max -- %d > %d, MB %d, %d", (mv).y, yborder_high, x_pos, y_pos); \
455                  if (cbp & 2)      (mv).y = yborder_high; \
456                          transfer_16to8add(pU_Cur, &data[4 * 64], stride2);    } else if ((mv).y < yborder_low) { \
457                  if (cbp & 1)      DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
458                          transfer_16to8add(pV_Cur, &data[5 * 64], stride2);      (mv).y = yborder_low; \
459          }    } \
460          stop_transfer_timer();    } 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 */  /* decode an inter macroblock */
473  static void  static void
# Line 446  Line 478 
478                                  const uint32_t cbp,                                  const uint32_t cbp,
479                                  Bitstream * bs,                                  Bitstream * bs,
480                                  const uint32_t rounding,                                  const uint32_t rounding,
481                                  const int reduced_resolution,          const int ref,
482                                  const int ref)                  const int bvop)
483  {  {
484          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
485          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 458  Line 490 
490          int uv_dx, uv_dy;          int uv_dx, uv_dy;
491          VECTOR mv[4];   /* local copy of mvs */          VECTOR mv[4];   /* local copy of mvs */
492    
         if (reduced_resolution) {  
                 pY_Cur = dec->cur.y + (y_pos << 5) * stride + (x_pos << 5);  
                 pU_Cur = dec->cur.u + (y_pos << 4) * stride2 + (x_pos << 4);  
                 pV_Cur = dec->cur.v + (y_pos << 4) * stride2 + (x_pos << 4);  
                 for (i = 0; i < 4; i++) {  
                         mv[i].x = RRV_MV_SCALEUP(pMB->mvs[i].x);  
                         mv[i].y = RRV_MV_SCALEUP(pMB->mvs[i].y);  
                 }  
         } else {  
493                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  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);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
495                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
496                  for (i = 0; i < 4; i++)                  for (i = 0; i < 4; i++)
497                          mv[i] = pMB->mvs[i];                          mv[i] = pMB->mvs[i];
498          }  
499      validate_vector(mv, x_pos, y_pos, dec);
500    
501          start_timer();          start_timer();
502    
503          if (pMB->mode != MODE_INTER4V) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */    if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
504    
505                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
506                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
507                  if (dec->quarterpel) {                  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;                          uv_dx /= 2;
514                          uv_dy /= 2;                          uv_dy /= 2;
515                  }                  }
516        }
517                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
518                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
519    
520                  if (reduced_resolution)      if (dec->quarterpel)
                         interpolate32x32_switch(dec->cur.y, dec->refn[0].y, 32*x_pos, 32*y_pos,  
                                                                         mv[0].x, mv[0].y, stride, rounding);  
                 else if (dec->quarterpel)  
521                          interpolate16x16_quarterpel(dec->cur.y, dec->refn[ref].y, dec->qtmp.y, dec->qtmp.y + 64,                          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,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
523                                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 501  Line 528 
528          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
529    
530                  if(dec->quarterpel) {                  if(dec->quarterpel) {
531                            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);                          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);                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
542          }
543                  } else {                  } else {
544                          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;                          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;                          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
# Line 511  Line 548 
548                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
549                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
550    
551                  if (reduced_resolution) {      if (dec->quarterpel) {
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y, 32*x_pos, 32*y_pos,  
                                                                 mv[0].x, mv[0].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y , 32*x_pos + 16, 32*y_pos,  
                                                                 mv[1].x, mv[1].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y , 32*x_pos, 32*y_pos + 16,  
                                                                 mv[2].x, mv[2].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.y, dec->refn[0].y , 32*x_pos + 16, 32*y_pos + 16,  
                                                                 mv[3].x, mv[3].y, stride, rounding);  
                         interpolate16x16_switch(dec->cur.u, dec->refn[0].u , 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
                         interpolate16x16_switch(dec->cur.v, dec->refn[0].v , 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
   
                 } else if (dec->quarterpel) {  
552                          interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y , dec->qtmp.y, dec->qtmp.y + 64,                          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,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
554                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 551  Line 574 
574          }          }
575    
576          /* chroma */          /* chroma */
         if (reduced_resolution) {  
                 interpolate16x16_switch(dec->cur.u, dec->refn[0].u, 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
                 interpolate16x16_switch(dec->cur.v, dec->refn[0].v, 16 * x_pos, 16 * y_pos,  
                                                                 uv_dx, uv_dy, stride2, rounding);  
         } else {  
577                  interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,                  interpolate8x8_switch(dec->cur.u, dec->refn[ref].u, 8 * x_pos, 8 * y_pos,
578                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
579                  interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,                  interpolate8x8_switch(dec->cur.v, dec->refn[ref].v, 8 * x_pos, 8 * y_pos,
580                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
581    
582      stop_comp_timer();
583    
584      if (cbp)
585        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
586    }
587    
588    /* decode an inter macroblock in field mode */
589    static void
590    decoder_mbinter_field(DECODER * dec,
591            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      validate_vector(mv, x_pos, y_pos, dec);
619    
620      start_timer();
621    
622      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
623      {
624        /* Prepare top field vector */
625        uvtop_dx = DIV2ROUND(mv[0].x);
626        uvtop_dy = DIV2ROUND(mv[0].y);
627    
628        /* Prepare bottom field vector */
629        uvbot_dx = DIV2ROUND(mv[1].x);
630        uvbot_dy = DIV2ROUND(mv[1].y);
631    
632        if(dec->quarterpel)
633        {
634          /* NOT supported */
635        }
636        else
637        {
638          /* 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        }
668      }
669      else
670      {
671        /* We don't expect 4 motion vectors in interlaced mode */
672          }          }
673    
674          stop_comp_timer();          stop_comp_timer();
675    
676      /* Must add error correction? */
677          if (cbp)          if (cbp)
678                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur,     decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
                                                         reduced_resolution, pMB);  
679  }  }
680    
681  static void  static void
# Line 614  Line 722 
722          stop_transfer_timer();          stop_transfer_timer();
723    
724          if (cbp)          if (cbp)
725                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, 0, pMB);      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
726    
727  }  }
728    
# Line 622  Line 730 
730  static void  static void
731  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
732                                  Bitstream * bs,                                  Bitstream * bs,
                                 int reduced_resolution,  
733                                  int quant,                                  int quant,
734                                  int intra_dc_threshold)                                  int intra_dc_threshold)
735  {  {
736          uint32_t bound;          uint32_t bound;
737          uint32_t x, y;          uint32_t x, y;
738          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
739          uint32_t mb_height = dec->mb_height;    const uint32_t mb_height = dec->mb_height;
   
         if (reduced_resolution) {  
                 mb_width = (dec->width + 31) / 32;  
                 mb_height = (dec->height + 31) / 32;  
         }  
740    
741          bound = 0;          bound = 0;
742    
# Line 655  Line 757 
757                                  bound = read_video_packet_header(bs, dec, 0,                                  bound = read_video_packet_header(bs, dec, 0,
758                                                          &quant, NULL, NULL, &intra_dc_threshold);                                                          &quant, NULL, NULL, &intra_dc_threshold);
759                                  x = bound % mb_width;                                  x = bound % mb_width;
760                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
761                          }                          }
762                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
763    
# Line 690  Line 792 
792                          }                          }
793    
794                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
795                                                          intra_dc_threshold, bound, reduced_resolution);                intra_dc_threshold, bound);
796    
797                  }                  }
798                  if(dec->out_frm)                  if(dec->out_frm)
# Line 743  Line 845 
845          ret_mv->y = mv.y;          ret_mv->y = mv.y;
846  }  }
847    
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      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      /* 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.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    
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        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        if (mvf1.y < low) {
905          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        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 */  /* for P_VOP set gmc_warp to NULL */
940  static void  static void
941  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
942                                  Bitstream * bs,                                  Bitstream * bs,
943                                  int rounding,                                  int rounding,
                                 int reduced_resolution,  
944                                  int quant,                                  int quant,
945                                  int fcode,                                  int fcode,
946                                  int intra_dc_threshold,                                  int intra_dc_threshold,
# Line 757  Line 949 
949          uint32_t x, y;          uint32_t x, y;
950          uint32_t bound;          uint32_t bound;
951          int cp_mb, st_mb;          int cp_mb, st_mb;
952          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
953          uint32_t mb_height = dec->mb_height;    const uint32_t mb_height = dec->mb_height;
   
         if (reduced_resolution) {  
                 mb_width = (dec->width + 31) / 32;  
                 mb_height = (dec->height + 31) / 32;  
         }  
954    
955      if (!dec->is_edged[0]) {
956          start_timer();          start_timer();
957          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
958                                          dec->width, dec->height);              dec->width, dec->height, dec->bs_version);
959        dec->is_edged[0] = 1;
960          stop_edges_timer();          stop_edges_timer();
961      }
962    
963          if (gmc_warp) {          if (gmc_warp) {
964                  /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */                  /* accuracy: 0==1/2, 1=1/4, 2=1/8, 3=1/16 */
# Line 794  Line 984 
984                                  bound = read_video_packet_header(bs, dec, fcode - 1,                                  bound = read_video_packet_header(bs, dec, fcode - 1,
985                                          &quant, &fcode, NULL, &intra_dc_threshold);                                          &quant, &fcode, NULL, &intra_dc_threshold);
986                                  x = bound % mb_width;                                  x = bound % mb_width;
987                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
988                          }                          }
989                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
990    
# Line 838  Line 1028 
1028                                  }                                  }
1029                                  mb->quant = quant;                                  mb->quant = quant;
1030    
1031            mb->field_pred=0;
1032                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1033                                          if ((cbp || intra) && !mcsel) {            if (cbp || intra) {
1034                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
1035                                                  DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);                                                  DPRINTF(XVID_DEBUG_MB,"decp: field_dct: %i\n", mb->field_dct);
1036                                          }                                          }
1037    
1038                                          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {            if ((mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) && !mcsel) {
1039                                                  mb->field_pred = BitstreamGetBit(bs);                                                  mb->field_pred = BitstreamGetBit(bs);
1040                                                  DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);                                                  DPRINTF(XVID_DEBUG_MB, "decp: field_pred: %i\n", mb->field_pred);
1041    
# Line 863  Line 1054 
1054    
1055                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1056    
1057                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1058                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1059                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1], fcode, bound);              get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1060                                          } else {                                          } else {
1061                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                                  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];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1063                                          }                                          }
1064                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1065              /* interlaced missing here */
1066                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                          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);                                          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);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
# Line 879  Line 1071 
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,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1074                                                                          intra_dc_threshold, bound, reduced_resolution);                    intra_dc_threshold, bound);
1075                                          continue;                                          continue;
1076                                  }                                  }
1077    
1078                                  decoder_mbinter(dec, mb, x, y, cbp, bs,          /* See how to decode */
1079                                                                  rounding, reduced_resolution, 0);          if(!mb->field_pred)
1080             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 */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1085                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
1086            mb->quant = quant;
1087                                  decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);                                  decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
1088    
1089                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
# Line 897  Line 1093 
1093                                  st_mb = x+1;                                  st_mb = x+1;
1094                          } else {        /* not coded P_VOP macroblock */                          } 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,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1103                                                                  rounding, reduced_resolution, 0);                                  rounding, 0, 0);
1104    
1105                                  if(dec->out_frm && cp_mb > 0) {                                  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);                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
# Line 923  Line 1121 
1121  get_b_motion_vector(Bitstream * bs,  get_b_motion_vector(Bitstream * bs,
1122                                          VECTOR * mv,                                          VECTOR * mv,
1123                                          int fcode,                                          int fcode,
1124                                          const VECTOR pmv)            const VECTOR pmv,
1125              const DECODER * const dec,
1126              const int x, const int y)
1127  {  {
1128          const int scale_fac = 1 << (fcode - 1);          const int scale_fac = 1 << (fcode - 1);
1129          const int high = (32 * scale_fac) - 1;          const int high = (32 * scale_fac) - 1;
# Line 955  Line 1155 
1155  decoder_bf_interpolate_mbinter(DECODER * dec,  decoder_bf_interpolate_mbinter(DECODER * dec,
1156                                                                  IMAGE forward,                                                                  IMAGE forward,
1157                                                                  IMAGE backward,                                                                  IMAGE backward,
1158                                                                  const MACROBLOCK * pMB,                  MACROBLOCK * pMB,
1159                                                                  const uint32_t x_pos,                                                                  const uint32_t x_pos,
1160                                                                  const uint32_t y_pos,                                                                  const uint32_t y_pos,
1161                                                                  Bitstream * bs,                                                                  Bitstream * bs,
# Line 972  Line 1172 
1172          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          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);          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) {          if (!direct) {
1179                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
1180                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
   
1181                  b_uv_dx = pMB->b_mvs[0].x;                  b_uv_dx = pMB->b_mvs[0].x;
1182                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1183    
1184                  if (dec->quarterpel) {                  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;                          uv_dx /= 2;
1193                          uv_dy /= 2;                          uv_dy /= 2;
1194                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1195                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1196                  }                  }
1197        }
1198    
1199                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1200                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
   
1201                  b_uv_dx = (b_uv_dx >> 1) + roundtab_79[b_uv_dx & 0x3];                  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];                  b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
1203    
1204          } else {          } else {
1205                  if(dec->quarterpel) {            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);                          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);                          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);                          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);                          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 {                  } else {
1225                          uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                          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;                          uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
# Line 1038  Line 1261 
1261                                                          pMB->mvs[1].x, pMB->mvs[1].y, stride, 0);                                                          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,                  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);                                                          pMB->mvs[2].x, pMB->mvs[2].y, stride, 0);
1264                  interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8,      interpolate8x8_switch(dec->cur.y, forward.y, 16 * x_pos + 8, 16 * y_pos + 8,
1265                                                          16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride, 0);                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,          interpolate8x8_switch(dec->cur.u, forward.u, 8 * x_pos, 8 * y_pos, uv_dx,
# Line 1050  Line 1273 
1273    
1274          if(dec->quarterpel) {          if(dec->quarterpel) {
1275                  if(!direct) {                  if(!direct) {
1276                          interpolate16x16_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        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,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1278                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1279                  } else {                  } else {
1280                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        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,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1282                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1283                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        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,                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1285                                                                                  pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);                                                                                  pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1286                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        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,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1288                                                                                  pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);                                                                                  pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1289                          interpolate8x8_quarterpel(dec->tmp.y, backward.y, dec->qtmp.y, dec->qtmp.y + 64,        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,                                                                                  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);                                                                                  pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1292                  }                  }
1293          } else {          } else {
1294                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos, 16 * y_pos,      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);                                                          pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1296                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos + 8,      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);                                                          16 * y_pos, pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1298                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos,      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);                                                          16 * y_pos + 8, pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1300                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos + 8,      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);                                                          16 * y_pos + 8, pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1302          }          }
1303    
1304          interpolate8x8_switch(dec->tmp.u, backward.u, 8 * x_pos, 8 * y_pos,    interpolate8x8_add_switch(dec->cur.u, backward.u, 8 * x_pos, 8 * y_pos,
1305                                                  b_uv_dx, b_uv_dy, stride2, 0);                                                  b_uv_dx, b_uv_dy, stride2, 0);
1306          interpolate8x8_switch(dec->tmp.v, backward.v, 8 * x_pos, 8 * y_pos,    interpolate8x8_add_switch(dec->cur.v, backward.v, 8 * x_pos, 8 * y_pos,
1307                                                  b_uv_dx, b_uv_dy, stride2, 0);                                                  b_uv_dx, b_uv_dy, stride2, 0);
1308    
         interpolate8x8_avg2(dec->cur.y + (16 * y_pos * stride) + 16 * x_pos,  
                                                 dec->cur.y + (16 * y_pos * stride) + 16 * x_pos,  
                                                 dec->tmp.y + (16 * y_pos * stride) + 16 * x_pos,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.y + (16 * y_pos * stride) + 16 * x_pos + 8,  
                                                 dec->cur.y + (16 * y_pos * stride) + 16 * x_pos + 8,  
                                                 dec->tmp.y + (16 * y_pos * stride) + 16 * x_pos + 8,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,  
                                                 dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,  
                                                 dec->tmp.y + ((16 * y_pos + 8) * stride) + 16 * x_pos,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,  
                                                 dec->cur.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,  
                                                 dec->tmp.y + ((16 * y_pos + 8) * stride) + 16 * x_pos + 8,  
                                                 stride, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.u + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->cur.u + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->tmp.u + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 stride2, 1, 8);  
   
         interpolate8x8_avg2(dec->cur.v + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->cur.v + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 dec->tmp.v + (8 * y_pos * stride2) + 8 * x_pos,  
                                                 stride2, 1, 8);  
   
1309          stop_comp_timer();          stop_comp_timer();
1310    
1311          if (cbp)          if (cbp)
1312                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, 0, pMB);      decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
1313  }  }
1314    
1315  /* for decode B-frame dbquant */  /* for decode B-frame dbquant */
# Line 1151  Line 1344 
1344          return -1;          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  static void
1355  decoder_bframe(DECODER * dec,  decoder_bframe(DECODER * dec,
1356                                  Bitstream * bs,                                  Bitstream * bs,
# Line 1161  Line 1361 
1361          uint32_t x, y;          uint32_t x, y;
1362          VECTOR mv;          VECTOR mv;
1363          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
         const int64_t TRB = dec->time_pp - dec->time_bp, TRD = dec->time_pp;  
1364          int i;          int i;
1365      int resync_len;
1366    
1367      if (!dec->is_edged[0]) {
1368          start_timer();          start_timer();
1369          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1370                                          dec->width, dec->height);              dec->width, dec->height, dec->bs_version);
1371        dec->is_edged[0] = 1;
1372        stop_edges_timer();
1373      }
1374    
1375      if (!dec->is_edged[1]) {
1376        start_timer();
1377          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1378                                          dec->width, dec->height);              dec->width, dec->height, dec->bs_version);
1379        dec->is_edged[1] = 1;
1380          stop_edges_timer();          stop_edges_timer();
1381      }
1382    
1383      resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1384          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1385                  /* Initialize Pred Motion Vector */                  /* Initialize Pred Motion Vector */
1386                  dec->p_fmv = dec->p_bmv = zeromv;                  dec->p_fmv = dec->p_bmv = zeromv;
1387                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
1388                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1389                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1390                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;        int intra_dc_threshold; /* fake variable */
                         uint32_t intra_dc_threshold; /* fake variable */  
1391    
1392                          if (check_resync_marker(bs, fcode_max  - 1)) {        if (check_resync_marker(bs, resync_len)) {
1393                                  int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,          int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1394                                                                                                           &fcode_forward, &fcode_backward, &intra_dc_threshold);                                                                                                           &fcode_forward, &fcode_backward, &intra_dc_threshold);
1395                                  x = bound % dec->mb_width;                                  x = bound % dec->mb_width;
1396                                  y = bound / dec->mb_width;          y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1397                                  /* reset predicted macroblocks */                                  /* reset predicted macroblocks */
1398                                  dec->p_fmv = dec->p_bmv = zeromv;                                  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 =                          mv =
# Line 1203  Line 1414 
1414                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1415                                  mb->cbp = 0;                                  mb->cbp = 0;
1416                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1417                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1418                                  continue;                                  continue;
1419                          }                          }
1420    
# Line 1252  Line 1463 
1463    
1464                          switch (mb->mode) {                          switch (mb->mode) {
1465                          case MODE_DIRECT:                          case MODE_DIRECT:
1466                                  get_b_motion_vector(bs, &mv, 1, zeromv);          get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);
1467    
1468                          case MODE_DIRECT_NONE_MV:                          case MODE_DIRECT_NONE_MV:
1469                                  for (i = 0; i < 4; i++) {                                  for (i = 0; i < 4; i++) {
1470                                          mb->mvs[i].x = (int32_t) ((TRB * last_mb->mvs[i].x) / TRD + mv.x);            mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
1471                                          mb->b_mvs[i].x = (int32_t) ((mv.x == 0)            mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;
1472                                                                          ? ((TRB - TRD) * last_mb->mvs[i].x) / TRD  
1473                                                                          : mb->mvs[i].x - last_mb->mvs[i].x);            mb->b_mvs[i].x = (mv.x)
1474                                          mb->mvs[i].y = (int32_t) ((TRB * last_mb->mvs[i].y) / TRD + mv.y);              ?  mb->mvs[i].x - last_mb->mvs[i].x
1475                                          mb->b_mvs[i].y = (int32_t) ((mv.y == 0)              : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1476                                                                          ? ((TRB - TRD) * last_mb->mvs[i].y) / TRD            mb->b_mvs[i].y = (mv.y)
1477                                                                          : mb->mvs[i].y - last_mb->mvs[i].y);              ? 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],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
# Line 1271  Line 1483 
1483                                  break;                                  break;
1484    
1485                          case MODE_INTERPOLATE:                          case MODE_INTERPOLATE:
1486                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv);          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];                                  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);          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];                                  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],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
# Line 1282  Line 1494 
1494                                  break;                                  break;
1495    
1496                          case MODE_BACKWARD:                          case MODE_BACKWARD:
1497                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv);          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];                                  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, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1501                                  break;                                  break;
1502    
1503                          case MODE_FORWARD:                          case MODE_FORWARD:
1504                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv);          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];                                  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, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1508                                  break;                                  break;
1509    
1510                          default:                          default:
# Line 1303  Line 1515 
1515  }  }
1516    
1517  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1518  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1519                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats, int coding_type)            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,          image_output(img, dec->width, dec->height,
1539                                   dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,                                   dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,
1540                                   frame->output.csp, dec->interlacing);                                   frame->output.csp, dec->interlacing);
# Line 1314  Line 1543 
1543                  stats->type = coding2type(coding_type);                  stats->type = coding2type(coding_type);
1544                  stats->data.vop.time_base = (int)dec->time_base;                  stats->data.vop.time_base = (int)dec->time_base;
1545                  stats->data.vop.time_increment = 0;     /* XXX: todo */                  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  int
1558  decoder_decode(DECODER * dec,  decoder_decode(DECODER * dec,
1559                                  xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)                                  xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
# Line 1325  Line 1561 
1561    
1562          Bitstream bs;          Bitstream bs;
1563          uint32_t rounding;          uint32_t rounding;
1564          uint32_t reduced_resolution;    uint32_t quant = 2;
         uint32_t quant;  
1565          uint32_t fcode_forward;          uint32_t fcode_forward;
1566          uint32_t fcode_backward;          uint32_t fcode_backward;
1567          uint32_t intra_dc_threshold;          uint32_t intra_dc_threshold;
# Line 1349  Line 1584 
1584                  /* if not decoding "low_delay/packed", and this isn't low_delay and                  /* if not decoding "low_delay/packed", and this isn't low_delay and
1585                          we have a reference frame, then outout the reference frame */                          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) {                  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);        decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1588                          dec->frames = 0;                          dec->frames = 0;
1589                          ret = 0;                          ret = 0;
1590                  } else {                  } else {
# Line 1380  Line 1615 
1615    
1616  repeat:  repeat:
1617    
1618          coding_type = BitstreamReadHeaders(&bs, dec, &rounding, &reduced_resolution,    coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1619                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1620    
1621          DPRINTF(XVID_DEBUG_HEADER, "coding_type=%i,  packed=%i,  time=%lli,  time_pp=%i,  time_bp=%i\n",    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);                                                          coding_type,    dec->packed_mode, dec->time, dec->time_pp, dec->time_bp);
1629    
1630          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1396  Line 1637 
1637          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */
1638    
1639                  if (coding_type == -3)                  if (coding_type == -3)
1640                          decoder_resize(dec);        if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1641    
1642                  if (stats) {                  if (stats) {
1643                          stats->type = XVID_TYPE_VOL;                          stats->type = XVID_TYPE_VOL;
# Line 1414  Line 1655 
1655                  goto repeat;                  goto repeat;
1656          }          }
1657    
1658          dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */    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.x = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1664    
1665          /* packed_mode: special-N_VOP treament */          /* packed_mode: special-N_VOP treament */
1666          if (dec->packed_mode && coding_type == N_VOP) {          if (dec->packed_mode && coding_type == N_VOP) {
1667                  if (dec->low_delay_default && dec->frames > 0) {                  if (dec->low_delay_default && dec->frames > 0) {
1668                          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type);        decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1669                          output = 1;                          output = 1;
1670                  }                  }
1671                  /* ignore otherwise */                  /* ignore otherwise */
1672          } else if (coding_type != B_VOP) {          } else if (coding_type != B_VOP) {
1673                  switch(coding_type) {                  switch(coding_type) {
1674                  case I_VOP :                  case I_VOP :
1675                          decoder_iframe(dec, &bs, reduced_resolution, quant, intra_dc_threshold);        decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1676                          break;                          break;
1677                  case P_VOP :                  case P_VOP :
1678                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1679                                                  fcode_forward, intra_dc_threshold, NULL);                                                  fcode_forward, intra_dc_threshold, NULL);
1680                          break;                          break;
1681                  case S_VOP :                  case S_VOP :
1682                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1683                                                  fcode_forward, intra_dc_threshold, &gmc_warp);                                                  fcode_forward, intra_dc_threshold, &gmc_warp);
1684                          break;                          break;
1685                  case N_VOP :                  case N_VOP :
1686                          /* XXX: not_coded vops are not used for forward prediction */                          /* XXX: not_coded vops are not used for forward prediction */
1687                          /* we should not swap(last_mbs,mbs) */                          /* we should not swap(last_mbs,mbs) */
1688                          image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);                          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;
1691                  }                  }
1692    
                 if (reduced_resolution) {  
                         image_deblock_rrv(&dec->cur, dec->edged_width, dec->mbs,  
                                 (dec->width + 31) / 32, (dec->height + 31) / 32, dec->mb_width,  
                                 16, 0);  
                 }  
   
1693                  /* note: for packed_mode, output is performed when the special-N_VOP is decoded */                  /* note: for packed_mode, output is performed when the special-N_VOP is decoded */
1694                  if (!(dec->low_delay_default && dec->packed_mode)) {                  if (!(dec->low_delay_default && dec->packed_mode)) {
1695                          if (dec->low_delay) {                          if (dec->low_delay) {
1696                                  decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type);          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1697                                  output = 1;                                  output = 1;
1698                          } else if (dec->frames > 0)     { /* is the reference frame valid? */                          } else if (dec->frames > 0)     { /* is the reference frame valid? */
1699                                  /* output the reference frame */                                  /* output the reference frame */
1700                                  decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type);          decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
1701                                  output = 1;                                  output = 1;
1702                          }                          }
1703                  }                  }
1704    
1705                  image_swap(&dec->refn[0], &dec->refn[1]);                  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]);                  image_swap(&dec->cur, &dec->refn[0]);
1708        dec->is_edged[0] = 0;
1709                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
                 dec->last_reduced_resolution = reduced_resolution;  
1710                  dec->last_coding_type = coding_type;                  dec->last_coding_type = coding_type;
1711    
1712                  dec->frames++;                  dec->frames++;
# Line 1474  Line 1716 
1716    
1717                  if (dec->low_delay) {                  if (dec->low_delay) {
1718                          DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");                          DPRINTF(XVID_DEBUG_ERROR, "warning: bvop found in low_delay==1 stream\n");
1719                          dec->low_delay = 1;        dec->low_delay = 0;
1720                  }                  }
1721    
1722                  if (dec->frames < 2) {                  if (dec->frames < 2) {
1723                          /* attemping to decode a bvop without atleast 2 reference frames */                          /* attemping to decode a bvop without atleast 2 reference frames */
1724                          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,                          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,
1725                                                  "broken b-frame, mising ref frames");                                                  "broken b-frame, mising ref frames");
1726          if (stats) stats->type = XVID_TYPE_NOTHING;
1727                  } else if (dec->time_pp <= dec->time_bp) {                  } else if (dec->time_pp <= dec->time_bp) {
1728                          /* this occurs when dx50_bvop_compatibility==0 sequences are                          /* this occurs when dx50_bvop_compatibility==0 sequences are
1729                          decoded in vfw. */                          decoded in vfw. */
1730                          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,                          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);                                                  "broken b-frame, tpp=%i tbp=%i", dec->time_pp, dec->time_bp);
1732          if (stats) stats->type = XVID_TYPE_NOTHING;
1733                  } else {                  } else {
1734                          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);                          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1735          decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type, quant);
1736                  }                  }
1737    
                 decoder_output(dec, &dec->cur, dec->mbs, frame, stats, coding_type);  
1738                  output = 1;                  output = 1;
1739                  dec->frames++;                  dec->frames++;
1740          }          }
1741    
1742    #if 0 /* Avoids to read to much data because of 32bit reads in our BS functions */
1743          BitstreamByteAlign(&bs);          BitstreamByteAlign(&bs);
1744    #endif
1745    
1746          /* low_delay_default mode: repeat in packed_mode */          /* low_delay_default mode: repeat in packed_mode */
1747          if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {          if (dec->low_delay_default && dec->packed_mode && output == 0 && success == 0) {
# Line 1505  Line 1751 
1751    
1752  done :  done :
1753    
1754          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1755             then output the recently decoded frame, or print an error message  */       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) {          if (dec->low_delay_default && output == 0) {
1766                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
1767                          /* output the recently decoded frame */        decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type, quant);
                         decoder_output(dec, &dec->refn[0], dec->last_mbs, frame, stats, dec->last_coding_type);  
1768                  } else {                  } else {
1769                          image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);                          image_clear(&dec->cur, dec->width, dec->height, dec->edged_width, 0, 128, 128);
1770                          image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,        decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
                                 "warning: nothing to output");  
                         image_printf(&dec->cur, dec->edged_width, dec->height, 16, 64,  
                                 "bframe decoder lag");  
   
                         decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP);  
1771                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1772                  }                  }
1773          }          }
# Line 1526  Line 1775 
1775          emms();          emms();
1776          stop_global_timer();          stop_global_timer();
1777    
1778          return BitstreamPos(&bs) / 8;   /* number of bytes consumed */    return (BitstreamPos(&bs)+7)/8; /* number of bytes consumed */
1779  }  }

Legend:
Removed from v.1.49.2.19  
changed lines
  Added in v.1.84

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