[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.35, Wed Mar 3 13:18:08 2004 UTC revision 1.87, Tue Dec 28 19:19:43 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-2010 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 46  Line 46 
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 61  Line 61 
61  #include "image/postprocessing.h"  #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 73  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);
         if (dec->qscale)  
90                  xvid_free(dec->qscale);                  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 87  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                  xvid_free(dec->mbs);            goto memory_error;
                 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);  
                 image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
123          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);          memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);
124    
125          /* nothing happens if that fails */          /* nothing happens if that fails */
# Line 171  Line 130 
130                  memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);                  memset(dec->qscale, 0, sizeof(int) * dec->mb_width * dec->mb_height);
131    
132          return 0;          return 0;
133    
134    memory_error:
135            /* Most structures were deallocated / nullifieded, so it should be safe */
136            /* decoder_destroy(dec) minus the write_timer */
137      xvid_free(dec->mbs);
138      image_destroy(&dec->cur, dec->edged_width, dec->edged_height);
139      image_destroy(&dec->refn[0], dec->edged_width, dec->edged_height);
140      image_destroy(&dec->refn[1], dec->edged_width, dec->edged_height);
141      image_destroy(&dec->tmp, dec->edged_width, dec->edged_height);
142      image_destroy(&dec->qtmp, dec->edged_width, dec->edged_height);
143    
144      xvid_free(dec);
145      return XVID_ERR_MEMORY;
146  }  }
147    
148    
# Line 200  Line 172 
172          dec->width = create->width;          dec->width = create->width;
173          dec->height = create->height;          dec->height = create->height;
174    
175      dec->num_threads = MAX(0, create->num_threads);
176    
177          image_null(&dec->cur);          image_null(&dec->cur);
178          image_null(&dec->refn[0]);          image_null(&dec->refn[0]);
179          image_null(&dec->refn[1]);          image_null(&dec->refn[1]);
# Line 222  Line 196 
196          dec->time = dec->time_base = dec->last_time_base = 0;          dec->time = dec->time_base = dec->last_time_base = 0;
197          dec->low_delay = 0;          dec->low_delay = 0;
198          dec->packed_mode = 0;          dec->packed_mode = 0;
199      dec->time_inc_resolution = 1; /* until VOL header says otherwise */
200      dec->ver_id = 1;
201    
202      if (create->fourcc == ((int)('X')|((int)('V')<<8)|
203                             ((int)('I')<<16)|((int)('D')<<24))) { /* XVID */
204        dec->bs_version = 0; /* Initially assume oldest xvid version */
205      }
206      else {
207            dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
208      }
209    
210          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
211    
212          if (dec->fixed_dimensions)    if (dec->fixed_dimensions) {
213                  return decoder_resize(dec);      int ret = decoder_resize(dec);
214        if (ret == XVID_ERR_MEMORY) create->handle = NULL;
215        return ret;
216      }
217          else          else
218                  return 0;                  return 0;
219  }  }
# Line 269  Line 256 
256                                  Bitstream * bs,                                  Bitstream * bs,
257                                  const uint32_t quant,                                  const uint32_t quant,
258                                  const uint32_t intra_dc_threshold,                                  const uint32_t intra_dc_threshold,
259                                  const unsigned int bound,          const unsigned int bound)
                                 const int reduced_resolution)  
260  {  {
261    
262          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
# Line 283  Line 269 
269          uint32_t iQuant = pMB->quant;          uint32_t iQuant = pMB->quant;
270          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
271    
         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{  
272                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
273                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
274                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
         }  
275    
276          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */          memset(block, 0, 6 * 64 * sizeof(int16_t));     /* clear */
277    
# Line 338  Line 318 
318                  stop_coding_timer();                  stop_coding_timer();
319    
320                  start_timer();                  start_timer();
321                  add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors);      add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors, dec->bs_version);
322                  stop_prediction_timer();                  stop_prediction_timer();
323    
324                  start_timer();                  start_timer();
# Line 350  Line 330 
330                  stop_iquant_timer();                  stop_iquant_timer();
331    
332                  start_timer();                  start_timer();
333                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
334                  stop_idct_timer();                  stop_idct_timer();
335    
336          }          }
# Line 361  Line 341 
341          }          }
342    
343          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{  
344                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);                  transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
345                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);                  transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
346                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);                  transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
347                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);                  transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
348                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);                  transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
349                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);                  transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
         }  
350          stop_transfer_timer();          stop_transfer_timer();
351  }  }
352    
# Line 389  Line 357 
357                                  uint8_t * pY_Cur,                                  uint8_t * pY_Cur,
358                                  uint8_t * pU_Cur,                                  uint8_t * pU_Cur,
359                                  uint8_t * pV_Cur,                                  uint8_t * pV_Cur,
                                 const int reduced_resolution,  
