Пример #1
0
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;
}
Пример #2
0
static gboolean
gtk_mng_view_init_libmng (GtkMngView * mng_view)
{
    FUNCTION_ENTRY();
  GtkWidget * widget;

  g_return_val_if_fail (IS_GTK_MNG_VIEW (mng_view), FALSE);

  if (mng_view->MNG_handle)
    mng_cleanup (&mng_view->MNG_handle);

  mng_view->MNG_handle = mng_initialize (mng_view,
					 mng_malloc_callback,
					 mng_free_callback,
					 MNG_NULL);

  if (mng_view->MNG_handle == MNG_NULL) {
      FUNCTION_EXIT();
    return FALSE;
  }

  mng_set_storechunks(mng_view->MNG_handle, MNG_TRUE);
  //mng_set_dfltimggamma(mng_view->MNG_handle, 5);
  //mng_set_displaygamma(mng_view->MNG_handle, 4);
  if (mng_setcb_openstream (mng_view->MNG_handle, mng_open_stream_callback) != MNG_NOERROR ||
      mng_setcb_closestream (mng_view->MNG_handle, mng_close_stream_callback) != MNG_NOERROR ||
      mng_setcb_readdata (mng_view->MNG_handle, mng_read_data_callback) != MNG_NOERROR ||
      mng_setcb_processheader (mng_view->MNG_handle, mng_process_header_callback) != MNG_NOERROR ||
      mng_setcb_processmend (mng_view->MNG_handle, mng_process_mend_callback) != MNG_NOERROR ||
      mng_setcb_processterm (mng_view->MNG_handle, mng_process_term_callback) != MNG_NOERROR ||
      mng_setcb_settimer (mng_view->MNG_handle, mng_set_timer_callback) != MNG_NOERROR ||
      mng_setcb_gettickcount (mng_view->MNG_handle, mng_get_tickcount_callback) != MNG_NOERROR ||
      mng_setcb_getcanvasline (mng_view->MNG_handle, mng_get_canvas_line_callback) != MNG_NOERROR ||
      mng_setcb_getalphaline (mng_view->MNG_handle, mng_get_alpha_line_callback) != MNG_NOERROR ||
      mng_setcb_refresh (mng_view->MNG_handle, mng_refresh_callback) != MNG_NOERROR)
    {
      mng_cleanup (&mng_view->MNG_handle);
      FUNCTION_EXIT();
      return FALSE;
    }

      //mng_set_suspensionmode(mng_view->MNG_handle, MNG_TRUE);
  mng_set_canvasstyle (mng_view->MNG_handle, MNG_CANVAS_RGB8_A8);

  widget = GTK_WIDGET (mng_view);

  if (!GTK_WIDGET_REALIZED (widget))
    gtk_widget_realize (widget);

  mng_set_bgcolor (mng_view->MNG_handle,
		   widget->style->bg[GTK_STATE_NORMAL].red,
		   widget->style->bg[GTK_STATE_NORMAL].green,
		   widget->style->bg[GTK_STATE_NORMAL].blue);
  FUNCTION_EXIT();
  return TRUE;
}
Пример #3
0
//---------------------------------------------------------------------------------------------
// the header's been read. set up the display stuff
//---------------------------------------------------------------------------------------------
mng_bool MNG_DECL mymngprocessheader(mng_handle mng, mng_uint32 width, mng_uint32 height)
{
	ILuint	AlphaDepth;

	AlphaDepth = mng_get_alphadepth(mng);

	if (AlphaDepth == 0) {
		ilTexImage(width, height, 1, 3, IL_BGR, IL_UNSIGNED_BYTE, NULL);
		iCurImage->Origin = IL_ORIGIN_LOWER_LEFT;
		mng_set_canvasstyle(mng, MNG_CANVAS_BGR8);
	}
	else {  // Use alpha channel
		ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL);
		iCurImage->Origin = IL_ORIGIN_LOWER_LEFT;
		mng_set_canvasstyle(mng, MNG_CANVAS_BGRA8);
	}

	iCurImage->Origin = IL_ORIGIN_UPPER_LEFT;

	return MNG_TRUE;
}
Пример #4
0
mng_bool
mymngprocessheader(mng_handle mng, mng_uint32 width, mng_uint32 height) {
	mngstuff *client_data = (mngstuff *)mng_get_userdata(mng);
	BYTE bHasAlpha = mng_get_alphadepth(mng);

#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_RGB
	if(bHasAlpha) {
		// allocate a bitmap with the given dimensions
		FIBITMAP *bitmap = FreeImage_Allocate(width, height, 32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
		client_data->bitmap = bitmap;
		// tell the mng decoder about our bit-depth choice
		mng_set_canvasstyle(mng, MNG_CANVAS_RGBA8);
	} else {
		// allocate a bitmap with the given dimensions
		FIBITMAP *bitmap = FreeImage_Allocate(width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
		client_data->bitmap = bitmap;
		// tell the mng decoder about our bit-depth choice
		mng_set_canvasstyle(mng, MNG_CANVAS_RGB8);
	}
#else
	if(bHasAlpha) {
		// allocate a bitmap with the given dimensions
		FIBITMAP *bitmap = FreeImage_Allocate(width, height, 32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
		client_data->bitmap = bitmap;
		// tell the mng decoder about our bit-depth choice
		mng_set_canvasstyle(mng, MNG_CANVAS_BGRA8);
	} else {
		// allocate a bitmap with the given dimensions
		FIBITMAP *bitmap = FreeImage_Allocate(width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
		client_data->bitmap = bitmap;
		// tell the mng decoder about our bit-depth choice
		mng_set_canvasstyle(mng, MNG_CANVAS_BGR8);
	}
#endif // FREEIMAGE_COLORORDER_RGB

	return client_data->bitmap ? MNG_TRUE : MNG_FALSE;
}
Пример #5
0
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;
}
Пример #6
0
mng_bool MNG_DECL
CMNGAnimation::CB_ProcessHeader(mng_handle handle, mng_uint32 width, mng_uint32 height)
{
  CMNGAnimation* This = (CMNGAnimation*)mng_get_userdata(handle);
  This->m_width = width;
  This->m_height = height;

  // in case ProcessHeader is called twice
  delete[] This->m_frame_buffer;
  This->m_frame_buffer = new RGBA[width * height];
  This->m_first_display = true;

  mng_set_canvasstyle(handle, MNG_CANVAS_RGBA8);

  return MNG_TRUE;
}
Пример #7
0
mng_bool ImageJngFile::cb_processheader (mng_handle hHandle, 
					  mng_uint32 iWidth, mng_uint32 iHeight)
{
  ImageJngFile *this_;
  
  this_ = (ImageJngFile *)mng_get_userdata (hHandle);

  if (mng_set_canvasstyle (hHandle, MNG_CANVAS_RGBA8))
  {
    ReportLibmngError (this_->object_reg, hHandle, "failed to set canvas style");
    return MNG_FALSE;
  }
   
  this_->Width = iWidth;
  this_->Height = iHeight;
  this_->NewImage = new uint8 [iWidth * iHeight * 4];

  return MNG_TRUE;
}
Пример #8
0
static mng_bool fb_mng_processheader(mng_handle handle, mng_uint32 width,
		mng_uint32 height)
{
	mng_anim *mng = mng_get_userdata(handle);

	free(mng->canvas);

	mng->canvas_bytes_pp = 4;

	if ((mng->canvas = malloc(width*height*mng->canvas_bytes_pp)) == NULL) {
		iprint(MSG_ERROR, "%s: Unable to allocate memory for MNG canvas\n",
				__FUNCTION__);
		return MNG_FALSE;
	}
	mng->canvas_w = width;
	mng->canvas_h = height;

	mng_set_canvasstyle(handle, MNG_CANVAS_RGBA8);
#if 0
	mng_set_bgcolor(handle, 0, 0, 0); /* FIXME - make configurable? */
#endif
	return MNG_TRUE;
}
Пример #9
0
/**
 * \brief MPlayer callback: Open MNG stream.
 * \param[in] demuxer demuxer structure
 * \return demuxer structure on success, \p NULL on error
 */
static demuxer_t * demux_mng_open(demuxer_t * demuxer)
{
    mng_priv_t * mng_priv;
    mng_handle h_mng;
    mng_retcode mng_ret;
    sh_video_t * sh_video;

    // create private data structure
    mng_priv = calloc(1, sizeof(mng_priv_t));

    //stream pointer into private data
    mng_priv->stream = demuxer->stream;

    // initialize MNG image instance
    h_mng = mng_initialize((mng_ptr)mng_priv, demux_mng_alloc,
                           demux_mng_free, MNG_NULL);
    if (!h_mng) {
        mp_msg(MSGT_DEMUX, MSGL_ERR,
               "demux_mng: could not initialize MNG image instance\n");
        free(mng_priv);
        return NULL;
    }

    // MNG image handle into private data
    mng_priv->h_mng = h_mng;

    // set required MNG callbacks
    if (mng_setcb_openstream(h_mng, demux_mng_openstream) ||
        mng_setcb_closestream(h_mng, demux_mng_closestream) ||
        mng_setcb_readdata(h_mng, demux_mng_readdata) ||
        mng_setcb_processheader(h_mng, demux_mng_processheader) ||
        mng_setcb_getcanvasline(h_mng, demux_mng_getcanvasline) ||
        mng_setcb_refresh(h_mng, demux_mng_refresh) ||
        mng_setcb_gettickcount(h_mng, demux_mng_gettickcount) ||
        mng_setcb_settimer(h_mng, demux_mng_settimer) ||
        mng_set_canvasstyle(h_mng, MNG_CANVAS_RGBA8)) {
        mp_msg(MSGT_DEMUX, MSGL_ERR,
               "demux_mng: could not set MNG callbacks\n");
        mng_cleanup(&h_mng);
        free(mng_priv);
        return NULL;
    }

    // start reading MNG data
    mng_ret = mng_read(h_mng);
    if (mng_ret) {
        mp_msg(MSGT_DEMUX, MSGL_ERR,
               "demux_mng: could not start reading MNG data: "
               "mng_retcode %d\n", mng_ret);
        mng_cleanup(&h_mng);
        free(mng_priv);
        return NULL;
    }

    // check that MNG header is processed now
    if (!mng_priv->header_processed) {
        mp_msg(MSGT_DEMUX, MSGL_ERR,
               "demux_mng: internal error: header not processed\n");
        mng_cleanup(&h_mng);
        free(mng_priv);
        return NULL;
    }

    // create a new video stream header
    sh_video = new_sh_video(demuxer, 0);

    // Make sure the demuxer knows about the new video stream header
    // (even though new_sh_video() ought to take care of it).
    // (Thanks to demux_gif.c for this.)
    demuxer->video->sh = sh_video;

    // Make sure that the video demuxer stream header knows about its
    // parent video demuxer stream (this is getting wacky), or else
    // video_read_properties() will choke.
    // (Thanks to demux_gif.c for this.)
    sh_video->ds = demuxer->video;

    // set format of pixels in video packets
    sh_video->format = mmioFOURCC(32, 'B', 'G', 'R');

    // set framerate to some value (MNG does not have a fixed framerate)
    sh_video->fps       = 5.0f;
    sh_video->frametime = 1.0f / sh_video->fps;

    // set video frame parameters
    sh_video->bih                = malloc(sizeof(*sh_video->bih));
    sh_video->bih->biCompression = sh_video->format;
    sh_video->bih->biWidth       = mng_priv->width;
    sh_video->bih->biHeight      = mng_priv->height;
    sh_video->bih->biBitCount    = 32;
    sh_video->bih->biPlanes      = 1;

    // Set start time to something > 0.
    //  - This is required for the variable frame time mechanism
    //    (GIF, MATROSKA, MNG) in video.c to work for the first frame.
    sh_video->ds->pts = MNG_START_PTS;

    // set private data in demuxer and return demuxer
    demuxer->priv = mng_priv;
    return demuxer;
}