Subversion Repositories shark

/*
 * Copyright (c) 1994 by Gregory P. Ward.
 * All rights reserved.
 *
 * This file is part of the MNI front end of the Berkeley MPEG decoder.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
 * UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER
 * IS ON AN "AS IS" BASIS, AND THE AUTHOR HAS NO OBLIGATION TO PROVIDE
 * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  
 */
/*
 * Portions of this software Copyright (c) 1995 Brown University.
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement
 * is hereby granted, provided that the above copyright notice and the
 * following two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN
 * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
 * BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
 * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 */

/* ----------------------------- MNI Header -----------------------------------
@NAME       : wrapper.c
@INPUT      :
@OUTPUT     :
@RETURNS    :
@DESCRIPTION: Functions and variables used in the interface between
              user applications and the Berkely MPEG decoder.  This
              file essentially comprises the MNI front end to the
              Berkeley decoder; applications should NOT have access to any of
              these.  The functions in this file are the only ones to
              which users of the MPEG library have access; all other
              functions in the library are private.
@METHOD     :
@GLOBALS    :
@CALLS      :
@CREATED    :
@MODIFIED   :
---------------------------------------------------------------------------- */

#include <stdio.h>
#include <errno.h>
#include "video.h"
#include "proto.h"
#include "util.h"
#include "dither.h"
#include "mpeg.h"

#define BUF_LENGTH 100000


/*
 * Global variables shared between this file and the core MPEG decoder
 * (but nowhere else!)  - these are the only globals!
 */
int quietFlag=1, loopFlag=1,qualityFlag=0, requireKeypressFlag=0;
int framerate=0,gammaCorrectFlag=0, chromaCorrectFlag=0, noDisplayFlag=0;
int partialFlag=0,startFrame=-1, endFrame=-1;
double gammaCorrect = 1.0, chromaCorrect=1.0;

static int numMovies=0;

/* Prototypes for functions local to this file: */

void GetMPEGInfo (ImageDesc *Info);

int dprintf (char *format, ...) {}


/* ----------------------------- MNI Header -----------------------------------
@NAME       : OpenMPEG
@INPUT      : MPEGfile - pointer to a stream opened for reading, positioned
                         at the beginning of an MPEG stream
              ImgInfo  - pointer to an ImageDesc structure which will have
                         information such as frame height, width, depth
                         and size (total bytes per frame) put in it.
@OUTPUT     :
@RETURNS    :
@DESCRIPTION: Creates and initializes the variables needed to start
              reading/decoding an MPEG stream.  

              This function is part of the MNI front end to the Berkeley
              MPEG decoder, adapted from the original Berkeley code.
@METHOD     :
@GLOBALS    : LUM_RANGE, CR_RANGE, CB_RANGE
              lum_values, cr_values, cb_values
@CALLS      : GetMPEGInfo()
              init_tables()
              InitDither()
@CREATED    : 94/6/16, Greg Ward (adapted from main() in the original
              Berkeley source)
@MODIFIED   :
---------------------------------------------------------------------------- */
Boolean OpenMPEG (FILE *MPEGfile, ImageDesc *ImgInfo)
{
   VidStream *vid_stream;
   /*
    * First reinitialize these globals in case we're opening a second
    * (or more) file - thanks to Loren Holding (art054@cs.brown.edu)
    * for the patch
    */

    /* unneeded - done in NewVidStream or ResetVidStream */

   /*
    * Create the video stream and read the first chunk to get movie
    * stats -- width and height in particular.
    */

   if (ImgInfo->vid_stream==NULL) {    
     ImgInfo->vid_stream = vid_stream =NewVidStream((unsigned int) BUF_LENGTH);
   } else {
     vid_stream=ImgInfo->vid_stream;
     clear_data_stream(vid_stream);
     ResetVidStream(vid_stream);
   }
   vid_stream->input = MPEGfile;
   vid_stream->filename = "mniwrapper";
   vid_stream->matched_depth=24;
   vid_stream->ditherType=FULL_COLOR_DITHER; /* default */

   numMovies++;

   if (numMovies==1) {
       /* Allocate/initialize tables used for dithering (?) */
       lum_values = (int *) malloc(LUM_RANGE*sizeof(int));
       cr_values = (int *) malloc(CR_RANGE*sizeof(int));
       cb_values = (int *) malloc(CB_RANGE*sizeof(int));

      init_tables();            /* initialize decoding stuff */
      InitCrop();

#if 0
      InitDither(ImgInfo);      /* initializes dithering structures and */
                                /* colormap (i.e. this is where we do */
                                /* all dither-specific stuff) */
#endif
   }

   if (mpegVidRsrc(0, ImgInfo->vid_stream, 1, NULL )==NULL) {
      return FALSE;
   } else {
     GetMPEGInfo(ImgInfo);
     return TRUE;
   }
}     /* OpenMPEG () */