360                                  const MACROBLOCK * pMB)                                  const MACROBLOCK * pMB)
361  {  {
362          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);  
363    
364          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * (reduced_resolution ? 16 : 8);  
         const int stride2 = stride/2;  
365          int i;          int i;
366          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
367          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
368          const quant_interFuncPtr dequant = dec->quant_type == 0 ? dequant_h263_inter : dequant_mpeg_inter;    typedef void (*get_inter_block_function_t)(
369          Bitstream * bs,
370          int16_t * block,
371          int direction,
372          const int quant,
373          const uint16_t *matrix);
374      typedef void (*add_residual_function_t)(
375          uint8_t *predicted_block,
376          const int16_t *residual,
377          int stride);
378    
379      const get_inter_block_function_t get_inter_block = (dec->quant_type == 0)
380        ? (get_inter_block_function_t)get_inter_block_h263
381        : (get_inter_block_function_t)get_inter_block_mpeg;
382    
383          for (i = 0; i < 6; i++) {    uint8_t *dst[6];
384      int strides[6];
385    
                 if (cbp & (1 << (5 - i))) {     /* coded */  
386    
387                          memset(block, 0, 64 * sizeof(int16_t)); /* clear */    if (dec->interlacing && pMB->field_dct) {
388        dst[0] = pY_Cur;
389        dst[1] = pY_Cur + 8;
390        dst[2] = pY_Cur + stride;
391        dst[3] = dst[2] + 8;
392        dst[4] = pU_Cur;
393        dst[5] = pV_Cur;
394        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
395        strides[4] = stride/2;
396        strides[5] = stride/2;
397      } else {
398        dst[0] = pY_Cur;
399        dst[1] = pY_Cur + 8;
400        dst[2] = pY_Cur + 8*stride;
401        dst[3] = dst[2] + 8;
402        dst[4] = pU_Cur;
403        dst[5] = pV_Cur;
404        strides[0] = strides[1] = strides[2] = strides[3] = stride;
405        strides[4] = stride/2;
406        strides[5] = stride/2;
407      }
408    
409      for (i = 0; i < 6; i++) {
410        /* Process only coded blocks */
411        if (cbp & (1 << (5 - i))) {
412    
413          /* Clear the block */
414          memset(&data[0], 0, 64*sizeof(int16_t));
415    
416          /* Decode coeffs and dequantize on the fly */
417                          start_timer();                          start_timer();
418                          get_inter_block(bs, block, direction);        get_inter_block(bs, &data[0], direction, iQuant, get_inter_matrix(dec->mpeg_quant_matrices));
419                          stop_coding_timer();                          stop_coding_timer();
420    
421          /* iDCT */
422                          start_timer();                          start_timer();
423                          dequant(&data[i * 64], block, iQuant, dec->mpeg_quant_matrices);        idct((short * const)&data[0]);
424                          stop_iquant_timer();        stop_idct_timer();
425    
426          /* Add this residual to the predicted block */
427                          start_timer();                          start_timer();
428                          idct(&data[i * 64]);        transfer_16to8add(dst[i], &data[0], strides[i]);
429                          stop_idct_timer();        stop_transfer_timer();
430                  }                  }
431          }          }
   
         if (dec->interlacing && pMB->field_dct) {  
                 next_block = stride;  
                 stride *= 2;  
432          }          }
433    
434          start_timer();  static void __inline
435          if (reduced_resolution) {  validate_vector(VECTOR * mv, unsigned int x_pos, unsigned int y_pos, const DECODER * dec)
436                  if (cbp & 32)  {
437                          add_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);    /* clip a vector to valid range
438                  if (cbp & 16)       prevents crashes if bitstream is broken
439                          add_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);    */
440                  if (cbp & 8)    int shift = 5 + dec->quarterpel;
441                          add_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);    int xborder_high = (int)(dec->mb_width - x_pos) << shift;
442                  if (cbp & 4)    int xborder_low = (-(int)x_pos-1) << shift;
443                          add_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);    int yborder_high = (int)(dec->mb_height - y_pos) << shift;
444                  if (cbp & 2)    int yborder_low = (-(int)y_pos-1) << shift;
445                          add_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);  
446                  if (cbp & 1)  #define CHECK_MV(mv) \
447                          add_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);    do { \
448          } else {    if ((mv).x > xborder_high) { \
449                  if (cbp & 32)      DPRINTF(XVID_DEBUG_MV, "mv.x > max -- %d > %d, MB %d, %d", (mv).x, xborder_high, x_pos, y_pos); \
450                          transfer_16to8add(pY_Cur, &data[0 * 64], stride);      (mv).x = xborder_high; \
451                  if (cbp & 16)    } else if ((mv).x < xborder_low) { \
452                          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); \
453                  if (cbp & 8)      (mv).x = xborder_low; \
454                          transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);    } \
455                  if (cbp & 4)    if ((mv).y > yborder_high) { \
456                          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); \
457                  if (cbp & 2)      (mv).y = yborder_high; \
458                          transfer_16to8add(pU_Cur, &data[4 * 64], stride2);    } else if ((mv).y < yborder_low) { \
459                  if (cbp & 1)      DPRINTF(XVID_DEBUG_MV, "mv.y < min -- %d < %d, MB %d, %d", (mv).y, yborder_low, x_pos, y_pos); \
460                          transfer_16to8add(pV_Cur, &data[5 * 64], stride2);      (mv).y = yborder_low; \
461          }    } \
462          stop_transfer_timer();    } while (0)
463  }  
464      CHECK_MV(mv[0]);
465      CHECK_MV(mv[1]);
466      CHECK_MV(mv[2]);
467      CHECK_MV(mv[3]);
468    }
469    
470    /* Up to this version, chroma rounding was wrong with qpel.
471     * So we try to be backward compatible to avoid artifacts */
472    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
473    
474  /* decode an inter macroblock */  /* decode an inter macroblock */
475  static void  static void
# Line 468  Line 480 
480                                  const uint32_t cbp,                                  const uint32_t cbp,
481                                  Bitstream * bs,                                  Bitstream * bs,
482                                  const uint32_t rounding,                                  const uint32_t rounding,
483                                  const int reduced_resolution,          const int ref,
484                                  const int ref)                  const int bvop)
485  {  {
486          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
487          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 480  Line 492 
492          int uv_dx, uv_dy;          int uv_dx, uv_dy;
493          VECTOR mv[4];   /* local copy of mvs */          VECTOR mv[4];   /* local copy of mvs */
494    
         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 {  
495                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);                  pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
496                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);                  pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
497                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);                  pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
498                  for (i = 0; i < 4; i++)                  for (i = 0; i < 4; i++)
499                          mv[i] = pMB->mvs[i];                          mv[i] = pMB->mvs[i];
500          }  
501      validate_vector(mv, x_pos, y_pos, dec);
502    
503          start_timer();          start_timer();
504    
505          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 */
506    
507                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
508                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
509                  if (dec->quarterpel) {                  if (dec->quarterpel) {
510                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
511                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
512                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
513                            }
514                            else {
515                          uv_dx /= 2;                          uv_dx /= 2;
516                          uv_dy /= 2;                          uv_dy /= 2;
517                  }                  }
518        }
519                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
520                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
521    
522                  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)  
523                          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,
524                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
525                                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 523  Line 530 
530          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
531    
532                  if(dec->quarterpel) {                  if(dec->quarterpel) {
533                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
534                                    int z;
535                                    uv_dx = 0; uv_dy = 0;
536                                    for (z = 0; z < 4; z++) {
537                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
538                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
539                                    }
540                            }
541                            else {
542                          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);
543                          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);
544          }
545                  } else {                  } else {
546                          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;
547                          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 533  Line 550 
550                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
551                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];                  uv_dy = (uv_dy >> 3) + roundtab_76[uv_dy & 0xf];
552    
553                  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) {  
554                          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,
555                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                          dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
556                                                                          mv[0].x, mv[0].y, stride, rounding);                                                                          mv[0].x, mv[0].y, stride, rounding);
# Line 573  Line 576 
576          }          }
577    
578          /* 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 {  
579                  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,
580                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
581                  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,
582                                                                  uv_dx, uv_dy, stride2, rounding);                                                                  uv_dx, uv_dy, stride2, rounding);
583    
584      stop_comp_timer();
585    
586      if (cbp)
587        decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
588    }
589    
590    /* decode an inter macroblock in field mode */
591    static void
592    decoder_mbinter_field(DECODER * dec,
593            const MACROBLOCK * pMB,
594            const uint32_t x_pos,
595            const uint32_t y_pos,
596            const uint32_t cbp,
597            Bitstream * bs,
598            const uint32_t rounding,
599            const int ref,
600                    const int bvop)
601    {
602      uint32_t stride = dec->edged_width;
603      uint32_t stride2 = stride / 2;
604    
605      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
606    
607      int uvtop_dx, uvtop_dy;
608      int uvbot_dx, uvbot_dy;
609      VECTOR mv[4]; /* local copy of mvs */
610    
611      /* Get pointer to memory areas */
612      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
613      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
614      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
615    
616      mv[0] = pMB->mvs[0];
617      mv[1] = pMB->mvs[1];
618      memset(&mv[2],0,2*sizeof(VECTOR));
619    
620      validate_vector(mv, x_pos, y_pos, dec);
621    
622      start_timer();
623    
624      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
625      {
626        /* Prepare top field vector */
627        uvtop_dx = DIV2ROUND(mv[0].x);
628        uvtop_dy = DIV2ROUND(mv[0].y);
629    
630        /* Prepare bottom field vector */
631        uvbot_dx = DIV2ROUND(mv[1].x);
632        uvbot_dy = DIV2ROUND(mv[1].y);
633    
634        if(dec->quarterpel)
635        {
636          /* NOT supported */
637        }
638        else
639        {
640          /* Interpolate top field left part(we use double stride for every 2nd line) */
641          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
642                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
643          /* top field right part */
644          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
645                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
646    
647          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
648          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
649                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
650          /* Bottom field right part */
651          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
652                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
653    
654          /* Interpolate field1 U */
655          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
656                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
657    
658          /* Interpolate field1 V */
659          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
660                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
661    
662          /* Interpolate field2 U */
663          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
664                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
665    
666          /* Interpolate field2 V */
667          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
668                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
669        }
670      }
671      else
672      {
673        /* We don't expect 4 motion vectors in interlaced mode */
674          }          }
675    
676          stop_comp_timer();          stop_comp_timer();
677    
678      /* Must add error correction? */
679          if (cbp)          if (cbp)
680                  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);  
681  }  }
682    
683  static void  static void
# Line 636  Line 724 
724          stop_transfer_timer();          stop_transfer_timer();
725    
726          if (cbp)          if (cbp)
727                  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);
728    
729  }  }
730    
# Line 644  Line 732 
732  static void  static void
733  decoder_iframe(DECODER * dec,  decoder_iframe(DECODER * dec,
734                                  Bitstream * bs,                                  Bitstream * bs,
                                 int reduced_resolution,  
735                                  int quant,                                  int quant,
736                                  int intra_dc_threshold)                                  int intra_dc_threshold)
737  {  {
738          uint32_t bound;          uint32_t bound;
739          uint32_t x, y;          uint32_t x, y;
740          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
741          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;  
         }  
742    
743          bound = 0;          bound = 0;
744    
# Line 677  Line 759 
759                                  bound = read_video_packet_header(bs, dec, 0,                                  bound = read_video_packet_header(bs, dec, 0,
760                                                          &quant, NULL, NULL, &intra_dc_threshold);                                                          &quant, NULL, NULL, &intra_dc_threshold);
761                                  x = bound % mb_width;                                  x = bound % mb_width;
762                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
763                          }                          }
764                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
765    
# Line 712  Line 794 
794                          }                          }
795    
796                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
797                                                          intra_dc_threshold, bound, reduced_resolution);                intra_dc_threshold, bound);
798    
799                  }                  }
800                  if(dec->out_frm)                  if(dec->out_frm)
# Line 761  Line 843 
843                  mv.y -= range;                  mv.y -= range;
844          }          }
845    
846          /* clip to valid range */    ret_mv->x = mv.x;
847      ret_mv->y = mv.y;
848    }
849    
850          if (mv.x > ((int)(dec->mb_width - x) << (5 + dec->quarterpel)) )  /* We use this when decoder runs interlaced -> different prediction */
                 mv.x = (int)(dec->mb_width - x) << (5 + dec->quarterpel);  
