dpvsimpledecode.c File Reference

#include "quakedef.h"
#include "dpvsimpledecode.h"

Include dependency graph for dpvsimpledecode.c:

Go to the source code of this file.

Data Structures
struct	dpvsimpledecodestream_t
struct	hz_bitstream_read_t
struct	hz_bitstream_readblock_t
struct	hz_bitstream_readblocks_t

Macros
#define	BLOCKSIZE   8
#define	HZREADBLOCKSIZE   1048576
#define	HZREADERROR_EOF   1
#define	HZREADERROR_MALLOCFAILED   2
#define	HZREADERROR_OK   0

Functions
void	dpvsimpledecode_close (void *stream)
static int	dpvsimpledecode_convertpixels (dpvsimpledecodestream_t *s, void *imagedata, int imagebytesperrow)
static int	dpvsimpledecode_decompressimage (dpvsimpledecodestream_t *s)
int	dpvsimpledecode_error (void *stream, const char **errorstring)
double	dpvsimpledecode_getaspectratio (void *stream)
double	dpvsimpledecode_getframerate (void *stream)
unsigned int	dpvsimpledecode_getheight (void *stream)
unsigned int	dpvsimpledecode_getwidth (void *stream)
void *	dpvsimpledecode_open (clvideo_t *video, char *filename, const char **errorstring)
static int	dpvsimpledecode_setpixelformat (dpvsimpledecodestream_t *s, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel)
int	dpvsimpledecode_video (void *stream, void *imagedata, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel, int imagebytesperrow)
static int	hz_bitstream_read_bit (hz_bitstream_readblocks_t *blocks)
static unsigned int	hz_bitstream_read_bits (hz_bitstream_readblocks_t *blocks, int size)
static void	hz_bitstream_read_blocks_free (hz_bitstream_readblocks_t *blocks)
static unsigned int	hz_bitstream_read_blocks_getbyte (hz_bitstream_readblocks_t *blocks)
static hz_bitstream_readblocks_t *	hz_bitstream_read_blocks_new (void)
static int	hz_bitstream_read_blocks_read (hz_bitstream_readblocks_t *blocks, hz_bitstream_read_t *stream, unsigned int size)
static unsigned int	hz_bitstream_read_byte (hz_bitstream_readblocks_t *blocks)
static void	hz_bitstream_read_bytes (hz_bitstream_readblocks_t *blocks, void *outdata, unsigned int size)
static void	hz_bitstream_read_close (hz_bitstream_read_t *stream)
static void	hz_bitstream_read_flushbits (hz_bitstream_readblocks_t *blocks)
static unsigned int	hz_bitstream_read_int (hz_bitstream_readblocks_t *blocks)
static hz_bitstream_read_t *	hz_bitstream_read_open (char *filename)
static unsigned int	hz_bitstream_read_short (hz_bitstream_readblocks_t *blocks)

Macro Definition Documentation

BLOCKSIZE

#define BLOCKSIZE   8

Definition at line 228 of file dpvsimpledecode.c.

Referenced by dpvsimpledecode_decompressimage().

HZREADBLOCKSIZE

#define HZREADBLOCKSIZE   1048576

Definition at line 29 of file dpvsimpledecode.c.

Referenced by hz_bitstream_read_blocks_read().

HZREADERROR_EOF

#define HZREADERROR_EOF   1

Definition at line 25 of file dpvsimpledecode.c.

Referenced by hz_bitstream_read_blocks_read().

HZREADERROR_MALLOCFAILED

#define HZREADERROR_MALLOCFAILED   2

Definition at line 26 of file dpvsimpledecode.c.

Referenced by hz_bitstream_read_blocks_read().

HZREADERROR_OK

#define HZREADERROR_OK   0

Definition at line 24 of file dpvsimpledecode.c.

Referenced by hz_bitstream_read_blocks_read().

Function Documentation

dpvsimpledecode_close()

void dpvsimpledecode_close

(

void *

stream

)

Definition at line 447 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    if (s == NULL)
        return;
    if (s->videopixels)
        Z_Free(s->videopixels);
    if (s->sndchan != -1)
        S_StopChannel (s->sndchan, true, true);
    if (s->framedatablocks)
        hz_bitstream_read_blocks_free(s->framedatablocks);
    if (s->bitstream)
        hz_bitstream_read_close(s->bitstream);
    Z_Free(s);
}