/* ----------------------------- MNI Header -----------------------------------
@NAME       : CloseMPEG
@INPUT      : (none)
@OUTPUT     : (none)
@RETURNS    : (void)
@DESCRIPTION: Frees up some of the memory allocated by OpenMPEG() (some
              is not freed because the Berkeley code doesn't take into
              account the fact that somebody might want to, say, free
              up the memory it allocates... someday, I'll probably have
              to hack into it to fix that, but not today thanks.)
@METHOD     :
@GLOBALS    : lum_values
              cr_values
              cb_values
@CALLS      : DestroyVidStream
@CREATED    : 94/6/27, Greg Ward
@MODIFIED   :
---------------------------------------------------------------------------- */
void CloseMPEG (ImageDesc *ImgInfo)
{
   DestroyVidStream(ImgInfo->vid_stream, NULL);
   free (lum_values);
   free (cr_values);
   free (cb_values);
}



/* ----------------------------- MNI Header -----------------------------------
@NAME       : RewindMPEG
@INPUT      : MPEGfile - the input stream where the MPEG's coming from
              Image    - image descriptor (just passed to OpenMPEG ())
@OUTPUT     : (none)
@RETURNS    : (void)
@DESCRIPTION: Resets things so that the caller can start reading the MPEG
              stream from the start again.   Note that the caller does NOT
              need to call OpenMPEG() again -- after a call to RewindMPEG(),
              the next call to GetMPEGFrame() will return the first frame
              of the MPEG.
@METHOD     :
@GLOBALS    :
@CALLS      :
@CREATED    : 94/7/20, Greg Ward
@MODIFIED   :
@COMMENTS   :
---------------------------------------------------------------------------- */
void RewindMPEG (FILE *MPEGfile, ImageDesc *Image)
{
   rewind (MPEGfile);

   OpenMPEG (MPEGfile, Image);
}



/* ----------------------------- MNI Header -----------------------------------
@NAME       : GetMPEGInfo
@INPUT      : vid_stream - a video stream that is open and has had at
                           least one call to mpegVidRsrc() performed on it
              Info       - a pointer to an ImageDesc struct in the caller's
                           space (i.e., the argument to OpenMPEG()) where
                           the image information will be copied
@OUTPUT     :
@RETURNS    : (void)
@DESCRIPTION: From the video stream, determines the width, height, pixel
              size and depth (in bits) and total image size (in bytes)
              for an MPEG stream.  Sets the fields in the structure
              pointed to by the Info pointer.
@METHOD     :
@GLOBALS    :
@CALLS      :
@CREATED    : 94/6/17, Greg Ward: based on code from ExecuteDisplay() in the
              original Berkeley source
@MODIFIED   :
---------------------------------------------------------------------------- */
void GetMPEGInfo (ImageDesc *Info)
{
#ifndef DISABLE_DITHER
   switch (Info->vid_stream->ditherType)
   {
      case Twox2_DITHER:
      {
         Info->Height = Info->vid_stream->mb_height * 32;
         Info->Width = Info->vid_stream->mb_width * 32;
         Info->Depth = 8;
         Info->PixelSize = 8;
         Info->BitmapPad = 8;
         break;
      }
      case FULL_COLOR_DITHER:
      {
#endif
         Info->Height = Info->vid_stream->mb_height * 16;
         Info->Width = Info->vid_stream->mb_width * 16;
         Info->Depth = 24;
         Info->PixelSize = 32;
         Info->BitmapPad = 32;
#ifndef DISABLE_DITHER
         break;
      }
     
      // MG
      case HALF_COLOR_DITHER:
         Info->Height = Info->vid_stream->mb_height * 16;
         Info->Width = Info->vid_stream->mb_width * 16;
         Info->Depth = 16;
         Info->PixelSize = 16;
         Info->BitmapPad = 16;
         break;
         
      case MONO_DITHER:
      case MONO_THRESHOLD:
      {
         Info->Height = Info->vid_stream->mb_height * 16;
         Info->Width = Info->vid_stream->mb_width * 16;
         Info->Depth = 1;
         Info->PixelSize = 1;
         Info->BitmapPad = 8;
         break;
      }
      default:                  /* including GRAY_DITHER and ORDERED_DITHER */
      {
         Info->Height = Info->vid_stream->mb_height * 16;
         Info->Width = Info->vid_stream->mb_width * 16;
         Info->Depth = 8;
         Info->PixelSize = 8;
         Info->BitmapPad = 8;
         break;
      }
   }     /* switch on ditherType */
#endif

   Info->Size = (Info->Height*Info->Width*Info->PixelSize) / 8;
   Info->PictureRate = Info->vid_stream->picture_rate;
   Info->BitRate = Info->vid_stream->bit_rate;

}     /* GetMPEGInfo () */



