[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.23, Sun Jun 30 10:46:29 2002 UTC revision 1.37.2.1, Thu Sep 26 01:54:54 2002 UTC
# Line 32  Line 32 
32   *   *
33   *  History:   *  History:
34   *   *
35     *  15.07.2002  fix a bug in B-frame decode at DIRECT mode
36     *              MinChen <chenm001@163.com>
37     *  10.07.2002  added BFRAMES_DEC_DEBUG support
38     *              Fix a little bug for low_delay flage
39     *              MinChen <chenm001@163.com>
40   *  28.06.2002  added basic resync support to iframe/pframe_decode()   *  28.06.2002  added basic resync support to iframe/pframe_decode()
41   *      22.06.2002      added primative N_VOP support   *      22.06.2002      added primative N_VOP support
42   *                              #define BFRAMES_DEC now enables Minchenm's bframe decoder   *                              #define BFRAMES_DEC now enables Minchen's bframe decoder
43   *  08.05.2002  add low_delay support for B_VOP decode   *  08.05.2002  add low_delay support for B_VOP decode
44   *              MinChen <chenm001@163.com>   *              MinChen <chenm001@163.com>
45   *  05.05.2002  fix some B-frame decode problem   *  05.05.2002  fix some B-frame decode problem
# Line 57  Line 62 
62  #include <stdlib.h>  #include <stdlib.h>
63  #include <string.h>  #include <string.h>
64    
65    #ifdef BFRAMES_DEC_DEBUG
66            #define BFRAMES_DEC
67    #endif
68    
69  #include "xvid.h"  #include "xvid.h"
70  #include "portab.h"  #include "portab.h"
71    
# Line 259  Line 268 
268                  start_timer();                  start_timer();
269                  if (cbp & (1 << (5 - i)))       // coded                  if (cbp & (1 << (5 - i)))       // coded
270                  {                  {
271                          get_intra_block(bs, &block[i * 64], pMB->acpred_directions[i],                          int direction = dec->alternate_vertical_scan ?
272                                                          start_coeff);                                  2 : pMB->acpred_directions[i];
273    
274                            get_intra_block(bs, &block[i * 64], direction, start_coeff);
275                  }                  }
276                  stop_coding_timer();                  stop_coding_timer();
277    
# Line 339  Line 350 
350                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
351                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
352    
353                    if (dec->quarterpel)
354                    {
355                            uv_dx = (uv_dx >> 1) | (uv_dx & 1);
356                            uv_dy = (uv_dy >> 1) | (uv_dy & 1);
357                    }
358    
359                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;                  uv_dx = (uv_dx & 3) ? (uv_dx >> 1) | 1 : uv_dx / 2;
360                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;                  uv_dy = (uv_dy & 3) ? (uv_dy >> 1) | 1 : uv_dy / 2;
361          } else {          } else {
362                  int sum;                  int sum;
   
363                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;                  sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;
364                  uv_dx =  
365                          (sum ==                  if (dec->quarterpel)
366                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +                  {
367                                                                    (ABS(sum) / 16) * 2));                          sum /= 2;
368                    }
369    
370                    uv_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
371    
372                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;                  sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;
373                  uv_dy =  
374                          (sum ==                  if (dec->quarterpel)
375                           0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] +                  {
376                                                                    (ABS(sum) / 16) * 2));                          sum /= 2;
377                    }
378    
379                    uv_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
380          }          }
381    
382          start_timer();          start_timer();
383            if(dec->quarterpel) {
384                    DEBUG("QUARTERPEL");
385                    interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos,
386                                                                      pMB->mvs[0].x, pMB->mvs[0].y, stride,  rounding);
387                    interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,
388                                                                      pMB->mvs[1].x, pMB->mvs[1].y, stride,  rounding);
389                    interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,
390                                                                      pMB->mvs[2].x, pMB->mvs[2].y, stride,  rounding);
391                    interpolate8x8_quarterpel(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,
392                                                                      pMB->mvs[3].x, pMB->mvs[3].y, stride,  rounding);
393            }
394            else {
395          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos, 16 * y_pos,          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos, 16 * y_pos,
396                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);                                                    pMB->mvs[0].x, pMB->mvs[0].y, stride, rounding);
397          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos + 8,                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos,
398                                                    16 * y_pos, pMB->mvs[1].x, pMB->mvs[1].y, stride,                                                            pMB->mvs[1].x, pMB->mvs[1].y, stride,  rounding);
399                                                    rounding);                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos, 16*y_pos + 8,
400          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos,                                                            pMB->mvs[2].x, pMB->mvs[2].y, stride,  rounding);
401                                                    16 * y_pos + 8, pMB->mvs[2].x, pMB->mvs[2].y, stride,                  interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16*x_pos + 8, 16*y_pos + 8,
402                                                    rounding);                                                            pMB->mvs[3].x, pMB->mvs[3].y, stride,  rounding);
403          interpolate8x8_switch(dec->cur.y, dec->refn[0].y, 16 * x_pos + 8,          }
404                                                    16 * y_pos + 8, pMB->mvs[3].x, pMB->mvs[3].y, stride,  
                                                   rounding);  