851    
852          else if (mv.x < (int)(-x-1) << (5 + dec->quarterpel))  static void get_motion_vector_interlaced(DECODER * dec,
853                  mv.x = (int)(-x-1) << (5 + dec->quarterpel);          Bitstream * bs,
854            int x,
855            int y,
856            int k,
857            MACROBLOCK *pMB,
858            int fcode,
859            const int bound)
860    {
861      const int scale_fac = 1 << (fcode - 1);
862      const int high = (32 * scale_fac) - 1;
863      const int low = ((-32) * scale_fac);
864      const int range = (64 * scale_fac);
865    
866          if (mv.y > ((int)(dec->mb_height - y) << (5 + dec->quarterpel)) )    /* Get interlaced prediction */
867                  mv.y = (int)(dec->mb_height - y) << (5 + dec->quarterpel);    const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
868      VECTOR mv,mvf1,mvf2;
869    
870          else if (mv.y < ((int)(-y-1)) << (5 + dec->quarterpel) )    if(!pMB->field_pred)
871                  mv.y = (int)(-y-1) << (5 + dec->quarterpel);    {
872        mv.x = get_mv(bs,fcode);
873        mv.y = get_mv(bs,fcode);
874    
875          ret_mv->x = mv.x;      mv.x += pmv.x;
876          ret_mv->y = mv.y;      mv.y += pmv.y;
877    
878        if(mv.x<low) {
879          mv.x += range;
880        } else if (mv.x>high) {
881          mv.x-=range;
882        }
883    
884        if (mv.y < low) {
885          mv.y += range;
886        } else if (mv.y > high) {
887          mv.y -= range;
888        }
889    
890        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
891      }
892      else
893      {
894        mvf1.x = get_mv(bs, fcode);
895        mvf1.y = get_mv(bs, fcode);
896    
897        mvf1.x += pmv.x;
898        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
899    
900        if (mvf1.x < low) {
901          mvf1.x += range;
902        } else if (mvf1.x > high) {
903          mvf1.x -= range;
904        }
905    
906        if (mvf1.y < low) {
907          mvf1.y += range;
908        } else if (mvf1.y > high) {
909          mvf1.y -= range;
910        }
911    
912        mvf2.x = get_mv(bs, fcode);
913        mvf2.y = get_mv(bs, fcode);
914    
915        mvf2.x += pmv.x;
916        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
917    
918        if (mvf2.x < low) {
919          mvf2.x += range;
920        } else if (mvf2.x > high) {
921          mvf2.x -= range;
922        }
923    
924        if (mvf2.y < low) {
925          mvf2.y += range;
926        } else if (mvf2.y > high) {
927          mvf2.y -= range;
928        }
929    
930        pMB->mvs[0]=mvf1;
931        pMB->mvs[1]=mvf2;
932        pMB->mvs[2].x=pMB->mvs[3].x=0;
933        pMB->mvs[2].y=pMB->mvs[3].y=0;
934    
935        /* Calculate average for as it is field predicted */
936        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
937        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
938      }
939  }  }
940    
941  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
# Line 784  Line 943 
943  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
944                                  Bitstream * bs,                                  Bitstream * bs,
945                                  int rounding,                                  int rounding,
                                 int reduced_resolution,  
