[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.68, Sun Dec 5 13:56:13 2004 UTC revision 1.75.2.2, Mon Jul 10 15:05:30 2006 UTC
# 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 223  Line 195 
195          dec->low_delay = 0;          dec->low_delay = 0;
196          dec->packed_mode = 0;          dec->packed_mode = 0;
197          dec->time_inc_resolution = 1; /* until VOL header says otherwise */          dec->time_inc_resolution = 1; /* until VOL header says otherwise */
198      dec->ver_id = 1;
199    
200      dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
201    
202          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
203    
# Line 344  Line 319 
319                  stop_iquant_timer();                  stop_iquant_timer();
320    
321                  start_timer();                  start_timer();
322                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
323                  stop_idct_timer();                  stop_idct_timer();
324    
325          }          }
# Line 376  Line 351 
351          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
352    
353          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * 8;  
354          int i;          int i;
355          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
356          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
# Line 400  Line 374 
374    
375    
376          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
                 next_block = stride;  
                 stride *= 2;  
         }  
   
377          dst[0] = pY_Cur;          dst[0] = pY_Cur;
378          dst[2] = pY_Cur + next_block;      dst[1] = pY_Cur + 8;
379          dst[1] = dst[0] + 8;      dst[2] = pY_Cur + stride;
380        dst[3] = dst[2] + 8;
381        dst[4] = pU_Cur;
382        dst[5] = pV_Cur;
383        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
384        strides[4] = stride/2;
385        strides[5] = stride/2;
386      } else {
387        dst[0] = pY_Cur;
388        dst[1] = pY_Cur + 8;
389        dst[2] = pY_Cur + 8*stride;
390          dst[3] = dst[2] + 8;          dst[3] = dst[2] + 8;
391          dst[4] = pU_Cur;          dst[4] = pU_Cur;
392          dst[5] = pV_Cur;          dst[5] = pV_Cur;
393          strides[0] = strides[1] = strides[2] = strides[3] = stride;          strides[0] = strides[1] = strides[2] = strides[3] = stride;
394          strides[4] = stride/2;          strides[4] = stride/2;
395          strides[5] = stride/2;          strides[5] = stride/2;
396      }
397    
398          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
399                  /* Process only coded blocks */                  /* Process only coded blocks */
# Line 428  Line 409 
409    
410                          /* iDCT */                          /* iDCT */
411                          start_timer();                          start_timer();
412                          idct(&data[0]);        idct((short * const)&data[0]);
413                          stop_idct_timer();                          stop_idct_timer();
414    
415                          /* Add this residual to the predicted block */                          /* Add this residual to the predicted block */
# Line 475  Line 456 
456          CHECK_MV(mv[3]);          CHECK_MV(mv[3]);
457  }  }
458    
459    /* Up to this version, chroma rounding was wrong with qpel.
460     * So we try to be backward compatible to avoid artifacts */
461    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
462    
463  /* decode an inter macroblock */  /* decode an inter macroblock */
464  static void  static void
465  decoder_mbinter(DECODER * dec,  decoder_mbinter(DECODER * dec,
# Line 484  Line 469 
469                                  const uint32_t cbp,                                  const uint32_t cbp,
470                                  Bitstream * bs,                                  Bitstream * bs,
471                                  const uint32_t rounding,                                  const uint32_t rounding,
472                                  const int ref)          const int ref,
473                    const int bvop)
474  {  {
475          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
476          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 505  Line 491 
491    
492          start_timer();          start_timer();
493    
494          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 */
495    
496                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
497                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
498                  if (dec->quarterpel) {                  if (dec->quarterpel) {
499                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
500                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
501                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
502                            }
503                            else {
504                          uv_dx /= 2;                          uv_dx /= 2;
505                          uv_dy /= 2;                          uv_dy /= 2;
506                  }                  }
507        }
508                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
509                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
510    
# Line 527  Line 519 
519          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
520    
521                  if(dec->quarterpel) {                  if(dec->quarterpel) {
522                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
523                                    int z;
524                                    uv_dx = 0; uv_dy = 0;
525                                    for (z = 0; z < 4; z++) {
526                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
527                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
528                                    }
529                            }
530                            else {
531                          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);
532                          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);
533          }
534                  } else {                  } else {
535                          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;
536                          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 576 
576                  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);
577  }  }
578    
579    /* decode an inter macroblock in field mode */
580    static void
581    decoder_mbinter_field(DECODER * dec,
582            const MACROBLOCK * pMB,
583            const uint32_t x_pos,
584            const uint32_t y_pos,
585            const uint32_t cbp,
586            Bitstream * bs,
587            const uint32_t rounding,
588            const int ref,
589                    const int bvop)
590    {
591      uint32_t stride = dec->edged_width;
592      uint32_t stride2 = stride / 2;
593    
594      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
595    
596      int uvtop_dx, uvtop_dy;
597      int uvbot_dx, uvbot_dy;
598      VECTOR mv[4]; /* local copy of mvs */
599    
600      /* Get pointer to memory areas */
601      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
602      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
603      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
604    
605      mv[0] = pMB->mvs[0];
606      mv[1] = pMB->mvs[1];
607      memset(&mv[2],0,2*sizeof(VECTOR));
608    
609      validate_vector(mv, x_pos, y_pos, dec);
610    
611      start_timer();
612    
613      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
614      {
615        /* Prepare top field vector */
616        uvtop_dx = DIV2ROUND(mv[0].x);
617        uvtop_dy = DIV2ROUND(mv[0].y);
618    
619        /* Prepare bottom field vector */
620        uvbot_dx = DIV2ROUND(mv[1].x);
621        uvbot_dy = DIV2ROUND(mv[1].y);
622    
623        if(dec->quarterpel)
624        {
625          /* NOT supported */
626        }
627        else
628        {
629          /* Interpolate top field left part(we use double stride for every 2nd line) */
630          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
631                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
632          /* top field right part */
633          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
634                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
635    
636          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
637          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
638                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
639          /* Bottom field right part */
640          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
641                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
642    
643          /* Interpolate field1 U */
644          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
645                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
646    
647          /* Interpolate field1 V */
648          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
649                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
650    
651          /* Interpolate field2 U */
652          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
653                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
654    
655          /* Interpolate field2 V */
656          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
657                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
658        }
659      }
660      else
661      {
662        /* We don't expect 4 motion vectors in interlaced mode */
663      }
664    
665      stop_comp_timer();
666    
667      /* Must add error correction? */
668      if(cbp)
669       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
670    }
671    
672  static void  static void
673  decoder_mbgmc(DECODER * dec,  decoder_mbgmc(DECODER * dec,
674                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
# Line 741  Line 836 
836          ret_mv->y = mv.y;          ret_mv->y = mv.y;
837  }  }
838    
839    /* We use this when decoder runs interlaced -> different prediction */
840    
841    static void get_motion_vector_interlaced(DECODER * dec,
842            Bitstream * bs,
843            int x,
844            int y,
845            int k,
846            MACROBLOCK *pMB,
847            int fcode,
848            const int bound)
849    {
850      const int scale_fac = 1 << (fcode - 1);
851      const int high = (32 * scale_fac) - 1;
852      const int low = ((-32) * scale_fac);
853      const int range = (64 * scale_fac);
854    
855      /* Get interlaced prediction */
856      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
857      VECTOR mv,mvf1,mvf2;
858    
859      if(!pMB->field_pred)
860      {
861        mv.x = get_mv(bs,fcode);
862        mv.y = get_mv(bs,fcode);
863    
864        mv.x += pmv.x;
865        mv.y += pmv.y;
866    
867        if(mv.x<low) {
868          mv.x += range;
869        } else if (mv.x>high) {
870          mv.x-=range;
871        }
872    
873        if (mv.y < low) {
874          mv.y += range;
875        } else if (mv.y > high) {
876          mv.y -= range;
877        }
878    
879        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
880      }
881      else
882      {
883        mvf1.x = get_mv(bs, fcode);
884        mvf1.y = get_mv(bs, fcode);
885    
886        mvf1.x += pmv.x;
887        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
888    
889        if (mvf1.x < low) {
890          mvf1.x += range;
891        } else if (mvf1.x > high) {
892          mvf1.x -= range;
893        }
894    
895        if (mvf1.y < low) {
896          mvf1.y += range;
897        } else if (mvf1.y > high) {
898          mvf1.y -= range;
899        }
900    
901        mvf2.x = get_mv(bs, fcode);
902        mvf2.y = get_mv(bs, fcode);
903    
904        mvf2.x += pmv.x;
905        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
906    
907        if (mvf2.x < low) {
908          mvf2.x += range;
909        } else if (mvf2.x > high) {
910          mvf2.x -= range;
911        }
912    
913        if (mvf2.y < low) {
914          mvf2.y += range;
915        } else if (mvf2.y > high) {
916          mvf2.y -= range;
917        }
918    
919        pMB->mvs[0]=mvf1;
920        pMB->mvs[1]=mvf2;
921        pMB->mvs[2].x=pMB->mvs[3].x=0;
922        pMB->mvs[2].y=pMB->mvs[3].y=0;
923    
924        /* Calculate average for as it is field predicted */
925        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
926        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
927      }
928    }
929    
930  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
931  static void  static void
932  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
# Line 833  Line 1019 
1019                                  }                                  }
1020                                  mb->quant = quant;                                  mb->quant = quant;
1021    
1022            mb->field_pred=0;
1023                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1024                                          if (cbp || intra) {                                          if (cbp || intra) {
1025                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 858  Line 1045 
1045    
1046                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1047    
1048                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1049                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1050                                                  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);
1051                                          } else {                                          } else {
1052                                                  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);
1053                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1054                                          }                                          }
1055                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1056              /* interlaced missing here */
1057                                          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);
1058                                          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);
1059                                          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 1066 
1066                                          continue;                                          continue;
1067                                  }                                  }
1068    
1069                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);          /* See how to decode */
1070            if(!mb->field_pred)
1071             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1072            else
1073             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1074    
1075                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1076                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 896  Line 1088 
1088    
1089                                  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;
1090                                  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;
1091            mb->field_pred=0; /* (!) */
1092    
1093                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1094                                                                  rounding, 0);                                  rounding, 0, 0);
1095    
1096                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1097                                          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 1173 
1173                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1174    
1175                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1176                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1177                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1178                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1179                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1180                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1181                            }
1182                            else {
1183                          uv_dx /= 2;                          uv_dx /= 2;
1184                          uv_dy /= 2;                          uv_dy /= 2;
1185                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1186                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1187                  }                  }
1188        }
1189    
1190                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1191                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
# Line 992  Line 1193 
1193                  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];
1194    
1195          } else {          } else {
1196              if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1197                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1198                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1199                            int z;
1200                            uv_dx = 0; uv_dy = 0;
1201                            b_uv_dx = 0; b_uv_dy = 0;
1202                            for (z = 0; z < 4; z++) {
1203                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1204                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1205                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1206                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1207                            }
1208                    }
1209                    else {
1210                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1211                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1212                            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);
1213                            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);
1214                    }
1215            } else {
1216                  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;
1217                  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;
1218                  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;
1219                  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;  
1220                  }                  }
1221    
1222                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
# Line 1155  Line 1370 
1370                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1371                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1372                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
1373                          uint32_t intra_dc_threshold; /* fake variable */        int intra_dc_threshold; /* fake variable */
1374    
1375                          if (check_resync_marker(bs, fcode_max  - 1)) {                          if (check_resync_marker(bs, fcode_max  - 1)) {
1376                                  int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,                                  int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,
# Line 1180  Line 1395 
1395                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1396                                  mb->cbp = 0;                                  mb->cbp = 0;
1397                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1398                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1399                                  continue;                                  continue;
1400                          }                          }
1401    
# Line 1263  Line 1478 
1478                                  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);
1479                                  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];
1480    
1481                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1482                                  break;                                  break;
1483    
1484                          case MODE_FORWARD:                          case MODE_FORWARD:
1485                                  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);
1486                                  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];
1487    
1488                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1489                                  break;                                  break;
1490    
1491                          default:                          default:
# Line 1281  Line 1496 
1496  }  }
1497    
1498  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1499  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1500                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1501                                          int coding_type, int quant)                                          int coding_type, int quant)
1502  {  {
# Line 1312  Line 1527 
1527                  stats->data.vop.qscale_stride = dec->mb_width;                  stats->data.vop.qscale_stride = dec->mb_width;
1528                  stats->data.vop.qscale = dec->qscale;                  stats->data.vop.qscale = dec->qscale;
1529                  if (stats->data.vop.qscale != NULL && mbs != NULL) {                  if (stats->data.vop.qscale != NULL && mbs != NULL) {
1530                          int i;        unsigned int i;
1531                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)                          for (i = 0; i < dec->mb_width*dec->mb_height; i++)
1532                                  stats->data.vop.qscale[i] = mbs[i].quant;                                  stats->data.vop.qscale[i] = mbs[i].quant;
1533                  } else                  } else
# Line 1384  Line 1599 
1599          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,          coding_type = BitstreamReadHeaders(&bs, dec, &rounding,
1600                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);                          &quant, &fcode_forward, &fcode_backward, &intra_dc_threshold, &gmc_warp);
1601    
1602          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=%"
1603    #if defined(_MSC_VER)
1604        "I64"
1605    #else
1606        "ll"
1607    #endif
1608        "i,  time_pp=%i,  time_bp=%i\n",
1609                                                          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);
1610    
1611          if (coding_type == -1) { /* nothing */          if (coding_type == -1) { /* nothing */
# Line 1511  Line 1732 
1732    
1733  done :  done :
1734    
1735          /* low_delay_default mode: if we've gotten here without outputting anything,    /* if we reach here without outputing anything _and_
1736             then output the recently decoded frame, or print an error message  */       the calling application has specified low_delay_default,
1737         we *must* output something.
1738         this always occurs on the first call to decode() call
1739         when bframes are present in the bitstream. it may also
1740         occur if no vops  were seen in the bitstream
1741    
1742         if packed_mode is enabled, then we output the recently
1743         decoded frame (the very first ivop). otherwise we have
1744         nothing to display, and therefore output a black screen.
1745      */
1746          if (dec->low_delay_default && output == 0) {          if (dec->low_delay_default && output == 0) {
1747                  if (dec->packed_mode && seen_something) {                  if (dec->packed_mode && seen_something) {
                         /* output the recently decoded frame */  
1748                          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);
1749                  } else {                  } else {
1750                          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");  
   
1751                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);                          decoder_output(dec, &dec->cur, NULL, frame, stats, P_VOP, quant);
1752                          if (stats) stats->type = XVID_TYPE_NOTHING;                          if (stats) stats->type = XVID_TYPE_NOTHING;
1753                  }                  }

Legend:
Removed from v.1.68  
changed lines
  Added in v.1.75.2.2

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