405          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,          interpolate8x8_switch(dec->cur.u, dec->refn[0].u, 8 * x_pos, 8 * y_pos,
406                                                    uv_dx, uv_dy, stride2, rounding);                                                    uv_dx, uv_dy, stride2, rounding);
407          interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,          interpolate8x8_switch(dec->cur.v, dec->refn[0].v, 8 * x_pos, 8 * y_pos,
# Line 376  Line 409 
409          stop_comp_timer();          stop_comp_timer();
410    
411          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
412                    int direction = dec->alternate_vertical_scan ? 2 : 0;
413    
414                  if (cbp & (1 << (5 - i)))       // coded                  if (cbp & (1 << (5 - i)))       // coded
415                  {                  {
416                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear
417    
418                          start_timer();                          start_timer();
419                          get_inter_block(bs, &block[i * 64]);                          get_inter_block(bs, &block[i * 64], direction);
420                          stop_coding_timer();                          stop_coding_timer();
421    
422                          start_timer();                          start_timer();
# Line 471  Line 506 
506                                  }                                  }
507                          }                          }
508                          mb->quant = quant;                          mb->quant = quant;
509                            mb->mvs[0].x = mb->mvs[0].y =
510                            mb->mvs[1].x = mb->mvs[1].y =
511                            mb->mvs[2].x = mb->mvs[2].y =
512                            mb->mvs[3].x = mb->mvs[3].y =0;
513    
514                          if (dec->interlacing) {                          if (dec->interlacing) {
515                                  mb->field_dct = BitstreamGetBit(bs);                                  mb->field_dct = BitstreamGetBit(bs);
# Line 480  Line 519 
519                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
520                                                          intra_dc_threshold, bound);                                                          intra_dc_threshold, bound);
521                  }                  }
522                    if(dec->out_frm)
523                      output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,0,y,dec->mb_width);
524    
525          }          }
526    
527  }  }
# Line 501  Line 543 
543          int low = ((-32) * scale_fac);          int low = ((-32) * scale_fac);
544          int range = (64 * scale_fac);          int range = (64 * scale_fac);
545    
546          VECTOR pmv[4];          VECTOR pmv;
         int32_t psad[4];  
   
547          int mv_x, mv_y;          int mv_x, mv_y;
         int pmv_x, pmv_y;  
   
548    
549          get_pmvdata2(dec->mbs, x, y, dec->mb_width, k, pmv, psad, bound);          pmv = get_pmv2(dec->mbs, dec->mb_width, bound, x, y, k);
   
         pmv_x = pmv[0].x;  
         pmv_y = pmv[0].y;  