946                                  int quant,                                  int quant,
947                                  int fcode,                                  int fcode,
948                                  int intra_dc_threshold,                                  int intra_dc_threshold,
# Line 793  Line 951 
951          uint32_t x, y;          uint32_t x, y;
952          uint32_t bound;          uint32_t bound;
953          int cp_mb, st_mb;          int cp_mb, st_mb;
954          uint32_t mb_width = dec->mb_width;    const uint32_t mb_width = dec->mb_width;
955          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;  
         }  
956    
957      if (!dec->is_edged[0]) {
958          start_timer();          start_timer();
959          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
960                                          dec->width, dec->height, dec->bs_version);                                          dec->width, dec->height, dec->bs_version);
961        dec->is_edged[0] = 1;
962          stop_edges_timer();          stop_edges_timer();
963      }
964    
965          if (gmc_warp) {          if (gmc_warp) {
966                  /* 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 830  Line 986 
986                                  bound = read_video_packet_header(bs, dec, fcode - 1,                                  bound = read_video_packet_header(bs, dec, fcode - 1,
987                                          &quant, &fcode, NULL, &intra_dc_threshold);                                          &quant, &fcode, NULL, &intra_dc_threshold);
988                                  x = bound % mb_width;                                  x = bound % mb_width;
989                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
990                          }                          }
991                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
992    
# Line 874  Line 1030 
1030                                  }                                  }
1031                                  mb->quant = quant;                                  mb->quant = quant;
1032    
1033            mb->field_pred=0;
1034                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1035                                          if (cbp || intra) {                                          if (cbp || intra) {
1036                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 899  Line 1056 
1056    
1057                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1058    
1059                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1060                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1061                                                  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);
1062                                          } else {                                          } else {
1063                                                  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);
1064                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1065                                          }                                          }
1066                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1067              /* interlaced missing here */
1068                                          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);
1069                                          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);
1070                                          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 915  Line 1073 
1073                                          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;
1074                                          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;
1075                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
1076                                                                          intra_dc_threshold, bound, reduced_resolution);                    intra_dc_threshold, bound);
1077                                          continue;                                          continue;
1078                                  }                                  }
1079    
1080                                  decoder_mbinter(dec, mb, x, y, cbp, bs,          /* See how to decode */
1081                                                                  rounding, reduced_resolution, 0);          if(!mb->field_pred)
1082             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1083            else
1084             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1085    
1086                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1087                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 938  Line 1099 
1099    
1100                                  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;
1101                                  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;
1102            mb->field_pred=0; /* (!) */
1103    
1104                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1105                                                                  rounding, reduced_resolution, 0);                                  rounding, 0, 0);
1106    
1107                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1108                                          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 986  Line 1148 
1148          else if (mv_y > high)          else if (mv_y > high)
1149                  mv_y -= range;                  mv_y -= range;
1150    
   
         /* clip to valid range */  
         if (mv_x > ((int)(dec->mb_width - x) << (5 + dec->quarterpel)) )  
                 mv_x = (int)(dec->mb_width - x) << (5 + dec->quarterpel);  
   
         else if (mv_x < (int)(-x-1) << (5 + dec->quarterpel))  
                 mv_x = (int)(-x-1) << (5 + dec->quarterpel);  
   
         if (mv_y > ((int)(dec->mb_height - y) << (5 + dec->quarterpel)) )  
                 mv_y = (int)(dec->mb_height - y) << (5 + dec->quarterpel);  
   
         else if (mv_y < ((int)(-y-1)) << (5 + dec->quarterpel) )  
                 mv_y = (int)(-y-1) << (5 + dec->quarterpel);  
   
