[svn] / branches / release-1_3-branch / xvidcore / src / decoder.c Repository:
ViewVC logotype

Diff of /branches/release-1_3-branch/xvidcore/src/decoder.c

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

trunk/xvidcore/src/decoder.c revision 1566, Sun Dec 5 13:56:13 2004 UTC branches/release-1_3-branch/xvidcore/src/decoder.c revision 2180, Tue Nov 12 14:48:35 2019 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-2004 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 20  Line 20 
20   *  along with this program ; if not, write to the Free Software   *  along with this program ; if not, write to the Free Software
21   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22   *   *
23   * $Id: decoder.c,v 1.68 2004-12-05 13:56:13 syskin Exp $   * $Id$
24   *   *
25   ****************************************************************************/   ****************************************************************************/
26    
# 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    
149  int  int
150  decoder_create(xvid_dec_create_t * create)  decoder_create(xvid_dec_create_t * create)
151  {  {
152      int ret = 0;
153          DECODER *dec;          DECODER *dec;
154    
155          if (XVID_VERSION_MAJOR(create->version) != 1)   /* v1.x.x */          if (XVID_VERSION_MAJOR(create->version) != 1)   /* v1.x.x */
# Line 197  Line 170 
170    
171          create->handle = dec;          create->handle = dec;
172    
173          dec->width = create->width;    dec->width = MAX(0, create->width);
174          dec->height = create->height;    dec->height = MAX(0, create->height);
175    
176      dec->num_threads = MAX(0, create->num_threads);
177    
178          image_null(&dec->cur);          image_null(&dec->cur);
179          image_null(&dec->refn[0]);          image_null(&dec->refn[0]);
# Line 223  Line 198 
198          dec->low_delay = 0;          dec->low_delay = 0;
199          dec->packed_mode = 0;          dec->packed_mode = 0;
200          dec->time_inc_resolution = 1; /* until VOL header says otherwise */          dec->time_inc_resolution = 1; /* until VOL header says otherwise */
201      dec->ver_id = 1;
202    
203      if (create->fourcc == ((int)('X')|((int)('V')<<8)|
204                             ((int)('I')<<16)|((int)('D')<<24))) { /* XVID */
205        dec->bs_version = 0; /* Initially assume oldest xvid version */
206      }
207      else {
208            dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
209      }
210    
211          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
212    
213          if (dec->fixed_dimensions)    ret = decoder_resize(dec);
214                  return decoder_resize(dec);    if (ret == XVID_ERR_MEMORY) create->handle = NULL;
215          else  
216                  return 0;    return ret;
217  }  }
218    
219    
# Line 280  Line 264 
264          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
265          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
266          uint32_t i;          uint32_t i;
267          uint32_t iQuant = pMB->quant;    uint32_t iQuant = MAX(1, pMB->quant);
268          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
269    
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);
# Line 344  Line 328 
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 376  Line 360 
360          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
361    
362          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * 8;  
363          int i;          int i;
364          const uint32_t iQuant = pMB->quant;    const uint32_t iQuant = MAX(1, pMB->quant);
365          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
366          typedef void (*get_inter_block_function_t)(          typedef void (*get_inter_block_function_t)(
367                          Bitstream * bs,                          Bitstream * bs,
# Line 400  Line 383 
383    
384    
385          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
                 next_block = stride;  
                 stride *= 2;  
         }  
   
386          dst[0] = pY_Cur;          dst[0] = pY_Cur;
387          dst[2] = pY_Cur + next_block;      dst[1] = pY_Cur + 8;
388          dst[1] = dst[0] + 8;      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;          dst[3] = dst[2] + 8;
400          dst[4] = pU_Cur;          dst[4] = pU_Cur;
401          dst[5] = pV_Cur;          dst[5] = pV_Cur;
402          strides[0] = strides[1] = strides[2] = strides[3] = stride;          strides[0] = strides[1] = strides[2] = strides[3] = stride;
403          strides[4] = stride/2;          strides[4] = stride/2;
404          strides[5] = stride/2;          strides[5] = stride/2;
405      }
406    
407          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
408                  /* Process only coded blocks */                  /* Process only coded blocks */
# Line 428  Line 418 
418    
419                          /* iDCT */                          /* iDCT */
420                          start_timer();                          start_timer();
421                          idct(&data[0]);        idct((short * const)&data[0]);
422                          stop_idct_timer();                          stop_idct_timer();
423    
424                          /* Add this residual to the predicted block */                          /* Add this residual to the predicted block */
# Line 475  Line 465 
465          CHECK_MV(mv[3]);          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
474  decoder_mbinter(DECODER * dec,  decoder_mbinter(DECODER * dec,
# Line 484  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 ref)          const int ref,
482                    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 505  Line 500 
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    
# Line 527  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 574  Line 585 
585                  decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);                  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();
675    
676      /* Must add error correction? */
677      if(cbp)
678       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
679    }
680    
681  static void  static void
682  decoder_mbgmc(DECODER * dec,  decoder_mbgmc(DECODER * dec,
683                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
# Line 653  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 741  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,
# Line 789  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 833  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) {                                          if (cbp || intra) {
1034                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 858  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 878  Line 1075 
1075                                          continue;                                          continue;
1076                                  }                                  }
1077    
1078                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);          /* See how to decode */
1079            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;
# Line 896  Line 1097 
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, 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 980  Line 1182 
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];
# Line 992  Line 1202 
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) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1206                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1207                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1208                            int z;
1209                            uv_dx = 0; uv_dy = 0;
1210                            b_uv_dx = 0; b_uv_dy = 0;
1211                            for (z = 0; z < 4; z++) {
1212                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1213                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1214                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1215                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1216                            }
1217                    }
1218                    else {
1219                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1220                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1221                            b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1222                            b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1223                    }
1224            } else {
1225                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  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;
1227                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;                  b_uv_dx = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;
1228                  b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;                  b_uv_dy = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;
   
                 if (dec->quarterpel) {  
                         uv_dx /= 2;  
                         uv_dy /= 2;  
                         b_uv_dx /= 2;  
                         b_uv_dy /= 2;  
1229                  }                  }
1230    
1231                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
# Line 1120  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 1131  Line 1362 
1362          VECTOR mv;          VECTOR mv;
1363          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
1364          int i;          int i;
1365      int resync_len;
1366    
1367          if (!dec->is_edged[0]) {          if (!dec->is_edged[0]) {
1368                  start_timer();                  start_timer();
# Line 1148  Line 1380 
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 */  
   
                         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;  
                         }  
1391    
1392                          mv =                          mv =
1393                          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 1180  Line 1403 
1403                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1404                                  mb->cbp = 0;                                  mb->cbp = 0;
1405                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1406                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1407                                  continue;                                  continue;
1408                          }                          }
1409    
1410          if (check_resync_marker(bs, resync_len)) {
1411            int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1412                               &fcode_forward, &fcode_backward, &intra_dc_threshold);
1413    
1414                    bound = MAX(0, bound-1); /* valid bound must always be >0 */
1415            x = bound % dec->mb_width;
1416            y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1417            /* reset predicted macroblocks */
1418            dec->p_fmv = dec->p_bmv = zeromv;
1419            /* update resync len with new fcodes */
1420            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1421                    continue; /* re-init loop */
1422              }
1423    
1424                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */
1425                                  const uint8_t modb2 = BitstreamGetBit(bs);                                  const uint8_t modb2 = BitstreamGetBit(bs);
1426    
# Line 1263  Line 1500 
1500                                  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);
1501                                  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];
1502    
1503                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1504                                  break;                                  break;
1505    
1506                          case MODE_FORWARD:                          case MODE_FORWARD:
1507                                  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);
1508                                  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];
1509    
1510                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1511                                  break;                                  break;
1512    
1513                          default:                          default:
# Line 1281  Line 1518 
1518  }  }
1519    
1520  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1521  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1522                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1523                                          int coding_type, int quant)                                          int coding_type, int quant)
1524  {  {
# Line 1297  Line 1534 
1534                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1535                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1536                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1537                                             frame->general, brightness, dec->frames, (coding_type == B_VOP));               frame->general, brightness, dec->frames, (coding_type == B_VOP), dec->num_threads);
1538                  img = &dec->tmp;                  img = &dec->tmp;
1539          }          }
1540    
1541      if ((frame->output.plane[0] != NULL) && (frame->output.stride[0] >= dec->width)) {
1542          image_output(img, dec->width, dec->height,          image_output(img, dec->width, dec->height,
1543                                   dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,                                   dec->edged_width, (uint8_t**)frame->output.plane, frame->output.stride,
1544                                   frame->output.csp, dec->interlacing);                                   frame->output.csp, dec->interlacing);
1545      }
1546    
1547          if (stats) {          if (stats) {
1548                  stats->type = coding2type(coding_type);                  stats->type = coding2type(coding_type);
# Line 1312  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 1326  Line 1565 
1565  {  {
1566    
1567          Bitstream bs;          Bitstream bs;
1568          uint32_t rounding;    uint32_t rounding = 0;
1569          uint32_t quant = 2;          uint32_t quant = 2;
1570          uint32_t fcode_forward;    uint32_t fcode_forward = 0;
1571          uint32_t fcode_backward;    uint32_t fcode_backward = 0;
1572          uint32_t intra_dc_threshold;    uint32_t intra_dc_threshold = 0;
1573          WARPPOINTS gmc_warp;          WARPPOINTS gmc_warp;
1574          int coding_type;    int coding_type = -1;
1575          int success, output, seen_something;          int success, output, seen_something;
1576    
1577          if (XVID_VERSION_MAJOR(frame->version) != 1 || (stats && XVID_VERSION_MAJOR(stats->version) != 1))      /* v1.x.x */          if (XVID_VERSION_MAJOR(frame->version) != 1 || (stats && XVID_VERSION_MAJOR(stats->version) != 1))      /* v1.x.x */
1578                  return XVID_ERR_VERSION;                  return XVID_ERR_VERSION;
1579    
1580          start_global_timer();          start_global_timer();
1581      memset((void *)&gmc_warp, 0, sizeof(WARPPOINTS));
1582    
1583          dec->low_delay_default = (frame->general & XVID_LOWDELAY);          dec->low_delay_default = (frame->general & XVID_LOWDELAY);
1584          if ((frame->general & XVID_DISCONTINUITY))          if ((frame->general & XVID_DISCONTINUITY))
# Line 1384  Line 1624 
1624          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1625                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1626    
1627          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=%"
1628    #if defined(_MSC_VER)
1629        "I64"
1630    #else
1631        "ll"
1632    #endif
1633        "i,  time_pp=%i,  time_bp=%i\n",
1634                                                          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);
1635    
1636          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1397  Line 1643 
1643          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */
1644    
1645                  if (coding_type == -3)                  if (coding_type == -3)
1646                          decoder_resize(dec);        if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1647    
1648                  if (stats) {                  if (stats) {
1649                          stats->type = XVID_TYPE_VOL;                          stats->type = XVID_TYPE_VOL;
1650                          stats->data.vol.general = 0;                          stats->data.vol.general = 0;
1651                          /*XXX: if (dec->interlacing)            stats->data.vop.general = 0;
1652                                  stats->data.vol.general |= ++INTERLACING; */            if (dec->interlacing) {
1653                          stats->data.vol.width = dec->width;                    stats->data.vol.general |= XVID_VOL_INTERLACING;
1654                      if (dec->top_field_first) {
1655                              stats->data.vop.general |= XVID_VOP_TOPFIELDFIRST;
1656                      }
1657              }      stats->data.vol.width = dec->width;
1658                          stats->data.vol.height = dec->height;                          stats->data.vol.height = dec->height;
1659                          stats->data.vol.par = dec->aspect_ratio;                          stats->data.vol.par = dec->aspect_ratio;
1660                          stats->data.vol.par_width = dec->par_width;                          stats->data.vol.par_width = dec->par_width;
# Line 1415  Line 1665 
1665                  goto repeat;                  goto repeat;
1666          }          }
1667    
1668          if(dec->frames == 0 && coding_type != I_VOP) {    if((dec->frames == 0 && coding_type != I_VOP) || (!dec->width || !dec->height)) {
1669                  /* 1st frame is not an i-vop */                  /* 1st frame is not an i-vop */
1670                  goto repeat;                  goto repeat;
1671          }          }
1672    
1673          dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.y = dec->p_fmv.y = 0;  /* init pred vector to 0 */    dec->p_bmv.x = dec->p_bmv.y = dec->p_fmv.x = dec->p_fmv.y = 0;  /* init pred vector to 0 */
1674    
1675          /* packed_mode: special-N_VOP treament */          /* packed_mode: special-N_VOP treament */
1676          if (dec->packed_mode && coding_type == N_VOP) {          if (dec->packed_mode && coding_type == N_VOP) {
# Line 1511  Line 1761 
1761    
1762  done :  done :
1763    
1764          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1765             then output the recently decoded frame, or print an error message  */       the calling application has specified low_delay_default,
1766         we *must* output something.
1767         this always occurs on the first call to decode() call
1768         when bframes are present in the bitstream. it may also
1769         occur if no vops  were seen in the bitstream
1770    
1771         if packed_mode is enabled, then we output the recently
1772         decoded frame (the very first ivop). otherwise we have
1773         nothing to display, and therefore output a black screen.
1774      */
1775          if (dec->low_delay_default && output == 0) {          if (dec->low_delay_default && output == 0) {
1776                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
                         /* output the recently decoded frame */  
1777                          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);
1778                  } else {                  } else {
1779                          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");  
   
1780                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1781                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1782                  }                  }
Legend:
Removed from v.1566  
changed lines
  Added in v.2180
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4