static mng_bool MNGPLG_CALLBACK callback_processheader(mng_handle mng,mng_uint32 iWidth,mng_uint32 iHeight)
{
PluginInstance *This;
This = (PluginInstance*) mng_get_userdata(mng);
This->diblinesize = (((iWidth * 24)+31)/32)*4;
This->dibsize = sizeof(BITMAPINFOHEADER) + This->diblinesize*iHeight;
This->lpdib = calloc(This->dibsize,1);
This->lpdibinfo = (LPBITMAPINFOHEADER)This->lpdib;
This->lpdibbits = &This->lpdib[sizeof(BITMAPINFOHEADER)];
ZeroMemory((void*)This->lpdib,sizeof(BITMAPINFOHEADER));
This->lpdibinfo->biSize = sizeof(BITMAPINFOHEADER);
This->lpdibinfo->biWidth = iWidth;
This->lpdibinfo->biHeight = iHeight;
This->lpdibinfo->biPlanes = 1;
This->lpdibinfo->biBitCount = 24;
mng_set_canvasstyle (mng, MNG_CANVAS_BGR8);
/* if(This->fhWnd) {
if((int)iWidth > This->windowwidth || (int)iHeight > This->windowheight) {
This->scrolling=1;
}
} */
set_scrollbars(This);
return MNG_TRUE;
}
/*
* Renders an animation frame to the anim's canvas.
*/
void anim_render_canvas(anim *a)
{
int ret;
mng_anim *mng;
obj *o;
mng = mng_get_userdata(a->mng);
mng->wait_msecs = 0;
memset(&mng->start_time, 0, sizeof(struct timeval));
/* XXX: This is a workaround for what seems to be a bug in libmng.
* Either we clear the canvas ourselves, or parts of the previous frame
* will remain in it after rendering the current one. */
memset(mng->canvas, 0, mng->canvas_h * mng->canvas_w * mng->canvas_bytes_pp);
ret = mng_render_next(a->mng);
if (ret == MNG_NOERROR) {
if (a->flags & F_ANIM_ONCE) {
a->status = F_ANIM_STATUS_DONE;
} else {
mng_display_restart(a->mng);
}
}
if (ret == MNG_NOERROR || ret == MNG_NEEDTIMERWAIT) {
o = container_of(a);
o->invalid = true;
}
}
static mng_bool
mng_read_data_callback (mng_handle mng_h,
mng_ptr buffer,
mng_uint32 bytes_requested,
mng_uint32 * bytes_read)
{
FUNCTION_ENTRY();
*bytes_read = 0;
return MNG_FALSE;
guint available_mng_food;
GtkMngView * mng_view = GTK_MNG_VIEW (mng_get_userdata (mng_h));
available_mng_food = mng_view->bytes_to_eat - mng_view->bytes_eaten;
if (available_mng_food > 0 && mng_view->mng_food != NULL)
{
* bytes_read = (mng_uint32) MIN ((mng_uint32) available_mng_food, bytes_requested);
memcpy (buffer, mng_view->mng_food + mng_view->bytes_eaten, * bytes_read);
mng_view->bytes_eaten += * bytes_read;
FUNCTION_EXIT();
return MNG_TRUE;
}
else {
FUNCTION_EXIT();
return MNG_FALSE;
}
}
mng_retcode mng_display_restart(mng_handle mngh)
{
mng_anim *mng = mng_get_userdata(mngh);
mng->displayed_first = 0;
return mng_display_reset(mngh);
}
static mng_bool mymngwritestream (mng_handle mng, mng_ptr pBuf, mng_uint32 iSize, mng_uint32 *iWritten)
{
mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
// write it
*iWritten = mymng->file->Write (pBuf, 1, iSize);
return MNG_TRUE;
}
static mng_ptr MNG_DECL my_getcanvasline(mng_handle handle, mng_uint32 linenr)
{
Mng *mng;
mng = (Mng *)mng_get_userdata(handle);
return mng->buffer + linenr * mng->surface->w * 3;
}
static mng_bool fb_mng_settimer(mng_handle handle, mng_uint32 msecs)
{
mng_anim *mng = mng_get_userdata(handle);
mng->wait_msecs = msecs;
return MNG_TRUE;
}
////////////////////////////////////////////////////////////////////////////////
// feed data to the decoder
static mng_bool mymngreadstream(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread)
{
mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
// read the requested amount of data from the file
*bytesread = mymng->file->Read( buffer, sizeof(BYTE), size);
return MNG_TRUE;
}
static mng_bool MNG_DECL my_settimer(mng_handle handle, mng_uint32 msecs)
{
Mng *mng = (Mng *)mng_get_userdata(handle);
mng->ticks = GetTicks() + msecs;
return MNG_TRUE;
}
static mng_bool fb_mng_closestream(mng_handle handle)
{
mng_anim *mng = mng_get_userdata(handle);
mng->open = 0;
return MNG_TRUE;
}
static mng_bool MNGPLG_CALLBACK callback_refresh (mng_handle mng, mng_uint32 iLeft, mng_uint32 iTop,
mng_uint32 iRight, mng_uint32 iBottom)
{
PluginInstance *This;
RECT rect;
This = (PluginInstance*) mng_get_userdata(mng);
if(This->loadstate<STATE_VALIDFRAME) {
This->loadstate=STATE_VALIDFRAME;
}
if(This->fhWnd) {
if(This->paintedyet) {
rect.left= iLeft - This->xscrollpos;
rect.top= iTop - This->yscrollpos;
rect.right= iLeft+iRight;
rect.bottom= iTop+iBottom;
InvalidateRect(This->fhWnd,&rect,FALSE);
}
else {
// Make sure the first paint clears the whole plugin window
InvalidateRect(This->fhWnd,NULL,TRUE);
This->paintedyet=1;
}
UpdateWindow(This->fhWnd);
}
return MNG_TRUE;
}
/**
* \brief MNG library callback: Get how many milliseconds have passed.
* \param[in] h_mng MNG library image handle
* \return global time in milliseconds
*/
static mng_uint32 demux_mng_gettickcount(mng_handle h_mng)
{
mng_priv_t * mng_priv = mng_get_userdata(h_mng);
// return current global time
return mng_priv->global_time_ms;
}
mng_bool MNG_DECL
CMNGAnimation::CB_SetTimer(mng_handle handle, mng_uint32 msecs)
{
CMNGAnimation* This = (CMNGAnimation*)mng_get_userdata(handle);
This->m_delay = msecs;
return MNG_TRUE;
}
mng_bool MNG_DECL
CMNGAnimation::CB_ReadData(mng_handle handle, mng_ptr buf, mng_uint32 len, mng_uint32p read)
{
CMNGAnimation* This = (CMNGAnimation*)mng_get_userdata(handle);
*read = This->m_file->Read(buf, len);
return MNG_TRUE;
}
static mng_bool MNG_DECL my_processheader(mng_handle handle, mng_uint32 width,
mng_uint32 height)
{
Uint32 Rmask;
Uint32 Gmask;
Uint32 Bmask;
mng_imgtype type;
Mng *mng;
#ifdef USE_OPENGL
unsigned w;
unsigned h;
#endif
type = mng_get_sigtype(handle);
if (type != mng_it_mng) {
return TRUE;
}
mng = (Mng *)mng_get_userdata(handle);
#ifdef USE_OPENGL
for (w = 1; w < width; w <<= 1) {
}
for (h = 1; h < height; h <<= 1) {
}
mng->texture_width = (float)width / w;
mng->texture_height = (float)height / h;
glGenTextures(1, &mng->texture_name);
glBindTexture(GL_TEXTURE_2D, mng->texture_name);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
#endif
// Allocate the SDL surface to hold the image
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
Rmask = 0x000000FF;
Gmask = 0x0000FF00;
Bmask = 0x00FF0000;
#else
Rmask = 0xFF000000 >> 8;
Gmask = 0x00FF0000 >> 8;
Bmask = 0x0000FF00 >> 8;
#endif
mng->buffer = new unsigned char[width * height * 3];
memset(mng->buffer, width * height * 3, sizeof(unsigned char));
mng->surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height,
8 * 3, Rmask, Gmask, Bmask, 0);
if (mng->surface == NULL) {
fprintf(stderr, "Out of memory");
ExitFatal(1);
}
return MNG_TRUE;
}
static mng_bool MNG_DECL my_processmend(mng_handle handle, mng_uint32 iterationsdone,
mng_uint32)
{
Mng *mng = (Mng *)mng_get_userdata(handle);
mng->iteration = iterationsdone;
return MNG_TRUE;
}
mng_bool ImageJngFile::cb_settimer (mng_handle hHandle, mng_uint32 iMsecs)
{
ImageJngFile *this_ = (ImageJngFile *)mng_get_userdata (hHandle);
this_->timer = iMsecs;
return MNG_TRUE;
}
mng_ptr ImageJngFile::cb_getcanvasline (mng_handle hHandle, mng_uint32 iLineNr)
{
ImageJngFile *this_;
this_ = (ImageJngFile *)mng_get_userdata (hHandle);
return this_->NewImage + (iLineNr * this_->Width * 4);
}
static mng_bool MNGPLG_CALLBACK callback_closestream (mng_handle mng)
{
PluginInstance *This;
This = (PluginInstance*) mng_get_userdata(mng);
This->loadstate = STATE_LOADED; // this is probably redundant
return MNG_TRUE;
}
mng_bool
mymngreadstream(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread) {
mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
*bytesread = mymng->io->read_proc(buffer, 1, size, mymng->file);
return MNG_TRUE;
}
mng_ptr csJNGImageIO::cb_getcanvasline(mng_handle hHandle, mng_uint32 iLinenr)
{
csJNGImageIO *this_;
this_ = (csJNGImageIO *)mng_get_userdata (hHandle);
return (csRGBpixel*)this_->imgRGBA->GetImageData()+(iLinenr*this_->imgRGBA->GetWidth());
}
static mng_ptr MNGPLG_CALLBACK callback_getcanvasline (mng_handle mng, mng_uint32 iLinenr)
{
unsigned char *pp;
PluginInstance *This;
This = (PluginInstance*) mng_get_userdata(mng);
pp = (&This->lpdibbits[(This->lpdibinfo->biHeight-1-iLinenr)*This->diblinesize]);
return (mng_ptr) pp;
}
/**
* \brief MNG library callback: Please call again after some milliseconds.
* \param[in] h_mng MNG library image handle
* \param[in] msecs number of milliseconds after which to call again
* \return \p MNG_TRUE on success, \p MNG_FALSE on error (never happens)
*/
static mng_bool demux_mng_settimer(mng_handle h_mng, mng_uint32 msecs)
{
mng_priv_t * mng_priv = mng_get_userdata(h_mng);
// Save number of milliseconds after which to call the MNG library again
// in private data.
mng_priv->timer_ms = msecs;
return MNG_TRUE;
}
/**
* @brief libmng callback: write libmng data to the open stream
* @param[in] mng libmng handle
* @param[in] *buf pointer to data to write
* @param[in] size size of data to write
* @param[out] *written size of data written
* @return if data was written successfully
*/
static mng_bool vomng_writedata(mng_handle mng, mng_ptr buf,
mng_uint32 size, mng_uint32 *written)
{
FILE *file = mng_get_userdata(mng);
*written = fwrite(buf, 1, size, file);
/* according to the example in libmng documentation, true is always
returned here, short writes can be detected by libmng via *written */
return MNG_TRUE;
}
static mng_bool MNG_DECL my_readdata(mng_handle handle, mng_ptr buf, mng_uint32 buflen,
mng_uint32p read)
{
Mng *mng;
mng = (Mng *)mng_get_userdata(handle);
*read = fread(buf, 1, buflen, mng->fd);
return MNG_TRUE;
}
static mng_bool mngProcessHeaderFn(mng_handle mng, mng_uint32 width, mng_uint32 height)
{
mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
GFXFormat format;
mng_uint8 colorType = mng_get_colortype(mng);
mng_uint8 alphaDepth = mng_get_alphadepth(mng);
switch(colorType)
{
case MNG_COLORTYPE_GRAY:
case MNG_COLORTYPE_JPEGGRAY:
format = GFXFormatR8G8B8;
mng_set_canvasstyle(mng, MNG_CANVAS_RGB8);
break;
case MNG_COLORTYPE_INDEXED:
if(alphaDepth >= 1)
{
format = GFXFormatR8G8B8A8;
mng_set_canvasstyle(mng, MNG_CANVAS_RGBA8);
}
else
{
format = GFXFormatR8G8B8;
mng_set_canvasstyle(mng, MNG_CANVAS_RGB8);
}
case MNG_COLORTYPE_RGB:
case MNG_COLORTYPE_JPEGCOLOR:
if(alphaDepth >= 1)
{
format = GFXFormatR8G8B8A8;
mng_set_canvasstyle(mng, MNG_CANVAS_RGBA8);
}
else
{
format = GFXFormatR8G8B8;
mng_set_canvasstyle(mng, MNG_CANVAS_RGB8);
}
break;
case MNG_COLORTYPE_RGBA:
case MNG_COLORTYPE_JPEGCOLORA:
format = GFXFormatR8G8B8A8;
mng_set_canvasstyle(mng, MNG_CANVAS_RGBA8);
break;
default:
// This case should never get hit, however it resolves a compiler
// warning
format = GFXFormat_FIRST;
AssertISV( false, "Unknown color format in bitmap MNG Loading" );
}
mymng->image->allocateBitmap(width, height, false, format);
return MNG_TRUE;
}
/**
* \brief MNG library callback: Get access to a canvas line.
* \param[in] h_mng MNG library image handle
* \param[in] line y coordinate of line to access
* \return pointer to line on success, \p MNG_NULL on error
*/
static mng_ptr demux_mng_getcanvasline(mng_handle h_mng, mng_uint32 line)
{
mng_priv_t * mng_priv = mng_get_userdata(h_mng);
// return pointer to canvas line
if (line < mng_priv->height && mng_priv->canvas)
return (mng_ptr)(mng_priv->canvas + line * mng_priv->width * 4);
else
return (mng_ptr)MNG_NULL;
}
/**
* \brief MNG library callback: Open MNG stream.
* \param[in] h_mng MNG library image handle
* \return \p MNG_TRUE on success, \p MNG_FALSE on error (never happens)
*/
static mng_bool demux_mng_openstream(mng_handle h_mng)
{
mng_priv_t * mng_priv = mng_get_userdata(h_mng);
stream_t * stream = mng_priv->stream;
// rewind stream to the beginning
stream_seek(stream, stream->start_pos);
return MNG_TRUE;
}
static mng_bool MNG_DECL my_errorproc(mng_handle handle, mng_int32,
mng_int8, mng_chunkid, mng_uint32, mng_int32, mng_int32, mng_pchar errortext)
{
Mng *mng = (Mng *)mng_get_userdata(handle);
mng->iteration = 0x7fffffff;
if (errortext) {
DebugPrint("MNG error: %s\n" _C_ errortext);
}
return TRUE;
}
static mng_bool MNG_DECL my_closestream(mng_handle handle)
{
Mng *mng;
mng = (Mng *)mng_get_userdata(handle);
if (mng->fd) {
fclose(mng->fd);
}
return MNG_TRUE;
}