1151          mv->x = mv_x;          mv->x = mv_x;
1152          mv->y = mv_y;          mv->y = mv_y;
1153  }  }
# Line 1009  Line 1157 
1157  decoder_bf_interpolate_mbinter(DECODER * dec,  decoder_bf_interpolate_mbinter(DECODER * dec,
1158                                                                  IMAGE forward,                                                                  IMAGE forward,
1159                                                                  IMAGE backward,                                                                  IMAGE backward,
1160                                                                  const MACROBLOCK * pMB,                  MACROBLOCK * pMB,
1161                                                                  const uint32_t x_pos,                                                                  const uint32_t x_pos,
1162                                                                  const uint32_t y_pos,                                                                  const uint32_t y_pos,
1163                                                                  Bitstream * bs,                                                                  Bitstream * bs,
# Line 1026  Line 1174 
1174          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
1175          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
1176    
1177      validate_vector(pMB->mvs, x_pos, y_pos, dec);
1178      validate_vector(pMB->b_mvs, x_pos, y_pos, dec);
1179    
1180          if (!direct) {          if (!direct) {
1181                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
1182                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
   
1183                  b_uv_dx = pMB->b_mvs[0].x;                  b_uv_dx = pMB->b_mvs[0].x;
1184                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1185    
1186                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1187                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1188                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1189                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1190                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1191                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1192                            }
1193                            else {
1194                          uv_dx /= 2;                          uv_dx /= 2;
1195                          uv_dy /= 2;                          uv_dy /= 2;
1196                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1197                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1198                  }                  }
1199        }
1200    
1201                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1202                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
   
1203                  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];
1204                  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];
1205    
1206          } else {          } else {
1207                  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. */
1208                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1209                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1210                            int z;
1211                            uv_dx = 0; uv_dy = 0;
1212                            b_uv_dx = 0; b_uv_dy = 0;
1213                            for (z = 0; z < 4; z++) {
1214                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1215                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1216                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1217                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1218                            }
1219                    }
1220                    else {
1221                          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);
1222                          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);
1223                          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);
1224                          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);
1225                    }
1226                  } else {                  } else {
1227                          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;
1228                          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 1104  Line 1275 
1275    
1276          if(dec->quarterpel) {          if(dec->quarterpel) {
1277                  if(!direct) {                  if(!direct) {
1278                          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,
1279                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1280                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1281                  } else {                  } else {
1282                          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,
1283                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos,
1284                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                                                  pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1285                          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,
1286                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos,
1287                                                                                  pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);                                                                                  pMB->b_mvs[1].x, pMB->b_mvs[1].y, stride, 0);
1288                          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,
1289                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,                                                                                  dec->qtmp.y + 128, 16*x_pos, 16*y_pos + 8,
1290                                                                                  pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);                                                                                  pMB->b_mvs[2].x, pMB->b_mvs[2].y, stride, 0);
1291                          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,
1292                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,                                                                                  dec->qtmp.y + 128, 16*x_pos + 8, 16*y_pos + 8,
1293                                                                                  pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);                                                                                  pMB->b_mvs[3].x, pMB->b_mvs[3].y, stride, 0);
1294                  }                  }
1295          } else {          } else {
1296                  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,
1297                                                          pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);                                                          pMB->b_mvs[0].x, pMB->b_mvs[0].y, stride, 0);
1298                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos + 8,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1299                                                          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);
1300                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos,
1301                                                          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);
1302                  interpolate8x8_switch(dec->tmp.y, backward.y, 16 * x_pos + 8,      interpolate8x8_add_switch(dec->cur.y, backward.y, 16 * x_pos + 8,
1303                                                          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);
1304          }          }
1305    
1306          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,
1307                                                  b_uv_dx, b_uv_dy, stride2, 0);                                                  b_uv_dx, b_uv_dy, stride2, 0);
1308          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,
1309                                                  b_uv_dx, b_uv_dy, stride2, 0);                                                  b_uv_dx, b_uv_dy, stride2, 0);
1310    
         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);  
   