References dpvsimpledecodestream_t::bitstream, dpvsimpledecodestream_t::framedatablocks, hz_bitstream_read_blocks_free(), hz_bitstream_read_close(), NULL, S_StopChannel(), dpvsimpledecodestream_t::sndchan, dpvsimpledecodestream_t::videopixels, and Z_Free.

Referenced by dpvsimpledecode_open().

dpvsimpledecode_convertpixels()

static int dpvsimpledecode_convertpixels ( dpvsimpledecodestream_t * s, void * imagedata, int imagebytesperrow )

static

Definition at line 545 of file dpvsimpledecode.c.

{
    unsigned int a, x, y, width, height;
    unsigned int Rloss, Rmask, Rshift, Gloss, Gmask, Gshift, Bloss, Bmask, Bshift;
    unsigned int *in;
 
    width = s->info_imagewidth;
    height = s->info_imageheight;
 
    Rloss = s->info_imageRloss;
    Rmask = s->info_imageRmask;
    Rshift = s->info_imageRshift;
    Gloss = s->info_imageGloss;
    Gmask = s->info_imageGmask;
    Gshift = s->info_imageGshift;
    Bloss = s->info_imageBloss;
    Bmask = s->info_imageBmask;
    Bshift = s->info_imageBshift;
 
    in = s->videopixels;
    if (s->info_imagebpp == 4)
    {
        unsigned int *outrow;
        for (y = 0;y < height;y++)
        {
            outrow = (unsigned int *)((unsigned char *)imagedata + y * imagebytesperrow);
            for (x = 0;x < width;x++)
            {
                a = *in++;
                outrow[x] = (((a >> Rloss) & Rmask) << Rshift) | (((a >> Gloss) & Gmask) << Gshift) | (((a >> Bloss) & Bmask) << Bshift);
            }
        }
    }
    else
    {
        unsigned short *outrow;
        for (y = 0;y < height;y++)
        {
            outrow = (unsigned short *)((unsigned char *)imagedata + y * imagebytesperrow);
            if (Rloss == 19 && Gloss == 10 && Bloss == 3 && Rshift == 11 && Gshift == 5 && Bshift == 0)
            {
                // optimized
                for (x = 0;x < width;x++)
                {
                    a = *in++;
                    outrow[x] = ((a >> 8) & 0xF800) | ((a >> 5) & 0x07E0) | ((a >> 3) & 0x001F);
                }
            }
            else
            {
                for (x = 0;x < width;x++)
                {
                    a = *in++;
                    outrow[x] = (((a >> Rloss) & Rmask) << Rshift) | (((a >> Gloss) & Gmask) << Gshift) | (((a >> Bloss) & Bmask) << Bshift);
                }
            }
        }
    }
    return s->error;
}

References a, dpvsimpledecodestream_t::error, height, dpvsimpledecodestream_t::info_imageBloss, dpvsimpledecodestream_t::info_imageBmask, dpvsimpledecodestream_t::info_imagebpp, dpvsimpledecodestream_t::info_imageBshift, dpvsimpledecodestream_t::info_imageGloss, dpvsimpledecodestream_t::info_imageGmask, dpvsimpledecodestream_t::info_imageGshift, dpvsimpledecodestream_t::info_imageheight, dpvsimpledecodestream_t::info_imageRloss, dpvsimpledecodestream_t::info_imageRmask, dpvsimpledecodestream_t::info_imageRshift, dpvsimpledecodestream_t::info_imagewidth, dpvsimpledecodestream_t::videopixels, width, x, and y.

Referenced by dpvsimpledecode_video().

dpvsimpledecode_decompressimage()

static int dpvsimpledecode_decompressimage ( dpvsimpledecodestream_t * s )

static

Definition at line 606 of file dpvsimpledecode.c.

