[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.71, Mon May 23 09:29:43 2005 UTC revision 1.86, Fri Dec 24 13:49:58 2010 UTC
# Line 4  Line 4 
4   *  - Decoder Module -   *  - Decoder Module -
5   *   *
6   *  Copyright(C) 2002      MinChen <chenm001@163.com>   *  Copyright(C) 2002      MinChen <chenm001@163.com>
7   *               2002-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 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 168  Line 172 
172          dec->width = create->width;          dec->width = create->width;
173          dec->height = create->height;          dec->height = create->height;
174    
175      dec->num_threads = MAX(0, create->num_threads);
176    
177          image_null(&dec->cur);          image_null(&dec->cur);
178          image_null(&dec->refn[0]);          image_null(&dec->refn[0]);
179          image_null(&dec->refn[1]);          image_null(&dec->refn[1]);
# Line 191  Line 197 
197          dec->low_delay = 0;          dec->low_delay = 0;
198          dec->packed_mode = 0;          dec->packed_mode = 0;
199          dec->time_inc_resolution = 1; /* until VOL header says otherwise */          dec->time_inc_resolution = 1; /* until VOL header says otherwise */
200      dec->ver_id = 1;
201    
202      if (create->fourcc == ((int)('X')|((int)('V')<<8)|
203                             ((int)('I')<<16)|((int)('D')<<24))) { /* XVID */
204        dec->bs_version = 0; /* Initially assume oldest xvid version */
205      }
206      else {
207            dec->bs_version = 0xffff; /* Initialize to very high value -> assume bugfree stream */
208      }
209    
210          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);          dec->fixed_dimensions = (dec->width > 0 && dec->height > 0);
211    
212          if (dec->fixed_dimensions)    if (dec->fixed_dimensions) {
213                  return decoder_resize(dec);      int ret = decoder_resize(dec);
214        if (ret == XVID_ERR_MEMORY) create->handle = NULL;
215        return ret;
216      }
217          else          else
218                  return 0;                  return 0;
219  }  }
# Line 312  Line 330 
330                  stop_iquant_timer();                  stop_iquant_timer();
331    
332                  start_timer();                  start_timer();
333                  idct(&data[i * 64]);      idct((short * const)&data[i * 64]);
334                  stop_idct_timer();                  stop_idct_timer();
335    
336          }          }
# Line 344  Line 362 
362          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(data, 1, 64, int16_t, CACHE_LINE);
363    
364          int stride = dec->edged_width;          int stride = dec->edged_width;
         int next_block = stride * 8;  