1311          stop_comp_timer();          stop_comp_timer();
1312    
1313          if (cbp)          if (cbp)
1314                  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);
1315  }  }
1316    
1317  /* for decode B-frame dbquant */  /* for decode B-frame dbquant */
# Line 1205  Line 1346 
1346          return -1;          return -1;
1347  }  }
1348    
1349    static int __inline get_resync_len_b(const int fcode_backward,
1350                                         const int fcode_forward) {
1351      int resync_len = ((fcode_forward>fcode_backward) ? fcode_forward : fcode_backward) - 1;
1352      if (resync_len < 1) resync_len = 1;
1353      return resync_len;
1354    }
1355    
1356  static void  static void
1357  decoder_bframe(DECODER * dec,  decoder_bframe(DECODER * dec,
1358                                  Bitstream * bs,                                  Bitstream * bs,
# Line 1215  Line 1363 
1363          uint32_t x, y;          uint32_t x, y;
1364          VECTOR mv;          VECTOR mv;
1365          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
         const int64_t TRB = dec->time_pp - dec->time_bp, TRD = dec->time_pp;  
1366          int i;          int i;
1367      int resync_len;
1368    
1369      if (!dec->is_edged[0]) {
1370          start_timer();          start_timer();
1371          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1372                                          dec->width, dec->height, dec->bs_version);                                          dec->width, dec->height, dec->bs_version);
1373        dec->is_edged[0] = 1;
1374        stop_edges_timer();
1375      }
1376    
1377      if (!dec->is_edged[1]) {
1378        start_timer();
1379          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1380                                          dec->width, dec->height, dec->bs_version);                                          dec->width, dec->height, dec->bs_version);
1381        dec->is_edged[1] = 1;
1382          stop_edges_timer();          stop_edges_timer();
1383      }
1384    
1385      resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1386          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1387                  /* Initialize Pred Motion Vector */                  /* Initialize Pred Motion Vector */
1388                  dec->p_fmv = dec->p_bmv = zeromv;                  dec->p_fmv = dec->p_bmv = zeromv;
1389                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
1390                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1391                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1392                          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 */  
   
                         if (check_resync_marker(bs, fcode_max  - 1)) {  
                                 int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,  
                                                                                                          &fcode_forward, &fcode_backward, &intra_dc_threshold);  
                                 x = bound % dec->mb_width;  
                                 y = bound / dec->mb_width;  
                                 /* reset predicted macroblocks */  
                                 dec->p_fmv = dec->p_bmv = zeromv;  
                         }  