{
    int i, a, b, colors, g, x1, y1, bw, bh, width, height, palettebits;
    unsigned int palette[256], *outrow, *out;
    g = BLOCKSIZE;
    width = s->info_imagewidth;
    height = s->info_imageheight;
    for (y1 = 0;y1 < height;y1 += g)
    {
        outrow = s->videopixels + y1 * width;
        bh = g;
        if (y1 + bh > height)
            bh = height - y1;
        for (x1 = 0;x1 < width;x1 += g)
        {
            out = outrow + x1;
            bw = g;
            if (x1 + bw > width)
                bw = width - x1;
            if (hz_bitstream_read_bit(s->framedatablocks))
            {
                // updated block
                palettebits = hz_bitstream_read_bits(s->framedatablocks, 3);
                colors = 1 << palettebits;
                for (i = 0;i < colors;i++)
                    palette[i] = hz_bitstream_read_bits(s->framedatablocks, 24);
                if (palettebits)
                {
                    for (b = 0;b < bh;b++, out += width)
                        for (a = 0;a < bw;a++)
                            out[a] = palette[hz_bitstream_read_bits(s->framedatablocks, palettebits)];
                }
                else
                {
                    for (b = 0;b < bh;b++, out += width)
                        for (a = 0;a < bw;a++)
                            out[a] = palette[0];
                }
            }
        }
    }
    return s->error;
}

References a, b, BLOCKSIZE, dpvsimpledecodestream_t::error, dpvsimpledecodestream_t::framedatablocks, g, height, hz_bitstream_read_bit(), hz_bitstream_read_bits(), i, dpvsimpledecodestream_t::info_imageheight, dpvsimpledecodestream_t::info_imagewidth, dpvsimpledecodestream_t::videopixels, width, and x1.

Referenced by dpvsimpledecode_video().

dpvsimpledecode_error()

int dpvsimpledecode_error	(	void *	stream,
		const char **	errorstring )

Definition at line 469 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    int e;
    e = s->error;
    s->error = 0;
    if (errorstring)
    {
        switch (e)
        {
            case DPVSIMPLEDECODEERROR_NONE:
                *errorstring = "no error";
                break;
            case DPVSIMPLEDECODEERROR_EOF:
                *errorstring = "end of file reached (this is not an error)";
                break;
            case DPVSIMPLEDECODEERROR_READERROR:
                *errorstring = "read error (corrupt or incomplete file)";
                break;
            case DPVSIMPLEDECODEERROR_SOUNDBUFFERTOOSMALL:
                *errorstring = "sound buffer is too small for decoding frame (please allocate it as large as dpvsimpledecode_getneededsoundbufferlength suggests)";
                break;
            case DPVSIMPLEDECODEERROR_INVALIDRMASK:
                *errorstring = "invalid red bits mask";
                break;
            case DPVSIMPLEDECODEERROR_INVALIDGMASK:
                *errorstring = "invalid green bits mask";
                break;
            case DPVSIMPLEDECODEERROR_INVALIDBMASK:
                *errorstring = "invalid blue bits mask";
                break;
            case DPVSIMPLEDECODEERROR_COLORMASKSOVERLAP:
                *errorstring = "color bit masks overlap";
                break;
            case DPVSIMPLEDECODEERROR_COLORMASKSEXCEEDBPP:
                *errorstring = "color masks too big for specified bytes per pixel";
                break;
            case DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP:
                *errorstring = "unsupported bytes per pixel (must be 2 for 16bit, or 4 for 32bit)";
                break;
            default:
                *errorstring = "unknown error";
                break;
        }
    }
    return e;
}

References DPVSIMPLEDECODEERROR_COLORMASKSEXCEEDBPP, DPVSIMPLEDECODEERROR_COLORMASKSOVERLAP, DPVSIMPLEDECODEERROR_EOF, DPVSIMPLEDECODEERROR_INVALIDBMASK, DPVSIMPLEDECODEERROR_INVALIDGMASK, DPVSIMPLEDECODEERROR_INVALIDRMASK, DPVSIMPLEDECODEERROR_NONE, DPVSIMPLEDECODEERROR_READERROR, DPVSIMPLEDECODEERROR_SOUNDBUFFERTOOSMALL, DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP, and dpvsimpledecodestream_t::error.

dpvsimpledecode_getaspectratio()

double dpvsimpledecode_getaspectratio

(

void *

stream

)

Definition at line 539 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    return s->info_aspectratio;
}

References dpvsimpledecodestream_t::info_aspectratio.