/* ----------------------------- MNI Header -----------------------------------
@NAME       : SetMPEGOption
@INPUT      : Option - which option to set
              Value  - what to set it to
@OUTPUT     :
@RETURNS    :
@DESCRIPTION: Set an MPEG option.  The options are all assigned intelligent
              defaults when they are created (as global variables), so
              calling SetMPEGOption is optional (as you might expect
              from the name).  Whether SetMPEGOption() is called before
              or after OpenMPEG() is important, but it depends on which
              option you're setting.  In particular, the dithering type
              and luminance/chromaticity ranges must be set before
              OpenMPEG(); but (unless your code is more clever than it
              needs to be), the colourmap indeces probably won't be set
              until after OpenMPEG().  RTFM for explanations of what the
              individual options do.

              The currently available options are:
                 MPEG_DITHER
                 MPEG_LUM_RANGE
                 MPEG_CR_RANGE
                 MPEG_CB_RANGE
                 MPEG_CMAP_INDEX

@METHOD     :
@GLOBALS    : Depending on the value of Option, sets one of the MPEG
              decoders global variables:
                 LUM_RANGE
                 CR_RANGE
                 CB_RANGE
@CALLS      :
@CREATED    : 94/6/17, Greg Ward.
@MODIFIED   : 95/3/18, GW: added MPEG_CMAP_INDEX option.
---------------------------------------------------------------------------- */
void SetMPEGOption (ImageDesc *Info, MPEGOptionEnum Option, int Value)
{

   switch (Option)
   {
      case MPEG_DITHER:    
#ifndef DISABLE_DITHER
         Info->vid_stream->ditherType = (DitherEnum) Value;
     
         InitDither(Info);      /* initializes dithering structures and */
                                /* colormap (i.e. this is where we do */
                                /* all dither-specific stuff) */
#endif
         break;
      case MPEG_LUM_RANGE: LUM_RANGE = Value; break;
      case MPEG_CR_RANGE:  CR_RANGE = Value; break;
      case MPEG_CB_RANGE:  CB_RANGE = Value; break;
#ifndef DISABLE_DITHER
      case MPEG_CMAP_INDEX:
      {
         int            i;
         unsigned char *cmap_index;

         cmap_index = (unsigned char *) Value;
         for (i = 0; i < Info->ColormapSize; i++)
         {
            pixel[i] = cmap_index[i];
         }
         break;
      }
#endif
           
   }
}     /* SetMPEGOption () */



/* ----------------------------- MNI Header -----------------------------------
@NAME       : GetMPEGFrame
@INPUT      :
@OUTPUT     : Frame - the image data, converted to RGB space, is
              copied to the area pointed to by Frame.  There must be
              enough room for the entire image; the ImageDesc
              structure returned by OpenMPEG() will tell you just how
              much memory this is.  The format of the data depends on
              the dithering type; for full colour dithering, there are
              four bytes per pixel: red, green, blue, and unused.
              (Perfect for passing to lrectwrite() or XPutImage().)
@RETURNS    : TRUE if there are still frames left to decode
              FALSE if we have just decoded the last frame
@DESCRIPTION: Part of the MNI front end to the Berkeley MPEG decoder.  
              Essentially reads, decodes, and converts to RGB space the
              next frame in the MPEG stream opened with OpenMPEG().
@METHOD     :
@GLOBALS    :
@CALLS      : mpegVidRsrc ()
@CREATED    : 94/6/16, Greg Ward
@MODIFIED   :
---------------------------------------------------------------------------- */
Boolean GetMPEGFrame (ImageDesc *image, char *Frame)
{
   Boolean   MovieDone = FALSE;
   int frames;
   char *CurrentImage;

   dprintf ("GetMPEGFrame: starting or continuing movie\n");

   frames=image->vid_stream->totNumFrames;
   while (!MovieDone && (frames==image->vid_stream->totNumFrames))
   {
      mpegVidRsrc(0,image->vid_stream,0, NULL);
      MovieDone = image->vid_stream->film_has_ended;
   }

   CurrentImage=(char *) image->vid_stream->current->display;

   dprintf ("\nGetMPEGFrame: just received a finished frame: "
            "copying from %08X to %08X\n", CurrentImage, Frame);

   memcpy (Frame, CurrentImage, image->Size);
   return (!MovieDone);

}     /* GetMPEGFrame () */