550    
551          mv_x = get_mv(bs, fcode);          mv_x = get_mv(bs, fcode);
552          mv_y = get_mv(bs, fcode);          mv_y = get_mv(bs, fcode);
553    
554          DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv_x, pmv_y);          DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv.x, pmv.y);
555    
556          mv_x += pmv_x;          mv_x += pmv.x;
557          mv_y += pmv_y;          mv_y += pmv.y;
558    
559          if (mv_x < low) {          if (mv_x < low) {
560                  mv_x += range;                  mv_x += range;
# Line 550  Line 585 
585    
586          uint32_t x, y;          uint32_t x, y;
587          uint32_t bound;          uint32_t bound;
588            int cp_mb, st_mb;
589    
590          start_timer();          start_timer();
591          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
592                                     dec->width, dec->height, dec->interlacing);                                     dec->width, dec->height);
593          stop_edges_timer();          stop_edges_timer();
594    
595          bound = 0;          bound = 0;
596    
597          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
598                    cp_mb = st_mb = 0;
599                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
600                          MACROBLOCK *mb;                          MACROBLOCK *mb;
601    
# Line 586  Line 623 
623                                  uint32_t cbp;                                  uint32_t cbp;
624                                  uint32_t intra;                                  uint32_t intra;
625    
626                                    cp_mb++;
627                                  mcbpc = get_mcbpc_inter(bs);                                  mcbpc = get_mcbpc_inter(bs);
628                                  mb->mode = mcbpc & 7;                                  mb->mode = mcbpc & 7;
629                                  cbpc = (mcbpc >> 4);                                  cbpc = (mcbpc >> 4);
# Line 619  Line 657 
657                                  mb->quant = quant;                                  mb->quant = quant;
658    
659                                  if (dec->interlacing) {                                  if (dec->interlacing) {
660                                            if (cbp || intra) {
661                                          mb->field_dct = BitstreamGetBit(bs);                                          mb->field_dct = BitstreamGetBit(bs);
662                                          DEBUG1("decp: field_dct: ", mb->field_dct);                                          DEBUG1("decp: field_dct: ", mb->field_dct);
663                                            }
664    
665                                          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
666                                                  mb->field_pred = BitstreamGetBit(bs);                                                  mb->field_pred = BitstreamGetBit(bs);
# Line 649  Line 689 
689                                                  mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =                                                  mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =
690                                                          mb->mvs[0].y;                                                          mb->mvs[0].y;
691                                          }                                          }
692                                  } else if (mb->mode ==                                  } else if (mb->mode == MODE_INTER4V ) {
693                                                     MODE_INTER4V /* || mb->mode == MODE_INTER4V_Q */ ) {  
694                                          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);
695                                          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);
696                                          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 670  Line 710 
710                                                                  rounding);                                                                  rounding);
711                          } else                          // not coded                          } else                          // not coded
712                          {                          {
713                                  //DEBUG2("P-frame MB at (X,Y)=",x,y);                                  DEBUG2("P-frame MB at (X,Y)=",x,y);
714                                  mb->mode = MODE_NOT_CODED;                                  mb->mode = MODE_NOT_CODED;
715                                  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;
716                                  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;
# Line 712  Line 752 
752                                                                   dec->refn[0].v +                                                                   dec->refn[0].v +
753                                                                   (8 * y) * dec->edged_width / 2 + (8 * x),                                                                   (8 * y) * dec->edged_width / 2 + (8 * x),
754                                                                   dec->edged_width / 2);                                                                   dec->edged_width / 2);
   