Referenced by dpvsimpledecode_open().

dpvsimpledecode_getframerate()

double dpvsimpledecode_getframerate

(

void *

stream

)

Definition at line 532 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    return s->info_framerate;
}

References dpvsimpledecodestream_t::info_framerate.

Referenced by dpvsimpledecode_open().

dpvsimpledecode_getheight()

unsigned int dpvsimpledecode_getheight

(

void *

stream

)

Definition at line 525 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    return s->info_imageheight;
}

References dpvsimpledecodestream_t::info_imageheight.

Referenced by dpvsimpledecode_open().

dpvsimpledecode_getwidth()

unsigned int dpvsimpledecode_getwidth

(

void *

stream

)

Definition at line 518 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    return s->info_imagewidth;
}

References dpvsimpledecodestream_t::info_imagewidth.

Referenced by dpvsimpledecode_open().

dpvsimpledecode_open()

void * dpvsimpledecode_open	(	clvideo_t *	video,
		char *	filename,
		const char **	errorstring )

Definition at line 356 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s;
    char t[8], *wavename;
    if (errorstring != NULL)
        *errorstring = NULL;
    s = (dpvsimpledecodestream_t *)Z_Malloc(sizeof(dpvsimpledecodestream_t));
    if (s != NULL)
    {
        s->bitstream = hz_bitstream_read_open(filename);
        if (s->bitstream != NULL)
        {
            // check file identification
            s->framedatablocks = hz_bitstream_read_blocks_new();
            if (s->framedatablocks != NULL)
            {
                hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 8);
                hz_bitstream_read_bytes(s->framedatablocks, t, 8);
                if (!memcmp(t, "DPVideo", 8))
                {
                    // check version number
                    hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 2);
                    if (hz_bitstream_read_short(s->framedatablocks) == 1)
                    {
                        hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 12);
                        s->info_imagewidth = hz_bitstream_read_short(s->framedatablocks);
                        s->info_imageheight = hz_bitstream_read_short(s->framedatablocks);
                        s->info_framerate = (double) hz_bitstream_read_int(s->framedatablocks) * (1.0 / 65536.0);
                        s->info_aspectratio = (double)s->info_imagewidth / (double)s->info_imageheight;
 
                        if (s->info_framerate > 0.0)
                        {
                            s->videopixels = (unsigned int *)Z_Malloc(s->info_imagewidth * s->info_imageheight * sizeof(*s->videopixels));
                            if (s->videopixels != NULL)
                            {
                                size_t namelen;
 
                                namelen = strlen(filename) + 10;
                                wavename = (char *)Z_Malloc(namelen);
                                if (wavename)
                                {
                                    sfx_t* sfx;
 
                                    FS_StripExtension(filename, wavename, namelen);
                                    dp_strlcat(wavename, ".wav", namelen);
                                    sfx = S_PrecacheSound (wavename, false, false);
                                    if (sfx != NULL)
                                        s->sndchan = S_StartSound (-1, 0, sfx, vec3_origin, 1.0f, 0);
                                    else
                                        s->sndchan = -1;
                                    Z_Free(wavename);
                                }
                                // all is well...
                                // set the module functions
                                s->videoframenum = -10000;
                                video->close = dpvsimpledecode_close;
                                video->getwidth = dpvsimpledecode_getwidth;
                                video->getheight = dpvsimpledecode_getheight;
                                video->getframerate = dpvsimpledecode_getframerate;
                                video->decodeframe = dpvsimpledecode_video;
                                video->getaspectratio = dpvsimpledecode_getaspectratio;
 
                                return s;
                            }
                            else if (errorstring != NULL)
                                *errorstring = "unable to allocate video image buffer";
                        }
                        else if (errorstring != NULL)
                            *errorstring = "error in video info chunk";
                    }
                    else if (errorstring != NULL)
                        *errorstring = "read error";
                }
                else if (errorstring != NULL)
                    *errorstring = "not a dpvideo file";
                hz_bitstream_read_blocks_free(s->framedatablocks);
            }
            else if (errorstring != NULL)
                *errorstring = "unable to allocate memory for reading buffer";
            hz_bitstream_read_close(s->bitstream);
        }
        else if (errorstring != NULL)
            *errorstring = "unable to open file";
        Z_Free(s);
    }
    else if (errorstring != NULL)
        *errorstring = "unable to allocate memory for stream info structure";
    return NULL;
}

