WebSVN - shark - Rev 2 - /shark/branches/pj/ports/mpeg/animmpeg.c

/*
* 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.
*/

/*
*
* Original C version by Greg Ward <greg@pet.mni.mcgill.ca>,
* reentrant C++ version by Loring Holden <lsh@cs.brown.edu>
*
* All functions that have an "MNI Header" are rewritten from the original
* MNI C function
*
*/

#include "ANIMmpeg.H"

// These are MPEG decoder globals but shouldn't be, really;
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;

int ANIMmpeg::numMovies=0;

//
//Constructor
//
//
ANIMmpeg::ANIMmpeg(const char * const inFileName)
: vid_stream(NULL)
{
newMovie(inFileName);
init();
}

//
//Copy constructor
//
ANIMmpeg::ANIMmpeg(const ANIMmpeg& rhs)
: ANIMbase(rhs),
vid_stream(NULL)
{
newMovie(rhs.fileName);
init();
}

//
// Takes in read-only string that is the the name of the new movie,
// if NULL, then just deallocates memory
//
void
ANIMmpeg::newMovie(const char * const infile)
{
int stringLength = infile==NULL ? 0 : strlen(infile);
#ifndef NOTHREADS
Boolean tmpThreaded=MultiThreaded;

// In case we're decoding in another thread...
if (MultiThreaded && mp_man->processor(threadNumber)->running) {
mp_man->processor(threadNumber)->wait_for_done();
}
#endif

// Clean up after old movie
if (fileName) {
delete [] fileName;
}
if (filePtr) fclose(filePtr);
if (vid_stream) {
DestroyVidStream(vid_stream, NULL);
vid_stream=NULL;
}
if (frameBuffer) {
Buffer(FALSE);
}
#ifndef NOTHREADS
MultiThread(FALSE);
#endif

if (stringLength) {
fileName = new char[stringLength];
strcpy(fileName, infile);
filePtr = fopen(fileName,"r");
#ifndef NOTHREADS
MultiThread(tmpThreaded);
#endif
}

/* Initialize movie information */
Height=Width=BlockHeight=BlockWidth=Depth=PixelSize=Size=BitmapPad=0;
PictureRate=BitRate=0;
}

//
//Initialization used by all constructors
//
//
void
ANIMmpeg::init() {
thread_routine=RunDecode;
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();
InitDither(); /* initializes dithering structures and */
/* colormap (i.e. this is where we do */
/* all dither-specific stuff) */
}
}

/* ----------------------------- 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 : 95/10, Loring Holden (made reentrant and ported to C++)
---------------------------------------------------------------------------- */
Boolean ANIMmpeg::open()
{
Boolean okMovie;
/*
* Create the video stream and read the first chunk to get movie
* stats -- width and height in particular.
*/
#ifndef NOTHREADS
if (MultiThreaded && (mp_man->processor(threadNumber)->running)) {
#ifdef sol
fprintf(stderr,"%s: Decode running when open called\n",
fileName);
#else
fprintf(stderr,"%s: Decode running when open called\n",fileName);
#endif
fflush(stderr);
exit(2);
}
#endif

if (vid_stream==NULL) {
vid_stream =NewVidStream((unsigned int) BUF_LENGTH);
/* Initialize start time */
vid_stream->realTimeStart = ReadSysClock();
} else {
// clear_data_stream(vid_stream) already called in mpegVidRsrc
ResetVidStream(vid_stream);
allBuffered=FALSE;
// call buffer destructor
if (frameBuffer) Buffer(FALSE);
}

vid_stream->input = filePtr;
vid_stream->filename = (char *) fileName;
vid_stream->ditherType=FULL_COLOR_DITHER; /* default */
frames=0;
InitStream();

okMovie=(mpegVidRsrc(0, vid_stream, 1, NULL)!=NULL);
if (okMovie) {
GetInfo();
moreFrames=TRUE;
} else moreFrames=FALSE;

#ifndef NOTHREADS
if (!allBuffered && MultiThreaded && okMovie) {
// Should check that nothing is running, but assume rewind has been
// called
mp_man->processor(threadNumber)->start_execute(RunDecode,this,NULL);
}
#endif
return okMovie;

} /* OpenMPEG () */

