Subversion Repositories shark

/*
 * Copyright (c) 1992 The Regents of the University of California.
 * 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 THE UNIVERSITY OF CALIFORNIA 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 UNIVERSITY OF CALIFORNIA 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 UNIVERSITY OF CALIFORNIA 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.
 */


#include "video.h"
#include "dither.h"
#include "mpeg.h"               /* for ImageDesc */

#define NUM_COLORS 256          /* number of entries in colormap */
                                /* for gray-scale dithering */

/* Range values for lum, cr, cb. */
extern int LUM_RANGE;
extern int CR_RANGE;
extern int CB_RANGE;

/* Array that remaps color numbers to actual pixel values used by X server. */

extern unsigned char pixel[256];

/* Arrays holding quantized value ranged for lum, cr, and cb. */

extern int *lum_values;
extern int *cr_values;
extern int *cb_values;


/* ----------------------------- MNI Header -----------------------------------
@NAME       : InitColormap
@INPUT      : (none)
@OUTPUT     : *NumColors - number of entries in the newly-created colormap
              *Map - an array of colourmap entries; each one contains a
                     red, green, and blue byte-values (0 .. 255).  
                     *Map[i] gives the colour to display a pixel value i.
@RETURNS    : (none)
@DESCRIPTION: Creates a colour map used for most dithering methods
              (everything except full-colour, gray, and monochrome).
              The colour map itself is pretty self-explanatory -- a
              pixel with value i is to be displayed using the red, green
              and blue values in *Map[i] after InitColormap() is done.
@METHOD     :
@GLOBALS    :
@CALLS      :
@CREATED    : 95/3/4, Greg Ward: based on InitColorDisplay(), from gdith.c
                                 in the original Berkeley player
@MODIFIED   :
---------------------------------------------------------------------------- */
#ifndef DISABLE_DITHER
static void
InitColormap (int *NumColors, ColormapEntry **Map)
{
   int i, lum_num, cr_num, cb_num;

   *NumColors =  LUM_RANGE*CB_RANGE*CR_RANGE;
   *Map = (ColormapEntry *) malloc (*NumColors * sizeof (ColormapEntry));

   for (i = 0; i < *NumColors; i++)
   {
      lum_num = (i / (CR_RANGE*CB_RANGE))%LUM_RANGE;
      cr_num = (i / CB_RANGE)%CR_RANGE;
      cb_num = i % CB_RANGE;
     
/*      ConvertColor(lum_values[lum_num], cr_values[cr_num], cb_values[cb_num],
                   &(*Map)[i].red, &(*Map)[i].green, &(*Map)[i].blue);
*/
      pixel[i] = i;
   }
}
#endif


/* ----------------------------- MNI Header -----------------------------------
@NAME       : InitGrayColormap
@INPUT      : (none)
@OUTPUT     : *NumColors - number of entries in the newly-created colormap
              *Map - an array of colourmap entries
@RETURNS    : (none)
@DESCRIPTION: Creates a colour map used for gray-scale dithering, i.e.
              the red/green/blue values are the same for any given
              pixel value.
@METHOD     :
@GLOBALS    :
@CALLS      :
@CREATED    : 95/3/4, Greg Ward: based on InitGrayDisplay(), from gdith.c
                                 in the original Berkeley player
@MODIFIED   :
---------------------------------------------------------------------------- */
#ifndef DISABLE_DITHER
static void
InitGrayColormap (int *NumColors, ColormapEntry **Map)
{
   int  i;
 
//cprintf("InitGColor...\n");
   *NumColors =  NUM_COLORS;
   *Map = (ColormapEntry *) malloc (*NumColors * sizeof (ColormapEntry));

   for (i = 0; i < *NumColors; i++)
   {
      (*Map)[i].red = (*Map)[i].green = (*Map)[i].blue = i;
      pixel[i] = i;
   }
}
#endif