References dpvsimpledecodestream_t::bitstream, clvideo_t::close, clvideo_t::decodeframe, dp_strlcat, dpvsimpledecode_close(), dpvsimpledecode_getaspectratio(), dpvsimpledecode_getframerate(), dpvsimpledecode_getheight(), dpvsimpledecode_getwidth(), dpvsimpledecode_video(), dpvsimpledecodestream_t::framedatablocks, FS_StripExtension(), clvideo_t::getaspectratio, clvideo_t::getframerate, clvideo_t::getheight, clvideo_t::getwidth, hz_bitstream_read_blocks_free(), hz_bitstream_read_blocks_new(), hz_bitstream_read_blocks_read(), hz_bitstream_read_bytes(), hz_bitstream_read_close(), hz_bitstream_read_int(), hz_bitstream_read_open(), hz_bitstream_read_short(), dpvsimpledecodestream_t::info_aspectratio, dpvsimpledecodestream_t::info_framerate, dpvsimpledecodestream_t::info_imageheight, dpvsimpledecodestream_t::info_imagewidth, NULL, S_PrecacheSound(), S_StartSound(), dpvsimpledecodestream_t::sndchan, strlen(), vec3_origin, dpvsimpledecodestream_t::videoframenum, dpvsimpledecodestream_t::videopixels, Z_Free, and Z_Malloc.

Referenced by OpenStream().

dpvsimpledecode_setpixelformat()

static int dpvsimpledecode_setpixelformat ( dpvsimpledecodestream_t * s, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel )

static

Definition at line 265 of file dpvsimpledecode.c.

{
    int Rshift, Rbits, Gshift, Gbits, Bshift, Bbits;
    if (!Rmask)
    {
        s->error = DPVSIMPLEDECODEERROR_INVALIDRMASK;
        return s->error;
    }
    if (!Gmask)
    {
        s->error = DPVSIMPLEDECODEERROR_INVALIDGMASK;
        return s->error;
    }
    if (!Bmask)
    {
        s->error = DPVSIMPLEDECODEERROR_INVALIDBMASK;
        return s->error;
    }
    if (Rmask & Gmask || Rmask & Bmask || Gmask & Bmask)
    {
        s->error = DPVSIMPLEDECODEERROR_COLORMASKSOVERLAP;
        return s->error;
    }
    switch (bytesperpixel)
    {
    case 2:
        if ((Rmask | Gmask | Bmask) > 65536)
        {
            s->error = DPVSIMPLEDECODEERROR_COLORMASKSEXCEEDBPP;
            return s->error;
        }
        break;
    case 4:
        break;
    default:
        s->error = DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP;
        return s->error;
    }
    for (Rshift = 0;!(Rmask & 1);Rshift++, Rmask >>= 1);
    for (Gshift = 0;!(Gmask & 1);Gshift++, Gmask >>= 1);
    for (Bshift = 0;!(Bmask & 1);Bshift++, Bmask >>= 1);
    if (((Rmask + 1) & Rmask) != 0)
    {
        s->error = DPVSIMPLEDECODEERROR_INVALIDRMASK;
        return s->error;
    }
    if (((Gmask + 1) & Gmask) != 0)
    {
        s->error = DPVSIMPLEDECODEERROR_INVALIDGMASK;
        return s->error;
    }
    if (((Bmask + 1) & Bmask) != 0)
    {
        s->error = DPVSIMPLEDECODEERROR_INVALIDBMASK;
        return s->error;
    }
    for (Rbits = 0;Rmask & 1;Rbits++, Rmask >>= 1);
    for (Gbits = 0;Gmask & 1;Gbits++, Gmask >>= 1);
    for (Bbits = 0;Bmask & 1;Bbits++, Bmask >>= 1);
    if (Rbits > 8)
    {
        Rshift += (Rbits - 8);
        Rbits = 8;
    }
    if (Gbits > 8)
    {
        Gshift += (Gbits - 8);
        Gbits = 8;
    }
    if (Bbits > 8)
    {
        Bshift += (Bbits - 8);
        Bbits = 8;
    }
    s->info_imagebpp = bytesperpixel;
    s->info_imageRloss = 16 + (8 - Rbits);
    s->info_imageGloss =  8 + (8 - Gbits);
    s->info_imageBloss =  0 + (8 - Bbits);
    s->info_imageRmask = (1 << Rbits) - 1;
    s->info_imageGmask = (1 << Gbits) - 1;
    s->info_imageBmask = (1 << Bbits) - 1;
    s->info_imageRshift = Rshift;
    s->info_imageGshift = Gshift;
    s->info_imageBshift = Bshift;
    s->info_imagesize = s->info_imagewidth * s->info_imageheight * s->info_imagebpp;
    return s->error;
}