// Destructor
/* ----------------------------- 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 : 95/10, Loring Holden (made reentrant and ported to C++)
---------------------------------------------------------------------------- */
ANIMmpeg::~ANIMmpeg()
{
newMovie(NULL); //Like we are playing a new movie, but no new
//allocation
// These stay around for the life of the program
// 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 : 95/10, Loring Holden (made reentrant and ported to C++)
@COMMENTS :
---------------------------------------------------------------------------- */
void ANIMmpeg::rewind()
{
#ifndef NOTHREADS
if (MultiThreaded && (mp_man->processor(threadNumber)->running)) {
#ifdef sol
fprintf(stderr,"%s: Decode running when rewind called\n",
fileName);
#else
fprintf(stderr,"%s: Decode running when rewind called\n",fileName);
#endif
fflush(stderr);
exit(2);
}
#endif

if (!allBuffered) {
::rewind(filePtr);
open();
} else {
// do buffering stuff here
}
}

/* ----------------------------- 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 global variable Info
(part of the interface between wrapper.c and globals.c),
and then copies that struct to the user application's
space via the Info pointer.
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : 94/6/17, Greg Ward: based on code from ExecuteDisplay() in the
original Berkeley source
@MODIFIED : 95/10, Loring Holden (made reentrant and ported to C++)
---------------------------------------------------------------------------- */
void ANIMmpeg::GetInfo()
{
#ifndef DISABLE_DITHER
switch (vid_stream->ditherType)
{
case Twox2_DITHER:
{
Height = vid_stream->v_size;
Width = vid_stream->h_size;
BlockHeight=vid_stream->mb_height;
BlockWidth=vid_stream->mb_width;
Depth = 8;
PixelSize = 8;
BitmapPad = 8;
break;
}
case FULL_COLOR_DITHER:
{
#endif
Height = vid_stream->v_size;
Width = vid_stream->h_size;
BlockHeight=vid_stream->mb_height;
BlockWidth=vid_stream->mb_width;
Depth = 24;
PixelSize = 32;
BitmapPad = 32;
#ifndef DISABLE_DITHER
break;
}
case MONO_DITHER:
case MONO_THRESHOLD:
{
Height = vid_stream->v_size;
Width = vid_stream->h_size;
Depth = 1;
PixelSize = 1;
BitmapPad = 8;
break;
}
default: /* including GRAY_DITHER and ORDERED_DITHER */
{
Height = vid_stream->v_size;
Width = vid_stream->h_size;
Depth = 8;
PixelSize = 8;
BitmapPad = 8;
break;
}
} /* switch on ditherType */
#endif

Size = (BlockHeight*16*BlockWidth*16*PixelSize) / 8;
PictureRate = vid_stream->picture_rate;
BitRate = vid_stream->bit_rate;

} /* GetMPEGInfo () */

/* ----------------------------- 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 : 95/10, Loring Holden (made reentrant and ported to C++)
---------------------------------------------------------------------------- */
void *ANIMmpeg::RunDecode(void *ptr, void *)
{
ANIMmpeg *movie=(ANIMmpeg *) ptr;
Boolean MovieDone = FALSE;
int frames;

#if 0
dprintf ("GetMPEGFrame: starting or continuing movie\n");
#endif

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

return NULL;

} /* GetMPEGFrame () */

Boolean ANIMmpeg::GetFrame(char **Frame, Boolean *newFrame)
{
void *CurrentImage;
int looped;

if ((vid_stream==NULL) && !open()) {
*newFrame=FALSE;
return FALSE;
}

if (!allBuffered) {
#ifndef NOTHREADS
if (MultiThreaded) {
mp_man->processor(threadNumber)->wait_for_done();
} else {
ANIMmpeg::RunDecode(this,NULL);
}
#else
ANIMmpeg::RunDecode(this,NULL);
#endif
moreFrames=!vid_stream->film_has_ended;
CurrentImage=(void *) vid_stream->current->display;
if (buffering) {
// copy CurrentImage to the right place in the array
if (!frameBuffer->addToBuffer(CurrentImage)) {
// ran out of memory - can't buffer
Buffer(FALSE);
fflush(stdout);
fprintf(stderr,"%s: no more room to buffer\n",fileName);
fflush(stderr);
} else if (!moreFrames) {
allBuffered=TRUE;
moreFrames=TRUE;
}
}
#if 0
dprintf ("\nGetMPEGFrame: just received a finished frame: ",
"copying from %08X to %08X\n", CurrentImage, Frame);
#endif
memcpy ((void *) *Frame, CurrentImage, Size);

if (allBuffered) {
int totFrames=vid_stream->totNumFrames;

DestroyVidStream(vid_stream,NULL);
// This is a hack in order to use PrintTimeInfo
// - Create a NewVidStream just to use realTimeStart
// - all the image information is deallocated, so we do save space
vid_stream =NewVidStream((unsigned int) BUF_LENGTH);
vid_stream->totNumFrames=totFrames;
/* Initialize start time */
vid_stream->realTimeStart = ReadSysClock();
}

} else {
// set moreFrames
moreFrames=TRUE;
// set CurrentImage to point to the right place in the array
*Frame=(char *) frameBuffer->nextBufferItem(&looped);
if (looped) {
PrintTimeInfo(vid_stream);
vid_stream->realTimeStart = ReadSysClock();
}
}

#ifndef NOTHREADS
if (!allBuffered && MultiThreaded && moreFrames) {
mp_man->processor(threadNumber)->start_execute(RunDecode,this,NULL);
}
#endif

frames++;
*newFrame=TRUE;
return moreFrames;
}

#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(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;

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(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

/* ----------------------------- 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;

*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 : ColormapSize, 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
ANIMmpeg::InitDither(unsigned long red,
unsigned long green,
unsigned long blue)
{
LUM_RANGE = 8;
CR_RANGE = 4;
CB_RANGE = 4;
#ifndef DISABLE_DITHER
switch (vid_stream->ditherType)
{
case HYBRID_DITHER:
InitColor ();
InitHybridDither ();
InitColormap (&ColormapSize, &Colormap);
break;

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

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

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

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

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

case GRAY_DITHER:
InitGrayColormap (&ColormapSize, &Colormap);
break;
case FULL_COLOR_DITHER:
#endif
wpixel[0]=red;
wpixel[1]=green;
wpixel[2]=blue;
InitColorDither(1);
#ifndef DISABLE_DITHER
break;

case NO_DITHER:
break;

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

case MONO_DITHER:
case MONO_THRESHOLD:
break;

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

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

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

//
//
//
void
ANIMmpeg::InitStream()
{
if ((vid_stream->ditherType==FULL_COLOR_DITHER) ||
(vid_stream->ditherType==PPM_DITHER)) {
vid_stream->matched_depth=24;
// InitColorDither(1);
}
}

Subversion Repositories shark

(root)/shark/branches/pj/ports/mpeg/animmpeg.c @ 1026 - Rev 2