755                                  stop_transfer_timer();                                  stop_transfer_timer();
756                                    if(dec->out_frm && cp_mb > 0) {
757                                      output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
758                                      cp_mb = 0;
759                                    }
760                                    st_mb = x+1;
761                          }                          }
762                  }                  }
763                    if(dec->out_frm && cp_mb > 0)
764                      output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
765          }          }
766  }  }
767    
# Line 793  Line 839 
839          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
840          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
841    
842    
843          if (!(pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {          if (!(pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {
844                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
845                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
# Line 833  Line 880 
880          stop_comp_timer();          stop_comp_timer();
881    
882          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
883                    int direction = dec->alternate_vertical_scan ? 2 : 0;
884    
885                  if (cbp & (1 << (5 - i)))       // coded                  if (cbp & (1 << (5 - i)))       // coded
886                  {                  {
887                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear
888    
889                          start_timer();                          start_timer();
890                          get_inter_block(bs, &block[i * 64]);                          get_inter_block(bs, &block[i * 64], direction);
891                          stop_coding_timer();                          stop_coding_timer();
892    
893                          start_timer();                          start_timer();
# Line 886  Line 935 
935                                                             const MACROBLOCK * pMB,                                                             const MACROBLOCK * pMB,
936                                                             const uint32_t x_pos,                                                             const uint32_t x_pos,
937                                                             const uint32_t y_pos,                                                             const uint32_t y_pos,
                                                            const uint32_t cbp,  
938                                                             Bitstream * bs)                                                             Bitstream * bs)
939  {  {
940    
# Line 901  Line 949 
949          int b_uv_dx, b_uv_dy;          int b_uv_dx, b_uv_dy;
950          uint32_t i;          uint32_t i;
951          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
952        const uint32_t cbp = pMB->cbp;
953    
954          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
955          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
956          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
957    
958    
959          if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {          if ((pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)) {
960                  uv_dx = pMB->mvs[0].x;                  uv_dx = pMB->mvs[0].x;
961                  uv_dy = pMB->mvs[0].y;                  uv_dy = pMB->mvs[0].y;
# Line 995  Line 1045 
1045                                           stride2);                                           stride2);
1046          interpolate8x8_c(dec->cur.v, dec->refn[2].v, 8 * x_pos, 8 * y_pos,          interpolate8x8_c(dec->cur.v, dec->refn[2].v, 8 * x_pos, 8 * y_pos,
1047                                           stride2);                                           stride2);
   
1048          stop_comp_timer();          stop_comp_timer();
1049    
1050          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
1051                    int direction = dec->alternate_vertical_scan ? 2 : 0;
1052    
1053                  if (cbp & (1 << (5 - i)))       // coded                  if (cbp & (1 << (5 - i)))       // coded
1054                  {                  {
1055                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear                          memset(&block[i * 64], 0, 64 * sizeof(int16_t));        // clear
1056    
1057                          start_timer();                          start_timer();
1058                          get_inter_block(bs, &block[i * 64]);                          get_inter_block(bs, &block[i * 64], direction);
1059                          stop_coding_timer();                          stop_coding_timer();
1060    
1061                          start_timer();                          start_timer();
# Line 1086  Line 1137 
1137                             int fcode_forward,                             int fcode_forward,
1138                             int fcode_backward)                             int fcode_backward)
1139  {  {
   
1140          uint32_t x, y;          uint32_t x, y;
1141          VECTOR mv, zeromv;          VECTOR mv;
1142            const VECTOR zeromv = {0,0};
1143    #ifdef BFRAMES_DEC_DEBUG
1144            FILE *fp;
1145            static char first=0;
1146    #define BFRAME_DEBUG    if (!first && fp){ \
1147                    fprintf(fp,"Y=%3d   X=%3d   MB=%2d   CBP=%02X\n",y,x,mb->mb_type,mb->cbp); \
1148            }
1149    #endif
1150    
1151          start_timer();          start_timer();
1152          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,          image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
1153                                     dec->width, dec->height, dec->interlacing);                                     dec->width, dec->height);
1154          //image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height, dec->width, dec->height, dec->interlacing);          image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
1155                                       dec->width, dec->height);
1156          stop_edges_timer();          stop_edges_timer();
1157    
1158    #ifdef BFRAMES_DEC_DEBUG
1159            if (!first){
1160                    fp=fopen("C:\\XVIDDBG.TXT","w");
1161            }
1162    #endif
1163    
1164          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
1165                  // Initialize Pred Motion Vector                  // Initialize Pred Motion Vector
1166                  dec->p_fmv.x = dec->p_fmv.y = dec->p_bmv.x = dec->p_bmv.y = 0;                  dec->p_fmv = dec->p_bmv = zeromv;
1167                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
1168                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
1169                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];                          MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
1170    
1171                          mb->mvs[0].x = mb->mvs[0].y = zeromv.x = zeromv.y = mv.x = mv.y =                          mv =
1172                                  0;                          mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
1173                            mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
1174    
1175                          // the last P_VOP is skip macroblock ?                          // the last P_VOP is skip macroblock ?
1176                          if (last_mb->mode == MODE_NOT_CODED) {                          if (last_mb->mode == MODE_NOT_CODED) {
1177                                  //DEBUG2("Skip MB in B-frame at (X,Y)=!",x,y);                                  //DEBUG2("Skip MB in B-frame at (X,Y)=!",x,y);
                                 mb->mb_type = MODE_FORWARD;  
1178                                  mb->cbp = 0;                                  mb->cbp = 0;
1179                                  mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;  #ifdef BFRAMES_DEC_DEBUG
1180                                  mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;                                  mb->mb_type = MODE_NOT_CODED;
1181                                  mb->quant = 8;          BFRAME_DEBUG
1182    #endif
1183                                    mb->mb_type = MODE_FORWARD;
1184                                    mb->quant = last_mb->quant;
1185                                    //mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = mb->mvs[0].x;
1186                                    //mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = mb->mvs[0].y;
1187    
1188                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, mb->quant, 1);
1189                                  continue;                                  continue;
1190                          }                          }
                         //t=BitstreamShowBits(bs,32);  
1191    
1192                          if (!BitstreamGetBit(bs)) {     // modb=='0'                          if (!BitstreamGetBit(bs)) {     // modb=='0'
1193                                  const uint8_t modb2 = BitstreamGetBit(bs);                                  const uint8_t modb2 = BitstreamGetBit(bs);
# Line 1139  Line 1207 
1207                                          } else if (quant < 1) {                                          } else if (quant < 1) {
1208                                                  quant = 1;                                                  quant = 1;
1209                                          }                                          }
                                 } else {  
                                         quant = 8;  
1210                                  }                                  }
                                 mb->quant = quant;  
1211                          } else {                          } else {
1212                                  mb->mb_type = MODE_DIRECT_NONE_MV;                                  mb->mb_type = MODE_DIRECT_NONE_MV;
1213                                  mb->cbp = 0;                                  mb->cbp = 0;
1214                          }                          }
1215    
1216                          mb->mode = MODE_INTER;                          mb->quant = quant;
1217                            mb->mode = MODE_INTER4V;
1218                          //DEBUG1("Switch bm_type=",mb->mb_type);                          //DEBUG1("Switch bm_type=",mb->mb_type);
1219    
1220    #ifdef BFRAMES_DEC_DEBUG
1221            BFRAME_DEBUG
1222    #endif
1223    
1224                          switch (mb->mb_type) {                          switch (mb->mb_type) {
1225                          case MODE_DIRECT:                          case MODE_DIRECT:
1226                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], 1, zeromv);                                  get_b_motion_vector(dec, bs, x, y, &mv, 1, zeromv);
1227    
1228                          case MODE_DIRECT_NONE_MV:                          case MODE_DIRECT_NONE_MV:
1229                                  {                               // Because this file is a C file not C++ so I use '{' to define var                                  {
1230                                          const int64_t TRB = dec->time_pp - dec->time_bp, TRD =                                          const int64_t TRB = dec->time_pp - dec->time_bp, TRD = dec->time_pp;
                                                 dec->time_pp;  
1231                                          int i;                                          int i;
1232    
1233                                          for (i = 0; i < 4; i++) {                                          for (i = 0; i < 4; i++) {
1234                                                  mb->mvs[i].x =                                                  mb->mvs[i].x = (int32_t) ((TRB * last_mb->mvs[i].x)
1235                                                          (int32_t) ((TRB * last_mb->mvs[i].x) / TRD +                                                                        / TRD + mv.x);
1236                                                                             mb->mvs[0].x);                                                  mb->b_mvs[i].x = (int32_t) ((mv.x == 0)
1237                                                  mb->b_mvs[i].x =                                                                                  ? ((TRB - TRD) * last_mb->mvs[i].x)
1238                                                          (int32_t) ((mb->mvs[0].x ==                                                                                    / TRD
1239                                                                                  0) ? ((TRB -                                                                                  : mb->mvs[i].x - last_mb->mvs[i].x);
1240                                                                                             TRD) * last_mb->mvs[i].x) /                                                  mb->mvs[i].y = (int32_t) ((TRB * last_mb->mvs[i].y)
1241                                                                             TRD : mb->mvs[i].x - last_mb->mvs[i].x);                                                                        / TRD + mv.y);
1242                                                  mb->mvs[i].y =                                                  mb->b_mvs[i].y = (int32_t) ((mv.y == 0)
1243                                                          (int32_t) ((TRB * last_mb->mvs[i].y) / TRD +                                                                                  ? ((TRB - TRD) * last_mb->mvs[i].y)
1244                                                                             mb->mvs[0].y);                                                                                    / TRD
1245                                                  mb->b_mvs[i].y =                                                                              : mb->mvs[i].y - last_mb->mvs[i].y);
                                                         (int32_t) ((mb->mvs[0].y ==  
                                                                                 0) ? ((TRB -  
                                                                                            TRD) * last_mb->mvs[i].y) /  
                                                                            TRD : mb->mvs[i].y - last_mb->mvs[i].y);  
1246                                          }                                          }
1247                                          //DEBUG("B-frame Direct!\n");                                          //DEBUG("B-frame Direct!\n");
1248                                  }                                  }
                                 mb->mode = MODE_INTER4V;  
