tmndec.c

H.263的压缩算法

  else
    init_idct ();

#ifdef DISPLAY
  if (outtype == T_X11)
  {
    init_display ("");
  }
#endif
#ifdef WINDOWS
  if (outtype == T_WIN)
  {
    initDisplay (coded_picture_width, coded_picture_height);
  }
#endif

  prev_mv_outside_frame = prev_sac = prev_adv_pred = prev_aic = prev_df = 0;
  prev_slice_struct = prev_rps = prev_isd = prev_aivlc = prev_mq = 0;
  prev_4mv = prev_long_vectors = prev_obmc = 0;
}

void error (char *text)
{
  fprintf (stderr, text);
  exit (1);
}

/* trace output */
void printbits (int code, int bits, int len)
{
  int i;
  for (i = 0; i < len; i++)
    fprintf (trace_file, "%d", (code >> (bits - 1 - i)) & 1);
}

/* option processing */
static void options (int *argcp, char **argvp[])
{
  trace = 0;
  save_frames = 0;

  while (*argcp > 1 && (*argvp)[1][0] == '-')
  {
    while ((*argvp)[1][1])
    {
      switch (toupper ((*argvp)[1][1]))
      {
#ifdef USE_TIME
        case 'F':
          framerate = getval (*argvp);
          break;
#endif
        case 'V':
          verbose = getval (*argvp);
          break;
        case 'O':
          outtype = getval (*argvp);
          break;
        case 'R':
          refidct = 1;
          break;
        case 'L':
          loopflag = 1;
          break;
        case 'X':
          expand = 1;
          break;
        case 'T':
          trace = 1;
          strcpy (trace_file_name, "trace.dec");
          break;
        case 'S':
          save_frames = 1;
          (*argvp)++;
          (*argcp)--;
          strcpy (recon_file_name, (*argvp)[1]);
          (*argvp)[1] += strlen (recon_file_name);
          if (recon_file_name[0] == '-')
          {
            printf ("Reconstruction file name is expected after -S option");
            exit (-1);
          }
          break;

        case 'Q':
          quiet = 1;
          break;
        case 'P':
          post_filter = 1;
          break;
        case 'C':
          concealment = 1;
          break;

          
        default:
          fprintf (stderr, "undefined option -%c ignored\n", (*argvp)[1][1]);
      }

      (*argvp)[1]++;
    }

    (*argvp)++;
    (*argcp)--;
  }


  if (outtype != T_X11 && outtype != T_WIN)
  {
    loopflag = 0;               /* No looping for output to file */
#ifdef USE_TIME
    framerate = 0;              /* No delay necessary when output to file */
#endif
  }
#ifdef DISPLAY
  if (outtype == T_X11)
  {
    (*argcp)++;                 /* fake outfile parameter */
  }
#endif
#ifdef WINDOWS
  if (outtype == T_WIN)
  {
    (*argcp)++;                 /* fake outfile parameter */
  }
#endif

  if (*argcp != 3 && *argcp != 4)
  {
    printf ("\n%s\n", version);
    printf ("Usage:   tmndecode {options} bitstream {outputfilename%%d}\n\
Options: -vn  verbose output (n: level)\n\
         -on  output format \n\
              n=0 : YUV\n\
              n=1 : SIF\n\
              n=2 : TGA\n\
              n=3 : PPM\n");
#ifdef DISPLAY
    printf ("\
              n=4 : X11 Display\n");
#endif
    printf ("\
              n=5 : YUV concatenated\n");
#ifdef WINDOWS
    printf ("\
              n=6 : Windows 95/NT Display\n");
#endif
    printf ("\
              You have to choose one output format!\n\
         -q   disable warnings to stderr\n\
         -r   use double precision reference IDCT\n\
         -t   enable low level tracing\n\
         -s <filename>  output reconstructed frame to filename (YUV concatenated)\n\
         -p   enable tmn-8 post filter\n\
         -c   enable error concealment\n");
#ifdef DISPLAY
    printf ("\
         -x   interpolate pictures to double size before display\n");
#endif
#ifdef USE_TIME
    printf ("\
         -fn  frame rate\n\
              n=0  : as fast as possible\n\
              n=99 : read frame rate from bitstream (default)\n");
#endif
#ifdef DISPLAY
    printf ("\
         -l   loop sequence\n");
#endif
    exit (0);
  }
}