365          int i;          int i;
366          const uint32_t iQuant = pMB->quant;          const uint32_t iQuant = pMB->quant;
367          const int direction = dec->alternate_vertical_scan ? 2 : 0;          const int direction = dec->alternate_vertical_scan ? 2 : 0;
# Line 368  Line 385 
385    
386    
387          if (dec->interlacing && pMB->field_dct) {          if (dec->interlacing && pMB->field_dct) {
                 next_block = stride;  
                 stride *= 2;  
         }  
   
388          dst[0] = pY_Cur;          dst[0] = pY_Cur;
389          dst[2] = pY_Cur + next_block;      dst[1] = pY_Cur + 8;
390          dst[1] = dst[0] + 8;      dst[2] = pY_Cur + stride;
391        dst[3] = dst[2] + 8;
392        dst[4] = pU_Cur;
393        dst[5] = pV_Cur;
394        strides[0] = strides[1] = strides[2] = strides[3] = stride*2;
395        strides[4] = stride/2;
396        strides[5] = stride/2;
397      } else {
398        dst[0] = pY_Cur;
399        dst[1] = pY_Cur + 8;
400        dst[2] = pY_Cur + 8*stride;
401          dst[3] = dst[2] + 8;          dst[3] = dst[2] + 8;
402          dst[4] = pU_Cur;          dst[4] = pU_Cur;
403          dst[5] = pV_Cur;          dst[5] = pV_Cur;
404          strides[0] = strides[1] = strides[2] = strides[3] = stride;          strides[0] = strides[1] = strides[2] = strides[3] = stride;
405          strides[4] = stride/2;          strides[4] = stride/2;
406          strides[5] = stride/2;          strides[5] = stride/2;
407      }
408    
409          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
410                  /* Process only coded blocks */                  /* Process only coded blocks */
# Line 396  Line 420 
420    
421                          /* iDCT */                          /* iDCT */
422                          start_timer();                          start_timer();
423                          idct(&data[0]);        idct((short * const)&data[0]);
424                          stop_idct_timer();                          stop_idct_timer();
425    
426                          /* Add this residual to the predicted block */                          /* Add this residual to the predicted block */
# Line 443  Line 467 
467          CHECK_MV(mv[3]);          CHECK_MV(mv[3]);
468  }  }
469    
470    /* Up to this version, chroma rounding was wrong with qpel.
471     * So we try to be backward compatible to avoid artifacts */
472    #define BS_VERSION_BUGGY_CHROMA_ROUNDING 1
473    
474  /* decode an inter macroblock */  /* decode an inter macroblock */
475  static void  static void
476  decoder_mbinter(DECODER * dec,  decoder_mbinter(DECODER * dec,
# Line 452  Line 480 
480                                  const uint32_t cbp,                                  const uint32_t cbp,
481                                  Bitstream * bs,                                  Bitstream * bs,
482                                  const uint32_t rounding,                                  const uint32_t rounding,
483                                  const int ref)          const int ref,
484                    const int bvop)
485  {  {
486          uint32_t stride = dec->edged_width;          uint32_t stride = dec->edged_width;
487          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
# Line 473  Line 502 
502    
503          start_timer();          start_timer();
504    
505          if (pMB->mode != MODE_INTER4V) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */    if ((pMB->mode != MODE_INTER4V) || (bvop)) { /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
506    
507                  uv_dx = mv[0].x;                  uv_dx = mv[0].x;
508                  uv_dy = mv[0].y;                  uv_dy = mv[0].y;
509                  if (dec->quarterpel) {                  if (dec->quarterpel) {
510                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
511                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
512                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
513                            }
514                            else {
515                          uv_dx /= 2;                          uv_dx /= 2;
516                          uv_dy /= 2;                          uv_dy /= 2;
517                  }                  }
518        }
519                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
520                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
521    
# Line 495  Line 530 
530          } else {        /* MODE_INTER4V */          } else {        /* MODE_INTER4V */
531    
532                  if(dec->quarterpel) {                  if(dec->quarterpel) {
533                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
534                                    int z;
535                                    uv_dx = 0; uv_dy = 0;
536                                    for (z = 0; z < 4; z++) {
537                                      uv_dx += ((mv[z].x>>1) | (mv[z].x&1));
538                                      uv_dy += ((mv[z].y>>1) | (mv[z].y&1));
539                                    }
540                            }
541                            else {
542                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);                          uv_dx = (mv[0].x / 2) + (mv[1].x / 2) + (mv[2].x / 2) + (mv[3].x / 2);
543                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);                          uv_dy = (mv[0].y / 2) + (mv[1].y / 2) + (mv[2].y / 2) + (mv[3].y / 2);
544          }
545                  } else {                  } else {
546                          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;                          uv_dx = mv[0].x + mv[1].x + mv[2].x + mv[3].x;
547                          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;                          uv_dy = mv[0].y + mv[1].y + mv[2].y + mv[3].y;
# Line 542  Line 587 
587                  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);
588  }  }
589    
590    /* decode an inter macroblock in field mode */
591    static void
592    decoder_mbinter_field(DECODER * dec,
593            const MACROBLOCK * pMB,
594            const uint32_t x_pos,
595            const uint32_t y_pos,
596            const uint32_t cbp,
597            Bitstream * bs,
598            const uint32_t rounding,
599            const int ref,
600                    const int bvop)
601    {
602      uint32_t stride = dec->edged_width;
603      uint32_t stride2 = stride / 2;
604    
605      uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
606    
607      int uvtop_dx, uvtop_dy;
608      int uvbot_dx, uvbot_dy;
609      VECTOR mv[4]; /* local copy of mvs */
610    
611      /* Get pointer to memory areas */
612      pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
613      pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
614      pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
615    
616      mv[0] = pMB->mvs[0];
617      mv[1] = pMB->mvs[1];
618      memset(&mv[2],0,2*sizeof(VECTOR));
619    
620      validate_vector(mv, x_pos, y_pos, dec);
621    
622      start_timer();
623    
624      if((pMB->mode!=MODE_INTER4V) || (bvop))   /* INTER, INTER_Q, NOT_CODED, FORWARD, BACKWARD */
625      {
626        /* Prepare top field vector */
627        uvtop_dx = DIV2ROUND(mv[0].x);
628        uvtop_dy = DIV2ROUND(mv[0].y);
629    
630        /* Prepare bottom field vector */
631        uvbot_dx = DIV2ROUND(mv[1].x);
632        uvbot_dy = DIV2ROUND(mv[1].y);
633    
634        if(dec->quarterpel)
635        {
636          /* NOT supported */
637        }
638        else
639        {
640          /* Interpolate top field left part(we use double stride for every 2nd line) */
641          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
642                                16*x_pos,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
643          /* top field right part */
644          interpolate8x8_switch(dec->cur.y,dec->refn[ref].y+pMB->field_for_top*stride,
645                                16*x_pos+8,8*y_pos,mv[0].x, mv[0].y>>1,2*stride, rounding);
646    
647          /* Interpolate bottom field left part(we use double stride for every 2nd line) */
648          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
649                                16*x_pos,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
650          /* Bottom field right part */
651          interpolate8x8_switch(dec->cur.y+stride,dec->refn[ref].y+pMB->field_for_bot*stride,
652                                16*x_pos+8,8*y_pos,mv[1].x, mv[1].y>>1,2*stride, rounding);
653    
654          /* Interpolate field1 U */
655          interpolate8x4_switch(dec->cur.u,dec->refn[ref].u+pMB->field_for_top*stride2,
656                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
657    
658          /* Interpolate field1 V */
659          interpolate8x4_switch(dec->cur.v,dec->refn[ref].v+pMB->field_for_top*stride2,
660                                8*x_pos,4*y_pos,uvtop_dx,DIV2ROUND(uvtop_dy),stride,rounding);
661    
662          /* Interpolate field2 U */
663          interpolate8x4_switch(dec->cur.u+stride2,dec->refn[ref].u+pMB->field_for_bot*stride2,
664                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
665    
666          /* Interpolate field2 V */
667          interpolate8x4_switch(dec->cur.v+stride2,dec->refn[ref].v+pMB->field_for_bot*stride2,
668                                8*x_pos,4*y_pos,uvbot_dx,DIV2ROUND(uvbot_dy),stride,rounding);
669        }
670      }
671      else
672      {
673        /* We don't expect 4 motion vectors in interlaced mode */
674      }
675    
676      stop_comp_timer();
677    
678      /* Must add error correction? */
679      if(cbp)
680       decoder_mb_decode(dec, cbp, bs, pY_Cur, pU_Cur, pV_Cur, pMB);
681    }
682    
683  static void  static void
684  decoder_mbgmc(DECODER * dec,  decoder_mbgmc(DECODER * dec,
685                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
# Line 621  Line 759 
759                                  bound = read_video_packet_header(bs, dec, 0,                                  bound = read_video_packet_header(bs, dec, 0,
760                                                          &quant, NULL, NULL, &intra_dc_threshold);                                                          &quant, NULL, NULL, &intra_dc_threshold);
761                                  x = bound % mb_width;                                  x = bound % mb_width;
762                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
763                          }                          }
764                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
765    
# Line 709  Line 847 
847          ret_mv->y = mv.y;          ret_mv->y = mv.y;
848  }  }
849    
850    /* We use this when decoder runs interlaced -> different prediction */
851    
852    static void get_motion_vector_interlaced(DECODER * dec,
853            Bitstream * bs,
854            int x,
855            int y,
856            int k,
857            MACROBLOCK *pMB,
858            int fcode,
859            const int bound)
860    {
861      const int scale_fac = 1 << (fcode - 1);
862      const int high = (32 * scale_fac) - 1;
863      const int low = ((-32) * scale_fac);
864      const int range = (64 * scale_fac);
865    
866      /* Get interlaced prediction */
867      const VECTOR pmv=get_pmv2_interlaced(dec->mbs,dec->mb_width,bound,x,y,k);
868      VECTOR mv,mvf1,mvf2;
869    
870      if(!pMB->field_pred)
871      {
872        mv.x = get_mv(bs,fcode);
873        mv.y = get_mv(bs,fcode);
874    
875        mv.x += pmv.x;
876        mv.y += pmv.y;
877    
878        if(mv.x<low) {
879          mv.x += range;
880        } else if (mv.x>high) {
881          mv.x-=range;
882        }
883    
884        if (mv.y < low) {
885          mv.y += range;
886        } else if (mv.y > high) {
887          mv.y -= range;
888        }
889    
890        pMB->mvs[0]=pMB->mvs[1]=pMB->mvs[2]=pMB->mvs[3]=mv;
891      }
892      else
893      {
894        mvf1.x = get_mv(bs, fcode);
895        mvf1.y = get_mv(bs, fcode);
896    
897        mvf1.x += pmv.x;
898        mvf1.y = 2*(mvf1.y+pmv.y/2); /* It's multiple of 2 */
899    
900        if (mvf1.x < low) {
901          mvf1.x += range;
902        } else if (mvf1.x > high) {
903          mvf1.x -= range;
904        }
905    
906        if (mvf1.y < low) {
907          mvf1.y += range;
908        } else if (mvf1.y > high) {
909          mvf1.y -= range;
910        }
911    
912        mvf2.x = get_mv(bs, fcode);
913        mvf2.y = get_mv(bs, fcode);
914    
915        mvf2.x += pmv.x;
916        mvf2.y = 2*(mvf2.y+pmv.y/2); /* It's multiple of 2 */
917    
918        if (mvf2.x < low) {
919          mvf2.x += range;
920        } else if (mvf2.x > high) {
921          mvf2.x -= range;
922        }
923    
924        if (mvf2.y < low) {
925          mvf2.y += range;
926        } else if (mvf2.y > high) {
927          mvf2.y -= range;
928        }
929    
930        pMB->mvs[0]=mvf1;
931        pMB->mvs[1]=mvf2;
932        pMB->mvs[2].x=pMB->mvs[3].x=0;
933        pMB->mvs[2].y=pMB->mvs[3].y=0;
934    
935        /* Calculate average for as it is field predicted */
936        pMB->mvs_avg.x=DIV2ROUND(pMB->mvs[0].x+pMB->mvs[1].x);
937        pMB->mvs_avg.y=DIV2ROUND(pMB->mvs[0].y+pMB->mvs[1].y);
938      }
939    }
940    
941  /* for P_VOP set gmc_warp to NULL */  /* for P_VOP set gmc_warp to NULL */
942  static void  static void
943  decoder_pframe(DECODER * dec,  decoder_pframe(DECODER * dec,
# Line 757  Line 986 
986                                  bound = read_video_packet_header(bs, dec, fcode - 1,                                  bound = read_video_packet_header(bs, dec, fcode - 1,
987                                          &quant, &fcode, NULL, &intra_dc_threshold);                                          &quant, &fcode, NULL, &intra_dc_threshold);
988                                  x = bound % mb_width;                                  x = bound % mb_width;
989                                  y = bound / mb_width;          y = MIN((bound / mb_width), (mb_height-1));
990                          }                          }
991                          mb = &dec->mbs[y * dec->mb_width + x];                          mb = &dec->mbs[y * dec->mb_width + x];
992    
# Line 801  Line 1030 
1030                                  }                                  }
1031                                  mb->quant = quant;                                  mb->quant = quant;
1032    
1033            mb->field_pred=0;
1034                                  if (dec->interlacing) {                                  if (dec->interlacing) {
1035                                          if (cbp || intra) {                                          if (cbp || intra) {
1036                                                  mb->field_dct = BitstreamGetBit(bs);                                                  mb->field_dct = BitstreamGetBit(bs);
# Line 826  Line 1056 
1056    
1057                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  } else if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
1058    
1059                                          if (dec->interlacing && mb->field_pred) {            if(dec->interlacing) {
1060                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);              /* Get motion vectors interlaced, field_pred is handled there */
1061                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1], fcode, bound);              get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
1062                                          } else {                                          } else {
1063                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1064                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];                                                  mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
1065                                          }                                          }
1066                                  } else if (mb->mode == MODE_INTER4V ) {                                  } else if (mb->mode == MODE_INTER4V ) {
1067              /* interlaced missing here */
1068                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
1069                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
1070                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
# Line 846  Line 1077 
1077                                          continue;                                          continue;
1078                                  }                                  }
1079    
1080                                  decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0);          /* See how to decode */
1081            if(!mb->field_pred)
1082             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1083            else
1084             decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);
1085    
1086                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */                          } else if (gmc_warp) {  /* a not coded S(GMC)-VOP macroblock */
1087                                  mb->mode = MODE_NOT_CODED_GMC;                                  mb->mode = MODE_NOT_CODED_GMC;
# Line 864  Line 1099 
1099    
1100                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;                                  mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
1101                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;                                  mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
1102            mb->field_pred=0; /* (!) */
1103    
1104                                  decoder_mbinter(dec, mb, x, y, 0, bs,                                  decoder_mbinter(dec, mb, x, y, 0, bs,
1105                                                                  rounding, 0);                                  rounding, 0, 0);
1106    
1107                                  if(dec->out_frm && cp_mb > 0) {                                  if(dec->out_frm && cp_mb > 0) {
1108                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);                                          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
# Line 948  Line 1184 
1184                  b_uv_dy = pMB->b_mvs[0].y;                  b_uv_dy = pMB->b_mvs[0].y;
1185    
1186                  if (dec->quarterpel) {                  if (dec->quarterpel) {
1187                            if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1188                                    uv_dx = (uv_dx>>1) | (uv_dx&1);
1189                                    uv_dy = (uv_dy>>1) | (uv_dy&1);
1190                                    b_uv_dx = (b_uv_dx>>1) | (b_uv_dx&1);
1191                                    b_uv_dy = (b_uv_dy>>1) | (b_uv_dy&1);
1192                            }
1193                            else {
1194                          uv_dx /= 2;                          uv_dx /= 2;
1195                          uv_dy /= 2;                          uv_dy /= 2;
1196                          b_uv_dx /= 2;                          b_uv_dx /= 2;
1197                          b_uv_dy /= 2;                          b_uv_dy /= 2;
1198                  }                  }
1199        }
1200    
1201                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];                  uv_dx = (uv_dx >> 1) + roundtab_79[uv_dx & 0x3];
1202                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];                  uv_dy = (uv_dy >> 1) + roundtab_79[uv_dy & 0x3];
# Line 960  Line 1204 
1204                  b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];                  b_uv_dy = (b_uv_dy >> 1) + roundtab_79[b_uv_dy & 0x3];
1205    
1206          } else {          } else {
1207              if (dec->quarterpel) { /* for qpel the /2 shall be done before summation. We've done it right in the encoder in the past. */
1208                                                             /* TODO: figure out if we ever did it wrong on the encoder side. If yes, add some workaround */
1209                    if (dec->bs_version <= BS_VERSION_BUGGY_CHROMA_ROUNDING) {
1210                            int z;
1211                            uv_dx = 0; uv_dy = 0;
1212                            b_uv_dx = 0; b_uv_dy = 0;
1213                            for (z = 0; z < 4; z++) {
1214                              uv_dx += ((pMB->mvs[z].x>>1) | (pMB->mvs[z].x&1));
1215                              uv_dy += ((pMB->mvs[z].y>>1) | (pMB->mvs[z].y&1));
1216                              b_uv_dx += ((pMB->b_mvs[z].x>>1) | (pMB->b_mvs[z].x&1));
1217                              b_uv_dy += ((pMB->b_mvs[z].y>>1) | (pMB->b_mvs[z].y&1));
1218                            }
1219                    }
1220                    else {
1221                            uv_dx = (pMB->mvs[0].x / 2) + (pMB->mvs[1].x / 2) + (pMB->mvs[2].x / 2) + (pMB->mvs[3].x / 2);
1222                            uv_dy = (pMB->mvs[0].y / 2) + (pMB->mvs[1].y / 2) + (pMB->mvs[2].y / 2) + (pMB->mvs[3].y / 2);
1223                            b_uv_dx = (pMB->b_mvs[0].x / 2) + (pMB->b_mvs[1].x / 2) + (pMB->b_mvs[2].x / 2) + (pMB->b_mvs[3].x / 2);
1224                            b_uv_dy = (pMB->b_mvs[0].y / 2) + (pMB->b_mvs[1].y / 2) + (pMB->b_mvs[2].y / 2) + (pMB->b_mvs[3].y / 2);
1225                    }
1226            } else {
1227                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  uv_dx = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
1228                  uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;                  uv_dy = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
1229                  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;
1230                  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;  
1231                  }                  }
1232    
1233                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];                  uv_dx = (uv_dx >> 3) + roundtab_76[uv_dx & 0xf];
# Line 1088  Line 1346 
1346          return -1;          return -1;
1347  }  }
1348    
1349    static int __inline get_resync_len_b(const int fcode_backward,
1350                                         const int fcode_forward) {
1351      int resync_len = ((fcode_forward>fcode_backward) ? fcode_forward : fcode_backward) - 1;
1352      if (resync_len < 1) resync_len = 1;
1353      return resync_len;
1354    }
1355    
1356  static void  static void
1357  decoder_bframe(DECODER * dec,  decoder_bframe(DECODER * dec,
1358                                  Bitstream * bs,                                  Bitstream * bs,
# Line 1099  Line 1364 
1364          VECTOR mv;          VECTOR mv;
1365          const VECTOR zeromv = {0,0};          const VECTOR zeromv = {0,0};
1366          int i;          int i;
1367      int resync_len;
1368    
1369          if (!dec->is_edged[0]) {          if (!dec->is_edged[0]) {
1370                  start_timer();                  start_timer();
# Line 1116  Line 1382 
1382                  stop_edges_timer();                  stop_edges_timer();
1383          }          }
1384    
1385      resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1386          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1387                  /* Initialize Pred Motion Vector */                  /* Initialize Pred Motion Vector */
1388                  dec->p_fmv = dec->p_bmv = zeromv;                  dec->p_fmv = dec->p_bmv = zeromv;
1389                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
1390                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1391                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1392                          const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;        int intra_dc_threshold; /* fake variable */
                         int32_t intra_dc_threshold; /* fake variable */  
   
                         if (check_resync_marker(bs, fcode_max  - 1)) {  
                                 int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,  
                                                                                                          &fcode_forward, &fcode_backward, &intra_dc_threshold);  
                                 x = bound % dec->mb_width;  
                                 y = bound / dec->mb_width;  
                                 /* reset predicted macroblocks */  
                                 dec->p_fmv = dec->p_bmv = zeromv;  
                         }  
1393    
1394                          mv =                          mv =
1395                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
# Line 1148  Line 1405 
1405                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1406                                  mb->cbp = 0;                                  mb->cbp = 0;
1407                                  mb->mode = MODE_FORWARD;                                  mb->mode = MODE_FORWARD;
1408                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1409                                  continue;                                  continue;
1410                          }                          }
1411    
1412          if (check_resync_marker(bs, resync_len)) {
1413            int bound = read_video_packet_header(bs, dec, resync_len, &quant,
1414                               &fcode_forward, &fcode_backward, &intra_dc_threshold);
1415    
1416                    bound = MAX(0, bound--); /* valid bound must always be >0 */
1417            x = bound % dec->mb_width;
1418            y = MIN((bound / dec->mb_width), (dec->mb_height-1));
1419            /* reset predicted macroblocks */
1420            dec->p_fmv = dec->p_bmv = zeromv;
1421            /* update resync len with new fcodes */
1422            resync_len = get_resync_len_b(fcode_backward, fcode_forward);
1423                    continue; /* re-init loop */
1424              }
1425    
1426                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */                          if (!BitstreamGetBit(bs)) {     /* modb=='0' */
1427                                  const uint8_t modb2 = BitstreamGetBit(bs);                                  const uint8_t modb2 = BitstreamGetBit(bs);
1428    
# Line 1231  Line 1502 
1502                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
1503                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1504    
1505                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
1506                                  break;                                  break;
1507    
1508                          case MODE_FORWARD:                          case MODE_FORWARD:
1509                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);                                  get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
1510                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
1511    
1512                                  decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1);          decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
1513                                  break;                                  break;
1514    
1515                          default:                          default:
# Line 1249  Line 1520 
1520  }  }
1521    
1522  /* perform post processing if necessary, and output the image */  /* perform post processing if necessary, and output the image */
1523  void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,  static void decoder_output(DECODER * dec, IMAGE * img, MACROBLOCK * mbs,
1524                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,                                          xvid_dec_frame_t * frame, xvid_dec_stats_t * stats,
1525                                          int coding_type, int quant)                                          int coding_type, int quant)
1526  {  {
# Line 1265  Line 1536 
1536                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);                  image_copy(&dec->tmp, img, dec->edged_width, dec->height);
1537                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,                  image_postproc(&dec->postproc, &dec->tmp, dec->edged_width,
1538                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,                                             mbs, dec->mb_width, dec->mb_height, dec->mb_width,
1539                                             frame->general, brightness, dec->frames, (coding_type == B_VOP));               frame->general, brightness, dec->frames, (coding_type == B_VOP), dec->num_threads);
1540                  img = &dec->tmp;                  img = &dec->tmp;
1541          }          }
1542    
# Line 1280  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 1371  Line 1642 
1642          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */          if (coding_type == -2 || coding_type == -3) {   /* vol and/or resize */
1643    
1644                  if (coding_type == -3)                  if (coding_type == -3)
1645                          decoder_resize(dec);        if (decoder_resize(dec)) return XVID_ERR_MEMORY;
1646    
1647                  if (stats) {                  if (stats) {
1648                          stats->type = XVID_TYPE_VOL;                          stats->type = XVID_TYPE_VOL;
# Line 1394  Line 1665 
1665                  goto repeat;                  goto repeat;
1666          }          }
1667    
1668          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 */
1669    
1670          /* packed_mode: special-N_VOP treament */          /* packed_mode: special-N_VOP treament */
1671          if (dec->packed_mode && coding_type == N_VOP) {          if (dec->packed_mode && coding_type == N_VOP) {

Legend:
Removed from v.1.71  
changed lines
  Added in v.1.86

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