1249                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1250                                                                                             mb, x, y, mb->cbp, bs);                                                                                             mb, x, y, bs);
1251                                  break;                                  break;
1252    
1253                          case MODE_INTERPOLATE:                          case MODE_INTERPOLATE:
1254                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,
1255                                                                          dec->p_fmv);                                                                          dec->p_fmv);
1256                                  dec->p_fmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                         mb->mvs[0].x;  
                                 dec->p_fmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =  
                                         mb->mvs[0].y;  
1257    
1258                                  get_b_motion_vector(dec, bs, x, y, &mb->b_mvs[0],                                  get_b_motion_vector(dec, bs, x, y, &mb->b_mvs[0],
1259                                                                          fcode_backward, dec->p_bmv);                                                                          fcode_backward, dec->p_bmv);
1260                                  dec->p_bmv.x = mb->b_mvs[1].x = mb->b_mvs[2].x =                                  dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] =
1261                                          mb->b_mvs[3].x = mb->b_mvs[0].x;                                          mb->b_mvs[3] = mb->b_mvs[0];
                                 dec->p_bmv.y = mb->b_mvs[1].y = mb->b_mvs[2].y =  
                                         mb->b_mvs[3].y = mb->b_mvs[0].y;  
1262    
1263                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],                                  decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
1264                                                                                             mb, x, y, mb->cbp, bs);                                                                                             mb, x, y, bs);
1265                                  //DEBUG("B-frame Bidir!\n");                                  //DEBUG("B-frame Bidir!\n");
1266                                  break;                                  break;
1267    
1268                          case MODE_BACKWARD:                          case MODE_BACKWARD:
1269                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_backward,                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_backward,
1270                                                                          dec->p_bmv);                                                                          dec->p_bmv);
1271                                  dec->p_bmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =                                  dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                         mb->mvs[0].x;  
                                 dec->p_bmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =  
                                         mb->mvs[0].y;  