References DPVSIMPLEDECODEERROR_COLORMASKSEXCEEDBPP, DPVSIMPLEDECODEERROR_COLORMASKSOVERLAP, DPVSIMPLEDECODEERROR_INVALIDBMASK, DPVSIMPLEDECODEERROR_INVALIDGMASK, DPVSIMPLEDECODEERROR_INVALIDRMASK, DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP, dpvsimpledecodestream_t::error, dpvsimpledecodestream_t::info_imageBloss, dpvsimpledecodestream_t::info_imageBmask, dpvsimpledecodestream_t::info_imagebpp, dpvsimpledecodestream_t::info_imageBshift, dpvsimpledecodestream_t::info_imageGloss, dpvsimpledecodestream_t::info_imageGmask, dpvsimpledecodestream_t::info_imageGshift, dpvsimpledecodestream_t::info_imageheight, dpvsimpledecodestream_t::info_imageRloss, dpvsimpledecodestream_t::info_imageRmask, dpvsimpledecodestream_t::info_imageRshift, dpvsimpledecodestream_t::info_imagesize, and dpvsimpledecodestream_t::info_imagewidth.

Referenced by dpvsimpledecode_video().

dpvsimpledecode_video()

int dpvsimpledecode_video	(	void *	stream,
		void *	imagedata,
		unsigned int	Rmask,
		unsigned int	Gmask,
		unsigned int	Bmask,
		unsigned int	bytesperpixel,
		int	imagebytesperrow )

Definition at line 651 of file dpvsimpledecode.c.

{
    dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
    unsigned int framedatasize;
    char t[4];
    s->error = DPVSIMPLEDECODEERROR_NONE;
    if (dpvsimpledecode_setpixelformat(s, Rmask, Gmask, Bmask, bytesperpixel))
        return s->error;
 
    hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 8);
    hz_bitstream_read_bytes(s->framedatablocks, t, 4);
    if (memcmp(t, "VID0", 4))
    {
        if (t[0] == 0)
            return (s->error = DPVSIMPLEDECODEERROR_EOF);
        else
            return (s->error = DPVSIMPLEDECODEERROR_READERROR);
    }
    framedatasize = hz_bitstream_read_int(s->framedatablocks);
    hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, framedatasize);
    if (dpvsimpledecode_decompressimage(s))
        return s->error;
 
    dpvsimpledecode_convertpixels(s, imagedata, imagebytesperrow);
    return s->error;
}

References dpvsimpledecodestream_t::bitstream, dpvsimpledecode_convertpixels(), dpvsimpledecode_decompressimage(), dpvsimpledecode_setpixelformat(), DPVSIMPLEDECODEERROR_EOF, DPVSIMPLEDECODEERROR_NONE, DPVSIMPLEDECODEERROR_READERROR, dpvsimpledecodestream_t::error, dpvsimpledecodestream_t::framedatablocks, hz_bitstream_read_blocks_read(), hz_bitstream_read_bytes(), and hz_bitstream_read_int().

Referenced by dpvsimpledecode_open().

hz_bitstream_read_bit()

static int hz_bitstream_read_bit ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 168 of file dpvsimpledecode.c.

{
    if (!blocks->count)
    {
        blocks->count += 8;
        blocks->store <<= 8;
        blocks->store |= hz_bitstream_read_blocks_getbyte(blocks) & 0xFF;
    }
    blocks->count--;
    return (blocks->store >> blocks->count) & 1;
}

References hz_bitstream_readblocks_t::count, hz_bitstream_read_blocks_getbyte(), and hz_bitstream_readblocks_t::store.