/* ----------------------------- MNI Header -----------------------------------
@NAME       : InitDither
@INPUT      : Image - pointer to the image descriptor for the current MPEG
@OUTPUT     : Image->ColormapSize, Image->Colormap - the colour map for
              this movie, as initialized by either InitColormap or
              InitGrayColormap (unless the current dithering scheme
              is full colour, in which case there is no colour map)
@RETURNS    : (none)
@DESCRIPTION: Does all initialization particular to the type of dithering
              being used.  Basically, sets up the internal data structures
              needed by the dithering code, and then sets up a colour map
              needed to display the pixels output by the ditherers.
@METHOD     :
@GLOBALS    :
@CALLS      : InitColor     (for most dithering methods)
              InitColormap  (for most dithering methods)
              InitGrayColormap (for gray-scale dithering)
              Init(..)Dither  (.. = the current dithering method)
@CREATED    : 95/3/3, Greg Ward: taken mostly from main() in the original
                                 Berkeley player
@MODIFIED   :
---------------------------------------------------------------------------- */
void
InitDither (ImageDesc *Image)
{
   LUM_RANGE = 8;
   CR_RANGE = 4;
   CB_RANGE = 4;

//cprintf("InitDitherin'...\n");
   switch (Image->vid_stream->ditherType)
   {
#ifndef DISABLE_DITHER
      case HYBRID_DITHER:
         InitColor ();
         InitHybridDither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         break;

      case HYBRID2_DITHER:
         InitColor ();
         InitHybridErrorDither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         break;

      case FS4_DITHER:
         InitColor ();
         InitFS4Dither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         break;

      case FS2_DITHER:
         InitColor ();
         InitFS2Dither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         break;

      case FS2FAST_DITHER:
         InitColor ();
         InitFS2FastDither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         break;

      case Twox2_DITHER:
         InitColor ();
         Init2x2Dither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         PostInit2x2Dither ();
         break;

      case GRAY_DITHER:
//cprintf("InitGray\n");
         InitGrayColormap (&Image->ColormapSize, &Image->Colormap);
         break;
#endif
      case FULL_COLOR_DITHER:
         wpixel[0] = 0xff;
         wpixel[1] = 0xff00;
         wpixel[2] = 0xff0000;
         Image->vid_stream->matched_depth=24;
         InitColorDither(1);
         Image->ColormapSize = -1;
         Image->Colormap = NULL;
         break;

#ifndef DISABLE_DITHER

      // MG      
      case HALF_COLOR_DITHER:
         wpixel[2] = 0x001f;
         wpixel[1] = 0x07e0;
         wpixel[0] = 0xf800;
         Image->vid_stream->matched_depth=16;
         InitColorDither(1);
         Image->ColormapSize = -1;
         Image->Colormap = NULL;
         break;

     case NO_DITHER:
         break;

      case ORDERED_DITHER:
         InitColor ();
         InitOrderedDither ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         break;

      case MONO_DITHER:
      case MONO_THRESHOLD:
         break;

      case ORDERED2_DITHER:
         InitColor ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         InitOrdered2Dither ();
         break;

      case MBORDERED_DITHER:
         InitColor ();
         InitColormap (&Image->ColormapSize, &Image->Colormap);
         InitMBOrderedDither ();
         break;

      case PPM_DITHER:
         Image->ColormapSize = -1;
         Image->Colormap = NULL;
         wpixel[0] = 0xff;
         wpixel[1] = 0xff00;
         wpixel[2] = 0xff0000;
         Image->vid_stream->matched_depth=24;
         InitColorDither(TRUE);
         break;
#endif
   }
}  


void ExecuteDisplay(VidStream *vid_stream, XInfo *xinfo)
{
  char dummy;
  int depth, result;
  static int rate_deal = -1;
  static int one_frame_time;
  register int usec, sec;
 

  vid_stream->totNumFrames++;

  if (partialFlag) {
    if ((endFrame != -1) && (vid_stream->totNumFrames > endFrame)) {

      vid_stream->film_has_ended=TRUE;
      if (loopFlag) {
              clear_data_stream(vid_stream);
      } else DestroyVidStream(vid_stream, xinfo);
      return;
    }
    if (vid_stream->totNumFrames < startFrame) {
      return;
    }
  }
}