[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.25, Tue Jul 9 01:09:33 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()
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 56  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 168  Line 178 
178  }  }
179    
180    
   
 /* ****************************************************************  
 NIC 28.06.2002  
         riscritta la 'decoder_create' per cambiarne l'interfaccia e poterla  
         usare nella dll caricata dall'IM1 player  
         IM1_decoder_create(XVID_DEC_PARAM * param,XVID_DEC_FRAME * frame)  
 **************************************************************** */  
 //XVID_DEC_FRAME * frame  
   
 int  
 IM1_decoder_create(XVID_DEC_PARAM * param,XVID_DEC_FRAME * frame)  
 {  
         DECODER *dec;  
         Bitstream bs;  
         uint32_t rounding;  
         uint32_t quant;  
         uint32_t fcode_forward;  
         uint32_t fcode_backward;  
         uint32_t intra_dc_threshold;  
   
         dec = xvid_malloc(sizeof(DECODER), CACHE_LINE);  
         if (dec == NULL) {  
                 return XVID_ERR_MEMORY;  
         }  
         param->handle = dec;  
   
   
         BitstreamInit(&bs, frame->bitstream, frame->length);//NIC  
   
         //NIC  
         BitstreamReadHeaders(&bs, dec, &rounding, &quant, &fcode_forward,  
                                                          &fcode_backward, &intra_dc_threshold);  
   
   
         param->width = dec->width;                      //NIC added  
         param->height = dec->height;            //NIC added  
         //dec->width = param->width;            //NIC commentate  
         //dec->height = param->height;          //NIC commentate  
   
         dec->mb_width = (dec->width + 15) / 16;  
         dec->mb_height = (dec->height + 15) / 16;  
   
         dec->edged_width = 16 * dec->mb_width + 2 * EDGE_SIZE;  
         dec->edged_height = 16 * dec->mb_height + 2 * EDGE_SIZE;  
         dec->low_delay = 0;  
   
         if (image_create(&dec->cur, dec->edged_width, dec->edged_height)) {  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         if (image_create(&dec->refn[0], dec->edged_width, dec->edged_height)) {  
                 image_destroy(&dec->cur, dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
         // add by chenm001 <chenm001@163.com>  
         // for 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->refn[2], 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;  
         }  
   
         dec->mbs =  
                 xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,  
                                         CACHE_LINE);  
         if (dec->mbs == NULL) {  
                 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->refn[2], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         memset(dec->mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);  
   
         // add by chenm001 <chenm001@163.com>  
         // for skip MB flag  
         dec->last_mbs =  
                 xvid_malloc(sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height,  
                                         CACHE_LINE);  
         if (dec->last_mbs == NULL) {  
                 xvid_free(dec->mbs);  
                 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->refn[2], dec->edged_width, dec->edged_height);  
                 xvid_free(dec);  
                 return XVID_ERR_MEMORY;  
         }  
   
         memset(dec->last_mbs, 0, sizeof(MACROBLOCK) * dec->mb_width * dec->mb_height);  
   
         init_timer();  
   
         // add by chenm001 <chenm001@163.com>  
         // for support B-frame to save reference frame's time  
         dec->frames = -1;  
         dec->time = dec->time_base = dec->last_time_base = 0;  
   
         return XVID_ERR_OK;  
 }  
 /* ****************************************************************  
                                                         END NIC  
 **************************************************************** */  
   
181  int  int
182  decoder_destroy(DECODER * dec)  decoder_destroy(DECODER * dec)
183  {  {
# Line 319  Line 213 
213                                  const uint32_t cbp,                                  const uint32_t cbp,
214                                  Bitstream * bs,                                  Bitstream * bs,
215                                  const uint32_t quant,                                  const uint32_t quant,
216                                  const uint32_t intra_dc_threshold)                                  const uint32_t intra_dc_threshold,
217                                    const unsigned int bound)
218  {  {
219    
220          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(block, 6, 64, int16_t, CACHE_LINE);
# Line 345  Line 240 
240    
241                  start_timer();                  start_timer();
242                  predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],                  predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i, &block[i * 64],
243                                           iQuant, iDcScaler, predictors);                                           iQuant, iDcScaler, predictors, bound);
244                  if (!acpred_flag) {                  if (!acpred_flag) {
245                          pMB->acpred_directions[i] = 0;                          pMB->acpred_directions[i] = 0;
246                  }                  }
# Line 364  Line 259 
259    
260                          block[i * 64 + 0] = dc_dif;                          block[i * 64 + 0] = dc_dif;
261                          start_coeff = 1;                          start_coeff = 1;
262    
263                            DPRINTF(DPRINTF_COEFF,"block[0] %i", dc_dif);
264                  } else {                  } else {
265                          start_coeff = 0;                          start_coeff = 0;
266                  }                  }
# Line 371  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 451  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 488  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 538  Line 461 
461                             int quant,                             int quant,
462                             int intra_dc_threshold)                             int intra_dc_threshold)
463  {  {
464            uint32_t bound;
465          uint32_t x, y;          uint32_t x, y;
466    
467            bound = 0;
468    
469          for (y = 0; y < dec->mb_height; y++) {          for (y = 0; y < dec->mb_height; y++) {
470                  for (x = 0; x < dec->mb_width; x++) {                  for (x = 0; x < dec->mb_width; x++) {
471                          MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb;
   
472                          uint32_t mcbpc;                          uint32_t mcbpc;
473                          uint32_t cbpc;                          uint32_t cbpc;
474                          uint32_t acpred_flag;                          uint32_t acpred_flag;
475                          uint32_t cbpy;                          uint32_t cbpy;
476                          uint32_t cbp;                          uint32_t cbp;
477    
478                            while (BitstreamShowBits(bs, 9) == 1)
479                                    BitstreamSkip(bs, 9);
480    
481                            if (check_resync_marker(bs, 0))
482                            {
483                                    bound = read_video_packet_header(bs, 0, &quant);
484                                    x = bound % dec->mb_width;
485                                    y = bound / dec->mb_width;
486                            }
487                            mb = &dec->mbs[y * dec->mb_width + x];
488    
489                            DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));
490    
491                          mcbpc = get_mcbpc_intra(bs);                          mcbpc = get_mcbpc_intra(bs);
492                          mb->mode = mcbpc & 7;                          mb->mode = mcbpc & 7;
493                          cbpc = (mcbpc >> 4);                          cbpc = (mcbpc >> 4);
494    
495                          acpred_flag = BitstreamGetBit(bs);                          acpred_flag = BitstreamGetBit(bs);
496    
                         if (mb->mode == MODE_STUFFING) {  
                                 DEBUG("-- STUFFING ?");  
                                 continue;  
                         }  
   
497                          cbpy = get_cbpy(bs, 1);                          cbpy = get_cbpy(bs, 1);
498                          cbp = (cbpy << 2) | cbpc;                          cbp = (cbpy << 2) | cbpc;
499    
# Line 574  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 581  Line 517 
517                          }                          }
518    
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);                                                          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 595  Line 534 
534                                    int y,                                    int y,
535                                    int k,                                    int k,
536                                    VECTOR * mv,                                    VECTOR * mv,
537                                    int fcode)                                    int fcode,
538                                      const int bound)
539  {  {
540    
541          int scale_fac = 1 << (fcode - 1);          int scale_fac = 1 << (fcode - 1);
# Line 603  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_pmvdata(dec->mbs, x, y, dec->mb_width, k, pmv, psad);          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          mv_x += pmv_x;          DPRINTF(DPRINTF_MV,"mv_diff (%i,%i) pred (%i,%i)", mv_x, mv_y, pmv.x, pmv.y);
555          mv_y += pmv_y;  
556            mv_x += pmv.x;
557            mv_y += pmv.y;
558    
559          if (mv_x < low) {          if (mv_x < low) {
560                  mv_x += range;                  mv_x += range;
# Line 649  Line 584 
584  {  {
585    
586          uint32_t x, y;          uint32_t x, y;
587            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;
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 = &dec->mbs[y * dec->mb_width + x];                          MACROBLOCK *mb;
601    
602                            // skip stuffing
603                            while (BitstreamShowBits(bs, 10) == 1)
604                                    BitstreamSkip(bs, 10);
605    
606                            if (check_resync_marker(bs, fcode - 1))
607                            {
608                                    bound = read_video_packet_header(bs, fcode - 1, &quant);
609                                    x = bound % dec->mb_width;
610                                    y = bound / dec->mb_width;
611                            }
612                            mb = &dec->mbs[y * dec->mb_width + x];
613    
614                            DPRINTF(DPRINTF_MB, "macroblock (%i,%i) %08x", x, y, BitstreamShowBits(bs, 32));
615    
616                          //if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs)))         // not_coded                          //if (!(dec->mb_skip[y*dec->mb_width + x]=BitstreamGetBit(bs)))         // not_coded
617                          if (!(BitstreamGetBit(bs)))     // not_coded                          if (!(BitstreamGetBit(bs)))     // not_coded
# Line 669  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);
630    
631                                    DPRINTF(DPRINTF_MB, "mode %i", mb->mode);
632                                    DPRINTF(DPRINTF_MB, "cbpc %i", cbpc);
633                                  acpred_flag = 0;                                  acpred_flag = 0;
634    
635                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);                                  intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);
# Line 680  Line 638 
638                                          acpred_flag = BitstreamGetBit(bs);                                          acpred_flag = BitstreamGetBit(bs);
639                                  }                                  }
640    
                                 if (mb->mode == MODE_STUFFING) {  
                                         DEBUG("-- STUFFING ?");  
                                         continue;  
                                 }  
   
641                                  cbpy = get_cbpy(bs, intra);                                  cbpy = get_cbpy(bs, intra);
642                                    DPRINTF(DPRINTF_MB, "cbpy %i", cbpy);
643    
644                                  cbp = (cbpy << 2) | cbpc;                                  cbp = (cbpy << 2) | cbpc;
645    
646                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {                                  if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) {
647                                          quant += dquant_table[BitstreamGetBits(bs, 2)];                                          int dquant = dquant_table[BitstreamGetBits(bs, 2)];
648                                            DPRINTF(DPRINTF_MB, "dquant %i", dquant);
649                                            quant += dquant;
650                                          if (quant > 31) {                                          if (quant > 31) {
651                                                  quant = 31;                                                  quant = 31;
652                                          } else if (mb->quant < 1) {                                          } else if (quant < 1) {
653                                                  quant = 1;                                                  quant = 1;
654                                          }                                          }
655                                            DPRINTF(DPRINTF_MB, "quant %i", quant);
656                                  }                                  }
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 718  Line 678 
678                                  if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {                                  if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
679                                          if (dec->interlacing && mb->field_pred) {                                          if (dec->interlacing && mb->field_pred) {
680                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],
681                                                                                    fcode);                                                                                    fcode, bound);
682                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[1],
683                                                                                    fcode);                                                                                    fcode, bound);
684                                          } else {                                          } else {
685                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],                                                  get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0],
686                                                                                    fcode);                                                                                    fcode, bound);
687                                                  mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =                                                  mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =
688                                                          mb->mvs[0].x;                                                          mb->mvs[0].x;
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);                                          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);                                          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);                                          get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
697                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode);                                          get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
698                                  } else                  // MODE_INTRA, MODE_INTRA_Q                                  } else                  // MODE_INTRA, MODE_INTRA_Q
699                                  {                                  {
700                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =                                          mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x =
# Line 742  Line 702 
702                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =                                          mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y =
703                                                  0;                                                  0;
704                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,                                          decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
705                                                                          intra_dc_threshold);                                                                          intra_dc_threshold, bound);
706                                          continue;                                          continue;
707                                  }                                  }
708    
# Line 750  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 792  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 873  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 913  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 966  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 981  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 1075  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 1166  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 1216  Line 1204 
1204    
1205                                          if (quant > 31) {                                          if (quant > 31) {
1206                                                  quant = 31;                                                  quant = 31;
1207                                          } else if (mb->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 1301  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 1316  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 1344  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 1359  Line 1343 
1343          case P_VOP:          case P_VOP:
1344                  decoder_pframe(dec, &bs, rounding, quant, fcode_forward,                  decoder_pframe(dec, &bs, rounding, quant, fcode_forward,
1345                                             intra_dc_threshold);                                             intra_dc_threshold);
1346                  printf("P_VOP  Time=%ld\n",dec->time);  #ifdef BFRAMES_DEC
1347                  DEBUG1("P_VOP  Time=", dec->time);                  DEBUG1("P_VOP  Time=", dec->time);
1348    #endif
1349                  break;                  break;
1350    
1351          case I_VOP:          case I_VOP:
1352                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);                  decoder_iframe(dec, &bs, quant, intra_dc_threshold);
1353                  printf("I_VOP  Time=%ld\n",dec->time);  #ifdef BFRAMES_DEC
1354                  DEBUG1("I_VOP  Time=", dec->time);                  DEBUG1("I_VOP  Time=", dec->time);
1355    #endif
1356                  break;                  break;
1357    
1358          case B_VOP:          case B_VOP:
1359  #ifdef BFRAMES_DEC  #ifdef BFRAMES_DEC
1360                  if (dec->time_pp > dec->time_bp) {                  if (dec->time_pp > dec->time_bp) {
                         printf("I_VOP  Time=%ld\n",dec->time);  
1361                          DEBUG1("B_VOP  Time=", dec->time);                          DEBUG1("B_VOP  Time=", dec->time);
1362                          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);                          decoder_bframe(dec, &bs, quant, fcode_forward, fcode_backward);
1363                  } else {                  } else {
1364                          DEBUG("broken B-frame!");                          DEBUG("broken B-frame!");
1365                  }                  }
1366  #else  #else
                 printf("Che minchia ne so\n");  
1367                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
1368  #endif  #endif
1369                  break;                  break;
# Line 1387  Line 1371 
1371          case N_VOP:                             // vop not coded          case N_VOP:                             // vop not coded
1372                  // when low_delay==0, N_VOP's should interpolate between the past and future frames                  // when low_delay==0, N_VOP's should interpolate between the past and future frames
1373                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);                  image_copy(&dec->cur, &dec->refn[0], dec->edged_width, dec->height);
                 printf("N_VOP vop not coded\n");  
1374                  break;                  break;
1375    
1376          default:          default:
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 1423  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.25  
changed lines
  Added in v.1.37.2.1

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