Referenced by dpvsimpledecode_decompressimage().

hz_bitstream_read_bits()

static unsigned int hz_bitstream_read_bits ( hz_bitstream_readblocks_t * blocks, int size )

static

Definition at line 180 of file dpvsimpledecode.c.

{
    unsigned int num = 0;
    // we can only handle about 24 bits at a time safely
    // (there might be up to 7 bits more than we need in the bit store)
    if (size > 24)
    {
        size -= 8;
        num |= hz_bitstream_read_bits(blocks, 8) << size;
    }
    while (blocks->count < size)
    {
        blocks->count += 8;
        blocks->store <<= 8;
        blocks->store |= hz_bitstream_read_blocks_getbyte(blocks) & 0xFF;
    }
    blocks->count -= size;
    num |= (blocks->store >> blocks->count) & ((1 << size) - 1);
    return num;
}

References hz_bitstream_readblocks_t::count, hz_bitstream_read_bits(), hz_bitstream_read_blocks_getbyte(), size, and hz_bitstream_readblocks_t::store.

Referenced by dpvsimpledecode_decompressimage(), and hz_bitstream_read_bits().

hz_bitstream_read_blocks_free()

static void hz_bitstream_read_blocks_free ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 90 of file dpvsimpledecode.c.

{
    hz_bitstream_readblock_t *b, *n;
    if (blocks == NULL)
        return;
    for (b = blocks->blocks;b;b = n)
    {
        n = b->next;
        Z_Free(b);
    }
    Z_Free(blocks);
}

References b, hz_bitstream_readblocks_t::blocks, n, NULL, and Z_Free.

Referenced by dpvsimpledecode_close(), and dpvsimpledecode_open().

hz_bitstream_read_blocks_getbyte()

static unsigned int hz_bitstream_read_blocks_getbyte ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 156 of file dpvsimpledecode.c.

{
    while (blocks->current != NULL && blocks->position >= blocks->current->size)
    {
        blocks->position = 0;
        blocks->current = blocks->current->next;
    }
    if (blocks->current == NULL)
        return 0;
    return blocks->current->data[blocks->position++];
}

References hz_bitstream_readblocks_t::current, hz_bitstream_readblock_t::data, hz_bitstream_readblock_t::next, NULL, hz_bitstream_readblocks_t::position, and hz_bitstream_readblock_t::size.

Referenced by hz_bitstream_read_bit(), hz_bitstream_read_bits(), and hz_bitstream_read_byte().

hz_bitstream_read_blocks_new()

static hz_bitstream_readblocks_t * hz_bitstream_read_blocks_new ( void )

static

Definition at line 80 of file dpvsimpledecode.c.

{
    hz_bitstream_readblocks_t *blocks;
    blocks = (hz_bitstream_readblocks_t *)Z_Malloc(sizeof(hz_bitstream_readblocks_t));
    if (blocks == NULL)
        return NULL;
    memset(blocks, 0, sizeof(hz_bitstream_readblocks_t));
    return blocks;
}

References NULL, and Z_Malloc.

Referenced by dpvsimpledecode_open().

hz_bitstream_read_blocks_read()

static int hz_bitstream_read_blocks_read ( hz_bitstream_readblocks_t * blocks, hz_bitstream_read_t * stream, unsigned int size )

static

Definition at line 109 of file dpvsimpledecode.c.

{
    int s;
    hz_bitstream_readblock_t *b, *p;
    s = size;
    p = NULL;
    b = blocks->blocks;
    while (s > 0)
    {
        if (b == NULL)
        {
            b = (hz_bitstream_readblock_t *)Z_Malloc(sizeof(hz_bitstream_readblock_t));
            if (b == NULL)
                return HZREADERROR_MALLOCFAILED;
            b->next = NULL;
            b->size = 0;
            if (p != NULL)
                p->next = b;
            else
                blocks->blocks = b;
        }
        if (s > HZREADBLOCKSIZE)
            b->size = HZREADBLOCKSIZE;
        else
            b->size = s;
        s -= b->size;
        if (FS_Read(stream->file, b->data, b->size) != (fs_offset_t)b->size)
        {
            stream->endoffile = 1;
            break;
        }
        p = b;
        b = b->next;
    }
    while (b)
    {
        b->size = 0;
        b = b->next;
    }
    blocks->current = blocks->blocks;
    blocks->position = 0;
    hz_bitstream_read_flushbits(blocks);
    if (stream->endoffile)
        return HZREADERROR_EOF;
    return HZREADERROR_OK;
}

