tmndec.c

H.263的压缩算法

/************************************************************************
 *
 *  tmndec.c, main(), initialization, options for tmndecode (H.263 decoder)
 *  Copyright (C) 1995, 1996  Telenor R&D, Norway
 *
 *  Contacts:
 *  Robert Danielsen                  <[e-mail]>
 *
 *  Telenor Research and Development  http://www.nta.no/brukere/DVC/
 *  P.O.Box 83                        tel.:   [phone]
 *  N-2007 Kjeller, Norway            fax.:   [phone]
 *
 *  Copyright (C) 1997  University of BC, Canada
 *  Modified by: Michael Gallant <[e-mail]>
 *               Guy Cote <[e-mail]>
 *               Berna Erol <[e-mail]>
 *
 *  Contacts:
 *  Michael Gallant                   <[e-mail]>
 *
 *  UBC Image Processing Laboratory   http://www.ee.ubc.ca/image
 *  2356 Main Mall                    tel.: [phone]
 *  Vancouver BC Canada V6T1Z4        fax.: [phone]
 *
 ************************************************************************/

/* Disclaimer of Warranty
 * 
 * These software programs are available to the user without any license fee
 * or royalty on an "as is" basis. The University of British Columbia
 * disclaims any and all warranties, whether express, implied, or
 * statuary, including any implied warranties or merchantability or of
 * fitness for a particular purpose.  In no event shall the
 * copyright-holder be liable for any incidental, punitive, or
 * consequential damages of any kind whatsoever arising from the use of
 * these programs.
 * 
 * This disclaimer of warranty extends to the user of these programs and
 * user's customers, employees, agents, transferees, successors, and
 * assigns.
 * 
 * The University of British Columbia does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any
 * third-party patents.
 * 
 * Commercial implementations of H.263, including shareware, are subject to
 * royalty fees to patent holders.  Many of these patents are general
 * enough such that they are unavoidable regardless of implementation
 * design.
 * 
 */



/* modified to support annex O true B frames, [e-mail]
 * 
 * based on mpeg2decode, (C) 1994, MPEG Software Simulation Group and
 * mpeg2play, (C) 1994 Stefan Eckart <[e-mail]>
 * 
 */


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <string.h>
#define GLOBAL
#include "config.h"
#include "tmndec.h"
#include "global.h"

#ifdef USE_TIME
#ifndef WIN32
#include <sys/time.h>
#else
#include <windows.h>
#endif
#endif
#ifdef WIN32
#include <io.h>
#endif



#ifdef WINDOWS
int initDisplay (int pels, int lines);
int closeDisplay ();
#endif

/* private prototypes */
static void initdecoder _ANSI_ARGS_ ((void));
static void options _ANSI_ARGS_ ((int *argcp, char **argvp[]));
static int getval _ANSI_ARGS_ ((char *argv[]));
static void flushdisplaybuffer _ANSI_ARGS_ ((int framenum));
/* private data */
static int loopflag;

int main (int argc, char *argv[])
{
  int first, framenum;
  int gob;
#ifdef USE_TIME
  int runtime;
#ifndef WIN32
  struct timeval tstart, tstop;
#else
  unsigned int startTime, stopTime;
#endif
#endif

#ifdef USE_TIME
  /* default is read frame rate from bitstream */
  framerate = 99;
#endif

  options (&argc, &argv);

  if (trace)
  {
    if ((trace_file = fopen (trace_file_name, "wt")) == NULL)
    {
      printf ("Unable to open trace file");
      exit (-1);
    }
  }
  if (save_frames)
  {
    if ((recon_file_ptr = fopen (recon_file_name, "wb")) == NULL)
    {
      printf ("Unable to open reconstruction file");
      exit (-1);
    }
  }
  /* pointer to name of output files */
#if (defined DISPLAY || defined WINDOWS)
  if (outtype == T_X11 || outtype == T_WIN)
    outputname = "";
  else
#endif
    outputname = argv[argc - 1];

  ld = &base;

  /* open H263plus input file(s) */
  if ((base.infile = open (argv[1], O_RDONLY | O_BINARY)) < 0)
  {
    sprintf (errortext, "Input file %s not found\n", argv[1]);
    error (errortext);
  }
  first = 1;

  do
  {
    if (base.infile != 0)
      lseek (base.infile, 0l, 0);
    initbits ();
    initoptions ();
    framenum = 0;
    temp_ref = 0;
    prev_non_disposable_temp_ref = next_non_disposable_temp_ref = 0;

    while ((gob = getheader ()))
    {
      if (first)
      {  
        base_source_format = source_format;
        initdecoder ();
#ifdef USE_TIME
#ifndef WIN32
        gettimeofday (&tstart, (struct timezone *) NULL);
        if (framerate > 0)
          gettimeofday (&tftarget, (struct timezone *) NULL);
#else
        startTime = timeGetTime ();
        if (framerate > 0)
          targetTime = timeGetTime ();
#endif
#endif
        first = 0;
      }
      getpicture (&framenum, gob);

      framenum++;
    }

    flushdisplaybuffer (framenum);

  } while (loopflag);

  close (base.infile);

#ifdef USE_TIME
#ifndef WIN32
  gettimeofday (&tstop, (struct timezone *) NULL);
  runtime = 100 * (tstop.tv_sec - tstart.tv_sec)
    + (tstop.tv_usec - tstart.tv_usec) / 10000;
#else
  stopTime = timeGetTime ();
  runtime = (stopTime - startTime) / 10;
#endif
  if (!quiet && runtime != 0)
    printf ("%d.%02d seconds, %d frames, %d.%02d fps\n",
            runtime / 100, runtime % 100,
            framenum, ((10000 * framenum + runtime / 2) / runtime) / 100,
            ((10000 * framenum + runtime / 2) / runtime) % 100);
#endif

#ifdef DISPLAY
  if (outtype == T_X11)
    exit_display ();
#endif
#ifdef WINDOWS
  if (outtype == T_WIN)
    closeDisplay ();
#endif

  return 0;
}