1393    
1394                          mv =                          mv =
1395                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
# Line 1257  Line 1405 
1405                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1406                                  mb->cbp = 0;                                  mb->cbp = 0;
1407                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1408                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1409                                  continue;                                  continue;
1410                          }                          }
1411    
1412          if (check_resync_marker(bs, resync_len)) {
1413            int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1414                               &fcode_forward, &fcode_backward, &intra_dc_threshold);
1415    
1416                    bound = MAX(0, bound-1); /* valid bound must always be >0 */
1417            x = bound % dec->mb_width;
1418            y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1419            /* reset predicted macroblocks */
1420            dec->p_fmv = dec->p_bmv = zeromv;
1421            /* update resync len with new fcodes */
1422            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1423                    continue; /* re-init loop */
1424              }
1425    
1426                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */
1427                                  const uint8_t modb2 = BitstreamGetBit(bs);                                  const uint8_t modb2 = BitstreamGetBit(bs);
1428    
# Line 1310  Line 1472 
1472    
1473                          case MODE_DIRECT_NONE_MV:                          case MODE_DIRECT_NONE_MV:
1474                                  for (i = 0; i < 4; i++) {                                  for (i = 0; i < 4; i++) {
1475                                          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;
1476                                          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;
1477                                                                          ? ((TRB - TRD) * last_mb->mvs[i].x) / TRD  
1478                                                                          : mb->mvs[i].x - last_mb->mvs[i].x);            mb->b_mvs[i].x = (mv.x)
1479                                          mb->mvs[i].y = (int32_t) ((TRB * last_mb->mvs[i].y) / TRD + mv.y);              ?  mb->mvs[i].x - last_mb->mvs[i].x
1480                                          mb->b_mvs[i].y = (int32_t) ((mv.y == 0)              : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
1481                                                                          ? ((TRB - TRD) * last_mb->mvs[i].y) / TRD            mb->b_mvs[i].y = (mv.y)
1482                                                                          : mb->mvs[i].y - last_mb->mvs[i].y);              ? mb->mvs[i].y - last_mb->mvs[i].y
1483                : last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
1484                                  }                                  }
1485    
1486                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
# Line 1339  Line 1502 
1502                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1503                                  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];
1504    
1505                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1506                                  break;                                  break;
1507    
1508                          case MODE_FORWARD:                          case MODE_FORWARD:
1509                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1510                                  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];
1511    
1512                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1513                                  break;                                  break;
1514    
1515                          default:                          default:
# Line 1357  Line 1520 
1520  }  }
1521    
1522  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1523  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1524                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1525                                          int coding_type, int quant)                                          int coding_type, int quant)
1526  {  {
1527      const int brightness = XVID_VERSION_MINOR(frame->version) >= 1 ? frame->brightness : 0;
1528    
1529          if (dec->cartoon_mode)          if (dec->cartoon_mode)
1530                  frame->general &= ~XVID_FILMEFFECT;                  frame->general &= ~XVID_FILMEFFECT;
1531    
1532          if (frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) && mbs != NULL)     /* post process */    if ((frame->general & (XVID_DEBLOCKY|XVID_DEBLOCKUV|XVID_FILMEFFECT) || brightness!=0)
1533        && mbs != NULL) /* post process */
1534          {          {
1535                  /* note: image is stored to tmp */                  /* note: image is stored to tmp */
1536                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1537                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1538                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1539                                             frame->general, dec->frames, (coding_type == B_VOP));               frame->general, brightness, dec->frames, (coding_type == B_VOP), dec->num_threads);
1540                  img = &dec->tmp;                  img = &dec->tmp;
1541          }          }
1542    
# Line 1385  Line 1551 
1551                  stats->data.vop.qscale_stride = dec->mb_width;                  stats->data.vop.qscale_stride = dec->mb_width;
1552                  stats->data.vop.qscale = dec->qscale;                  stats->data.vop.qscale = dec->qscale;
1553                  if (stats->data.vop.qscale != NULL && mbs != NULL) {                  if (stats->data.vop.qscale != NULL && mbs != NULL) {
1554                          int i;        unsigned int i;
1555                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1556                                  stats->data.vop.qscale[i] = mbs[i].quant;                                  stats->data.vop.qscale[i] = mbs[i].quant;
1557                  } else                  } else
# Line 1393  Line 1559 
1559          }          }
1560  }  }
1561    
   
1562  int  int
1563  decoder_decode(DECODER * dec,  decoder_decode(DECODER * dec,
1564                                  xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)                                  xvid_dec_frame_t * frame, xvid_dec_stats_t * stats)
# Line 1401  Line 1566 
1566    
1567          Bitstream bs;          Bitstream bs;
1568          uint32_t rounding;          uint32_t rounding;
         uint32_t reduced_resolution;  