1272    
1273                                    mb->mode = MODE_INTER;
1274                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 0);                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 0);
1275                                  //DEBUG("B-frame Backward!\n");                                  //DEBUG("B-frame Backward!\n");
1276                                  break;                                  break;
# Line 1221  Line 1278 
1278                          case MODE_FORWARD:                          case MODE_FORWARD:
1279                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,                                  get_b_motion_vector(dec, bs, x, y, &mb->mvs[0], fcode_forward,
1280                                                                          dec->p_fmv);                                                                          dec->p_fmv);
1281                                  dec->p_fmv.x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =                                  dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] =     mb->mvs[0];
                                         mb->mvs[0].x;  
                                 dec->p_fmv.y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =  
                                         mb->mvs[0].y;  
1282    
1283                                    mb->mode = MODE_INTER;
1284                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);                                  decoder_bf_mbinter(dec, mb, x, y, mb->cbp, bs, quant, 1);
1285                                  //DEBUG("B-frame Forward!\n");                                  //DEBUG("B-frame Forward!\n");
1286                                  break;                                  break;
# Line 1236  Line 1291 
1291    
1292                  }                                               // end of FOR                  }                                               // end of FOR
1293          }          }
1294    #ifdef BFRAMES_DEC_DEBUG
1295            if (!first){
1296                    first=1;
1297                    if (fp)
1298                            fclose(fp);
1299            }
1300    #endif
1301  }  }
1302    
1303  // swap two MACROBLOCK array  // swap two MACROBLOCK array
# Line 1264  Line 1326 
1326    
1327          start_global_timer();          start_global_timer();
1328    
1329            dec->out_frm = (frame->colorspace == XVID_CSP_EXTERN) ? frame->image : NULL;
1330    
1331          BitstreamInit(&bs, frame->bitstream, frame->length);          BitstreamInit(&bs, frame->bitstream, frame->length);
1332    
1333          // add by chenm001 <chenm001@163.com>          // add by chenm001 <chenm001@163.com>
# Line 1313  Line 1377 
1377                  return XVID_ERR_FAIL;                  return XVID_ERR_FAIL;
1378          }          }
1379    
1380    #ifdef BFRAMES_DEC_DEBUG
1381            if (frame->length != BitstreamPos(&bs) / 8){
1382                    DEBUG2("InLen/UseLen",frame->length, BitstreamPos(&bs) / 8);
1383            }
1384    #endif
1385          frame->length = BitstreamPos(&bs) / 8;          frame->length = BitstreamPos(&bs) / 8;
1386    
1387    
1388  #ifdef BFRAMES_DEC  #ifdef BFRAMES_DEC
1389          // test if no B_VOP          // test if no B_VOP
1390          if (dec->low_delay) {          if (dec->low_delay || dec->frames == 0) {
1391  #endif  #endif
1392                  image_output(&dec->cur, dec->width, dec->height, dec->edged_width,                  image_output(&dec->cur, dec->width, dec->height, dec->edged_width,
1393                                           frame->image, frame->stride, frame->colorspace);                                           frame->image, frame->stride, frame->colorspace);
1394    
1395  #ifdef BFRAMES_DEC  #ifdef BFRAMES_DEC
1396          } else {          } else {
1397                  if (dec->frames >= 1) {                  if (dec->frames >= 1) {
# Line 1342  Line 1413 
1413          if (vop_type == I_VOP || vop_type == P_VOP) {          if (vop_type == I_VOP || vop_type == P_VOP) {
1414                  image_swap(&dec->refn[0], &dec->refn[1]);                  image_swap(&dec->refn[0], &dec->refn[1]);
1415                  image_swap(&dec->cur, &dec->refn[0]);                  image_swap(&dec->cur, &dec->refn[0]);
1416    
1417                  // swap MACROBLOCK                  // swap MACROBLOCK
1418                  if (dec->low_delay && vop_type == P_VOP)                  // the Divx will not set the low_delay flage some times
1419                    // so follow code will wrong to not swap at that time
1420                    // this will broken bitstream! so I'm change it,
1421                    // But that is not the best way! can anyone tell me how
1422                    // to do another way?
1423                    // 18-07-2002   MinChen<chenm001@163.com>
1424                    //if (!dec->low_delay && vop_type == P_VOP)
1425                    if (vop_type == P_VOP)
1426                          mb_swap(&dec->mbs, &dec->last_mbs);                          mb_swap(&dec->mbs, &dec->last_mbs);
1427          }          }
1428    

Legend:
Removed from v.1.23  
changed lines
  Added in v.1.37.2.1

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