#ifndef DISABLE_DITHER
/* ----------------------------- MNI Header -----------------------------------
@NAME       : DoDitherImage
@INPUT      : l, Cr, Cb - pointers to the luminance, Cr, and Cb planes
              disp - ?
              h, w - height and width of image (?)
@OUTPUT     :
@RETURNS    :
@DESCRIPTION: Called when image needs to be dithered. Selects correct
              dither routine based on info in ditherType.
@METHOD     :
@GLOBALS    : ditherType
@CALLS      : One of the following, depending on the value of ditherType:
                 HybridDitherImage       (hybrid.c)
                 HybridErrorDitherImage  (hybriderr.c)
                 FS2FastDitherImage      (fs2fast.c)
                 FS2DitherImage          (fs2.c)
                 FS4DitherImage          (fs4.c)
                 Twox2DitherImage        (2x2.c)
                 ColorDitherImage        (16bit.c)
                 GrayDitherImage         (gray.c)
                 OrderedDitherImage      (ordered.c)
                 MonoDitherImage         (mono.c)
                 MonoThresholdImage      (mono.c)
                 Ordered2DitherImage     (ordered2.c)
                 MBOrderedDitherImage    (mb_ordered.c)
@CREATED    : (taken from the original Berkeley code)
@MODIFIED   :
---------------------------------------------------------------------------- */
void
DoDitherImage(vid_stream)
VidStream *vid_stream;
{
 unsigned char *l=vid_stream->current->luminance,
               *Cr=vid_stream->current->Cr,
               *Cb=vid_stream->current->Cb,
               *disp=vid_stream->current->display;
 int h=(int) vid_stream->mb_height * 16;
 int w=(int) vid_stream->mb_width * 16;
 int ditherType=vid_stream->ditherType;
 int matched_depth=vid_stream->matched_depth;

  switch(ditherType) {
  case HYBRID_DITHER:
    HybridDitherImage(l, Cr, Cb, disp, h, w);
    break;

  case HYBRID2_DITHER:
    HybridErrorDitherImage(l, Cr, Cb, disp, h, w);
    break;

  case FS2FAST_DITHER:
    FS2FastDitherImage(l, Cr, Cb, disp, h, w);
    break;

  case FS2_DITHER:
    FS2DitherImage(l, Cr, Cb, disp, h, w);
    break;

  case FS4_DITHER:
    FS4DitherImage(l, Cr, Cb, disp, h, w);
    break;

  case Twox2_DITHER:
    Twox2DitherImage(l, Cr, Cb, disp, h, w);
    break;

  case FULL_COLOR_DITHER:
    Color32DitherImage(l, Cr, Cb, disp, h, w);
    break;

  // MG
  case HALF_COLOR_DITHER:
    Color16DitherImage(l, Cr, Cb, disp, h, w);
    break;

  case GRAY_DITHER:
    GrayDitherImage(l, Cr, Cb, disp, h, w);
    break;

  case NO_DITHER:
    break;

  case PPM_DITHER:
    Color32DitherImage(l, Cr, Cb, disp, h, w);
    break;

  case ORDERED_DITHER:
    OrderedDitherImage(l, Cr, Cb, disp, h, w);
    break;

  case MONO_DITHER:
    MonoDitherImage(l, Cr, Cb, disp, h, w);
    break;

  case MONO_THRESHOLD:
    MonoThresholdImage(l, Cr, Cb, disp, h, w);
    break;

  case ORDERED2_DITHER:
    Ordered2DitherImage(l, Cr, Cb, disp, h, w);
    break;

  case MBORDERED_DITHER:
    MBOrderedDitherImage(l, Cr, Cb, disp, h, w, vid_stream->ditherFlags);
    break;
  }
}   /* DoDitherImage () */
#else
void
DoDitherImage(vid_stream)
VidStream *vid_stream;
{
 unsigned char *l=vid_stream->current->luminance,
               *Cr=vid_stream->current->Cr,
               *Cb=vid_stream->current->Cb,
               *disp=vid_stream->current->display;
 int h=(int) vid_stream->mb_height * 16;
 int w=(int) vid_stream->mb_width * 16;

 Color32DitherImage(l,Cr,Cb,disp,h,w);
}
#endif