1569          uint32_t quant = 2;          uint32_t quant = 2;
1570          uint32_t fcode_forward;          uint32_t fcode_forward;
1571          uint32_t fcode_backward;          uint32_t fcode_backward;
# Line 1456  Line 1620 
1620    
1621  repeat:  repeat:
1622    
1623          coding_type = BitstreamReadHeaders(&bs, dec, &rounding, &reduced_resolution,    coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1624                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1625    
1626          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=%"
1627    #if defined(_MSC_VER)
1628        "I64"
1629    #else
1630        "ll"
1631    #endif
1632        "i,  time_pp=%i,  time_bp=%i\n",
1633                                                          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);
1634    
1635          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1472  Line 1642 
1642          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */
1643    
1644                  if (coding_type == -3)                  if (coding_type == -3)
1645                          decoder_resize(dec);        if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1646    
1647                  if (stats) {                  if (stats) {
1648                          stats->type = XVID_TYPE_VOL;                          stats->type = XVID_TYPE_VOL;
# Line 1490  Line 1660 
1660                  goto repeat;                  goto repeat;
1661          }          }
1662    
1663          dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */    if(dec->frames == 0 && coding_type != I_VOP) {
1664        /* 1st frame is not an i-vop */
1665        goto repeat;
1666      }
1667    
1668      dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.x = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1669    
1670          /* packed_mode: special-N_VOP treament */          /* packed_mode: special-N_VOP treament */
1671          if (dec->packed_mode && coding_type == N_VOP) {          if (dec->packed_mode && coding_type == N_VOP) {
# Line 1502  Line 1677 
1677          } else if (coding_type != B_VOP) {          } else if (coding_type != B_VOP) {
1678                  switch(coding_type) {                  switch(coding_type) {
1679                  case I_VOP :                  case I_VOP :
1680                          decoder_iframe(dec, &bs, reduced_resolution, quant, intra_dc_threshold);        decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1681                          break;                          break;
1682                  case P_VOP :                  case P_VOP :
1683                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1684                                                  fcode_forward, intra_dc_threshold, NULL);                                                  fcode_forward, intra_dc_threshold, NULL);
1685                          break;                          break;
1686                  case S_VOP :                  case S_VOP :
1687                          decoder_pframe(dec, &bs, rounding, reduced_resolution, quant,        decoder_pframe(dec, &bs, rounding, quant,
1688                                                  fcode_forward, intra_dc_threshold, &gmc_warp);                                                  fcode_forward, intra_dc_threshold, &gmc_warp);
1689                          break;                          break;
1690                  case N_VOP :                  case N_VOP :
# Line 1520  Line 1695 
1695                          break;                          break;
1696                  }                  }
1697    
                 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);  
                 }  
   
1698                  /* 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 */
1699                  if (!(dec->low_delay_default && dec->packed_mode)) {                  if (!(dec->low_delay_default && dec->packed_mode)) {
1700                          if (dec->low_delay) {                          if (dec->low_delay) {
# Line 1539  Line 1708 
1708                  }                  }
1709    
1710                  image_swap(&dec->refn[0], &dec->refn[1]);                  image_swap(&dec->refn[0], &dec->refn[1]);
1711        dec->is_edged[1] = dec->is_edged[0];
1712                  image_swap(&dec->cur, &dec->refn[0]);                  image_swap(&dec->cur, &dec->refn[0]);
1713        dec->is_edged[0] = 0;
1714                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);                  SWAP(MACROBLOCK *, dec->mbs, dec->last_mbs);
                 dec->last_reduced_resolution = reduced_resolution;  
1715                  dec->last_coding_type = coding_type;                  dec->last_coding_type = coding_type;
1716    
1717                  dec->frames++;                  dec->frames++;
# Line 1551  Line 1721 
1721    
1722                  if (dec->low_delay) {                  if (dec->low_delay) {
1723                          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");
1724                          dec->low_delay = 1;        dec->low_delay = 0;
1725                  }                  }
1726    
1727                  if (dec->frames < 2) {                  if (dec->frames < 2) {
# Line 1586  Line 1756 
1756    
1757  done :  done :
1758    
1759          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1760             then output the recently decoded frame, or print an error message  */       the calling application has specified low_delay_default,
1761         we *must* output something.
1762         this always occurs on the first call to decode() call
1763         when bframes are present in the bitstream. it may also
1764         occur if no vops  were seen in the bitstream
1765    
1766         if packed_mode is enabled, then we output the recently
1767         decoded frame (the very first ivop). otherwise we have
1768         nothing to display, and therefore output a black screen.
1769      */
1770          if (dec->low_delay_default && output == 0) {          if (dec->low_delay_default && output == 0) {
1771                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
                         /* output the recently decoded frame */  
1772                          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, quant);
1773                  } else {                  } else {
1774                          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);
                         image_printf(&dec->cur, dec->edged_width, dec->height, 16, 16,  
                                 "warning: nothing to output");  
                         image_printf(&dec->cur, dec->edged_width, dec->height, 16, 64,  
                                 "bframe decoder lag");  
   
1775                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1776                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1777                  }                  }

Legend:
Removed from v.1.49.2.35  
changed lines
  Added in v.1.87

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