static void initdecoder ()
{
  int i, cc, size;
  FILE *cleared;

  /* clip table */
  if (!(clp = (unsigned char *) malloc (1024)))
    error ("malloc failed\n");

  clp += 384;

  for (i = -384; i < 640; i++)
    clp[i] = (i < 0) ? 0 : ((i > 255) ? 255 : i);

  /* MPEG-1 = TMN parameters */
  matrix_coefficients = 5;

  blk_cnt = 6;

  for (i=0; i<MAX_LAYERS; i++)
    enhancement_layer_init[i] = OFF;

  for (cc = 0; cc < 3; cc++)
  {
    if (cc == 0)
      size = coded_picture_width * coded_picture_height;
    else
      size = chrom_width * chrom_height;

    /* Used for bidirectional and direct prediction mode for true B
     * pictures, one for forward and one for backward. */
    if (!(next_I_P_frame[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");

    if (!(prev_I_P_frame[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");
    
    if (!(current_frame[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");

    if (!(bframe[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");
    
    prev_frame[cc] = current_frame[cc];
    
    if (!(tmp_f[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");

    if (!(tmp_b[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");

    /* Stores frame in display buffer */
    if (!(buffered_frame[cc] = (unsigned char *) malloc (size)))
      error ("malloc failed\n");
  }

  for (cc = 0; cc < 3; cc++)
  {
    if (cc == 0)
    {
      size = (coded_picture_width + 64) * (coded_picture_height + 64);

      /* Stores framed version of previous inter-picture, luminance. */
      if (!(edgeframeorig[cc] = (unsigned char *) malloc (size)))
        error ("malloc failed\n");
      edgeframe[cc] = edgeframeorig[cc] + (coded_picture_width + 64) * 32 + 32;

      /* Required for true B frames backward, bidir, and direct
       * prediction. Stores future inter-picture, luminance */
      if (!(nextedgeframeorig[cc] = (unsigned char *) malloc (size)))
        error ("malloc failed\n");
      nextedgeframe[cc] = nextedgeframeorig[cc] + (coded_picture_width + 64) * 32 + 32;
    } 
    else
    {
      size = (chrom_width + 32) * (chrom_height + 32);

      /* Stores framed version of previous inter-picture, chrominance. */
      if (!(edgeframeorig[cc] = (unsigned char *) malloc (size)))
        error ("malloc failed\n");
      edgeframe[cc] = edgeframeorig[cc] + (chrom_width + 32) * 16 + 16;

      /* Required for true B frames backward, bidir, and direct
       * prediction. Stores future inter-picture, chrominance. */
      if (!(nextedgeframeorig[cc] = (unsigned char *) malloc (size)))
        error ("malloc failed\n");
      nextedgeframe[cc] = nextedgeframeorig[cc] + (chrom_width + 32) * 16 + 16;
    }
  }

  if (expand)
  {
    for (cc = 0; cc < 3; cc++)
    {
      if (cc == 0)
        size = coded_picture_width * coded_picture_height * 4;
      else
        size = chrom_width * chrom_height * 4;

      if (!(exnewframe[cc] = (unsigned char *) malloc (size)))
        error ("malloc failed\n");
    }
  }
  /* Clear output file for concatenated storing */
  if (outtype == T_YUV_CONC)
  {
    if ((cleared = fopen (outputname, "wb")) == NULL)
      error ("couldn't clear outputfile\n");
    else
      fclose (cleared);
  }
  /* IDCT */
  if (refidct)
    init_idctref ();