References b, hz_bitstream_readblocks_t::blocks, hz_bitstream_readblocks_t::current, hz_bitstream_read_t::endoffile, hz_bitstream_read_t::file, FS_Read(), hz_bitstream_read_flushbits(), HZREADBLOCKSIZE, HZREADERROR_EOF, HZREADERROR_MALLOCFAILED, HZREADERROR_OK, hz_bitstream_readblock_t::next, NULL, hz_bitstream_readblocks_t::position, size, and Z_Malloc.

Referenced by dpvsimpledecode_open(), and dpvsimpledecode_video().

hz_bitstream_read_byte()

static unsigned int hz_bitstream_read_byte ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 201 of file dpvsimpledecode.c.

{
    return hz_bitstream_read_blocks_getbyte(blocks);
}

References hz_bitstream_read_blocks_getbyte().

Referenced by hz_bitstream_read_bytes(), hz_bitstream_read_int(), and hz_bitstream_read_short().

hz_bitstream_read_bytes()

static void hz_bitstream_read_bytes ( hz_bitstream_readblocks_t * blocks, void * outdata, unsigned int size )

static

Definition at line 220 of file dpvsimpledecode.c.

{
    unsigned char *out;
    out = (unsigned char *)outdata;
    while (size--)
        *out++ = hz_bitstream_read_byte(blocks);
}

References hz_bitstream_read_byte(), and size.

Referenced by dpvsimpledecode_open(), and dpvsimpledecode_video().

hz_bitstream_read_close()

static void hz_bitstream_read_close ( hz_bitstream_read_t * stream )

static

Definition at line 71 of file dpvsimpledecode.c.

{
    if (stream)
    {
        FS_Close(stream->file);
        Z_Free(stream);
    }
}

References hz_bitstream_read_t::file, FS_Close(), and Z_Free.

Referenced by dpvsimpledecode_close(), and dpvsimpledecode_open().

hz_bitstream_read_flushbits()

static void hz_bitstream_read_flushbits ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 103 of file dpvsimpledecode.c.

{
    blocks->store = 0;
    blocks->count = 0;
}

References hz_bitstream_readblocks_t::count, and hz_bitstream_readblocks_t::store.

Referenced by hz_bitstream_read_blocks_read().

hz_bitstream_read_int()

static unsigned int hz_bitstream_read_int ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 212 of file dpvsimpledecode.c.

{
    return (hz_bitstream_read_byte(blocks) << 24)
         | (hz_bitstream_read_byte(blocks) << 16)
         | (hz_bitstream_read_byte(blocks) << 8)
         | (hz_bitstream_read_byte(blocks));
}

References hz_bitstream_read_byte().

Referenced by dpvsimpledecode_open(), and dpvsimpledecode_video().

hz_bitstream_read_open()

static hz_bitstream_read_t * hz_bitstream_read_open ( char * filename )

static

Definition at line 56 of file dpvsimpledecode.c.

{
    qfile_t *file;
    hz_bitstream_read_t *stream;
    if ((file = FS_OpenVirtualFile(filename, false)))
    {
        stream = (hz_bitstream_read_t *)Z_Malloc(sizeof(hz_bitstream_read_t));
        memset(stream, 0, sizeof(*stream));
        stream->file = file;
        return stream;
    }
    else
        return NULL;
}

References hz_bitstream_read_t::file, FS_OpenVirtualFile(), NULL, and Z_Malloc.

Referenced by dpvsimpledecode_open().

hz_bitstream_read_short()

static unsigned int hz_bitstream_read_short ( hz_bitstream_readblocks_t * blocks )

static

Definition at line 206 of file dpvsimpledecode.c.

{
    return (hz_bitstream_read_byte(blocks) << 8)
         | (hz_bitstream_read_byte(blocks));
}

References hz_bitstream_read_byte().

Referenced by dpvsimpledecode_open().