static int getval (char *argv[])
{
  int val;

  if (sscanf (argv[1] + 2, "%d", &val) != 1)
    return 0;

  while (isdigit (argv[1][2]))
    argv[1]++;

  return val;
}



#ifdef USE_TIME
#ifndef WINDOWS

/* Unix version */
void doframerate (int pb)
{
  struct timeval tfdiff;
  const float REF_FRAME_RATE = 29.97;

  /* Compute desired frame rate */
  if (framerate <= 0)
    return;

  if (framerate != 99)
  {
    tftarget.tv_usec += 1000000 / framerate;
  } else
  {
    if (pb)
    {
      tftarget.tv_usec += 1000000 / (REF_FRAME_RATE / trb);
    } else
    {
      tftarget.tv_usec += 1000000 / (REF_FRAME_RATE / (trd - trb));
    }
  }

  /* this is where we should be */
  if (tftarget.tv_usec >= 1000000)
  {
    tftarget.tv_usec -= 1000000;
    tftarget.tv_sec++;
  }
  /* this is where we are */
  gettimeofday (&tfdiff, (struct timezone *) NULL);

  tfdiff.tv_usec = tftarget.tv_usec - tfdiff.tv_usec;
  tfdiff.tv_sec = tftarget.tv_sec - tfdiff.tv_sec;
  if (tfdiff.tv_usec < 0)
  {
    tfdiff.tv_usec += 1000000;
    tfdiff.tv_sec--;
  }
  /* See if we are already lagging behind */
  if (tfdiff.tv_sec < 0 || (tfdiff.tv_sec == 0 && tfdiff.tv_usec <= 0))
    return;

  /* Spin for awhile */
  select (0, NULL, NULL, NULL, &tfdiff);
}

#else

/* Win32 version */
void doframerate (int pb)
{
  DWORD currentTime;
  int diffTime;
  const float REF_FRAME_RATE = (float) 29.97;

  /* Compute desired frame rate */
  if (framerate <= 0)
    return;

  if (framerate != 99)
  {
    targetTime += 1000 / framerate;
  } else
  {
    if (pb)
    {
      targetTime += (int) (1000 / (REF_FRAME_RATE / trb));
    } else
    {
      targetTime += (int) (1000 / (REF_FRAME_RATE / (trd - trb)));
    }
  }

  /* this is where we are */
  currentTime = timeGetTime ();


  diffTime = targetTime - currentTime;

  /* See if we are already lagging behind */
  if (diffTime <= 0)
    return;

  /* Spin for awhile */
  Sleep (diffTime);
  /* this is not a very accurate timer */
}

#endif

#endif

/**********************************************************************
 *
 *	Name:		      flushdisplaybuffer
 *	Description:  empties last frame from display buffer when sequence 
 *                fully decoded
 *	Input:	      frame number
 *	Returns:      
 *	Side effects: 
 *
 *  Date: 971102  Author: [e-mail]
 *
 ***********************************************************************/

void flushdisplaybuffer (int framenum)
{

  /* Ensure the dimensions are set properly for displaying the last picture in 
   * the display buffer */
  coded_picture_width = horizontal_size = lines[base_source_format];
  coded_picture_height = vertical_size = pels[base_source_format];

  mb_width = horizontal_size / 16;
  mb_height = vertical_size / 16;
  chrom_width = coded_picture_width >> 1;
  chrom_height = coded_picture_height >> 1;

  if (expand && outtype == T_X11)
  {
    /* display this image and keep frame already in storage where it is. */
    interpolate_image (buffered_frame[0], exnewframe[0],
                       coded_picture_width, coded_picture_height);
    interpolate_image (buffered_frame[1], exnewframe[1], chrom_width, chrom_height);
    interpolate_image (buffered_frame[2], exnewframe[2], chrom_width, chrom_height);

    storeframe (exnewframe, framenum);
    if (save_frames)
    {
      save_frame (exnewframe, framenum, recon_file_ptr);
    }
  } else
  {
    storeframe (buffered_frame, framenum);
    if (save_frames)
    {
      save_frame (buffered_frame, framenum, recon_file_ptr);
    }
  }
}