Index: Makefile
===================================================================
--- Makefile	(revision 27638)
+++ Makefile	(working copy)
@@ -182,6 +182,7 @@
               libmpdemux/demux_lmlm4.c \
               libmpdemux/demux_mf.c \
               libmpdemux/demux_mkv.c \
+              libmpdemux/demux_mng.c \
               libmpdemux/demux_mov.c \
               libmpdemux/demux_mpg.c \
               libmpdemux/demux_nsv.c \
Index: configure
===================================================================
--- configure	(revision 27638)
+++ configure	(working copy)
@@ -274,6 +274,7 @@
 Codecs:
   --enable-gif		    enable GIF support [autodetect]
   --enable-png		    enable PNG input/output support [autodetect]
+  --enable-mng		    enable MNG input support [autodetect]
   --enable-jpeg		    enable JPEG input/output support [autodetect]
   --enable-libcdio	    enable libcdio support [autodetect]
   --enable-liblzo	    enable liblzo support [autodetect]
@@ -537,6 +538,7 @@
 _win32waveout=auto
 _nas=auto
 _png=auto
+_mng=auto
 _jpeg=auto
 _pnm=yes
 _md5sum=yes
@@ -858,6 +860,8 @@
   --disable-nas)	_nas=no		;;
   --enable-png)		_png=yes	;;
   --disable-png)	_png=no		;;
+  --enable-mng)		_mng=yes	;;
+  --disable-mng)	_mng=no		;;
   --enable-jpeg)	_jpeg=yes	;;
   --disable-jpeg)	_jpeg=no		;;
   --enable-pnm)		_pnm=yes	;;
@@ -4683,6 +4687,33 @@
   _novomodules="png $_novomodules"
 fi
 
+echocheck "MNG support"
+if test "$_mng" = auto ; then
+  _mng=no
+  cat > $TMPC << EOF
+#include <libmng.h>
+int main(void) {
+  const char * p_ver = mng_version_text() ?: "";
+  printf("libmng: %s\n", p_ver);
+  return p_ver[0] == 0;
+}
+EOF
+  if cc_check -lmng -lz $_ld_lm ; then
+    if tmp_run ; then
+      _mng=yes
+    else
+      _res_comment="no library version"
+    fi
+  fi
+fi
+echores "$_mng"
+if test "$_mng" = yes ; then
+  _def_mng='#define HAVE_MNG 1'
+  _ld_extra="$_ld_extra -lmng -lz"
+else
+  _def_mng='#undef HAVE_MNG'
+fi
+
 echocheck "JPEG support"
 if test "$_jpeg" = auto ; then
   _jpeg=no
@@ -7950,6 +7981,7 @@
 LIVE555 = $_live
 MACOSX_BUNDLE = $_macosx_bundle
 MACOSX_FINDER = $_macosx_finder
+MNG = $_mng
 MP3LAME = $_mp3lame
 MUSEPACK = $_musepack
 NATIVE_RTSP = $_native_rtsp
@@ -8623,6 +8655,9 @@
 /* enable PNG support */
 $_def_png
 
+/* enable MNG support */
+$_def_mng
+
 /* enable JPEG support */
 $_def_jpeg
 
Index: libmpdemux/video.c
===================================================================
--- libmpdemux/video.c	(revision 27638)
+++ libmpdemux/video.c	(working copy)
@@ -561,6 +561,7 @@
     if(!force_fps) switch(demuxer->file_format){
       case DEMUXER_TYPE_GIF:
       case DEMUXER_TYPE_MATROSKA:
+      case DEMUXER_TYPE_MNG:
        if(d_video->pts>0 && pts1>0 && d_video->pts>pts1)
          frame_time=d_video->pts-pts1;
         break;
Index: libmpdemux/demuxer.c
===================================================================
--- libmpdemux/demuxer.c	(revision 27638)
+++ libmpdemux/demuxer.c	(working copy)
@@ -80,6 +80,7 @@
 extern const demuxer_desc_t demuxer_desc_lavf_preferred;
 extern const demuxer_desc_t demuxer_desc_aac;
 extern const demuxer_desc_t demuxer_desc_nut;
+extern const demuxer_desc_t demuxer_desc_mng;
 
 /* Please do not add any new demuxers here. If you want to implement a new
  * demuxer, add it to libavformat, except for wrappers around external
@@ -152,6 +153,9 @@
 #ifdef CONFIG_XMMS
     &demuxer_desc_xmms,
 #endif
+#ifdef HAVE_MNG
+    &demuxer_desc_mng,
+#endif
     /* Please do not add any new demuxers here. If you want to implement a new
      * demuxer, add it to libavformat, except for wrappers around external
      * libraries and demuxers requiring binary support. */
Index: libmpdemux/demuxer.h
===================================================================
--- libmpdemux/demuxer.h	(revision 27638)
+++ libmpdemux/demuxer.h	(working copy)
@@ -63,11 +63,12 @@
 #define DEMUXER_TYPE_NUT 43
 #define DEMUXER_TYPE_LAVF_PREFERRED 44
 #define DEMUXER_TYPE_RTP_NEMESI 45
+#define DEMUXER_TYPE_MNG 46
 
 // This should always match the higest demuxer type number.
 // Unless you want to disallow users to force the demuxer to some types
 #define DEMUXER_TYPE_MIN 0
-#define DEMUXER_TYPE_MAX 45
+#define DEMUXER_TYPE_MAX 46
 
 #define DEMUXER_TYPE_DEMUXERS (1<<16)
 // A virtual demuxer type for the network code
Index: libmpdemux/demux_mng.c
===================================================================
--- libmpdemux/demux_mng.c	(revision 0)
+++ libmpdemux/demux_mng.c	(revision 0)
@@ -0,0 +1,528 @@
+/*
+ * MNG file demuxer for MPlayer
+ *
+ * Copyright (C) 2008 Stefan Schuermans <stefan blinkenarea org>
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "config.h"
+
+#include "mp_msg.h"
+#include "help_mp.h"
+
+#include "stream/stream.h"
+#include "demuxer.h"
+#include "stheader.h"
+
+#define MNG_SUPPORT_READ
+#define MNG_SUPPORT_DISPLAY
+#include <libmng.h>
+
+// some small fixed start time > 0
+//  - start time must be > 0 for the variable frame time mechanism
+//    (GIF, MATROSKA, MNG) in video.c to work for the first frame
+#define MNG_START_PTS 0.01f
+
+// private context structure
+//  - used as private data in MPlayer demuxer
+//  - used as private data in MNG library
+typedef struct {
+  demuxer_t * demuxer;        // pointer to MPlayer demuxer object
+  mng_handle h_mng;           // MNG library image handle
+  int header_processed;       // if header of MNG image is processed
+  mng_uint32 width;           // MNG image width
+  mng_uint32 height;          // MNG image height
+  int total_time_ms;          // total time of MNG animation
+                              //   (in milliseconds)
+  unsigned char * canvas;     // canvas to draw the image onto
+                              //  - lines top-down with pixels left-to-right
+                              //     with channels RGB, no padding
+                              //  - NULL if no canvas yet
+  int displaying;             // if displaying already (i.e. if mng_display
+                              //   has already been called)
+  int finished;               // if animation is finished
+  int global_time_ms;         // current global time for MNG library
+  int anim_cur_time_ms;       // time of current frame in MNG animation
+  int anim_frame_duration_ms; // duration of current frame in MNG animation
+  int show_cur_time_ms;       // current time in the show process,
+                              //   i.e. time of last demux packet created
+  int show_next_time_ms;      // next time in the show process,
+                              //   i.e. time of next demux packet to create
+  int timer_ms;               // number of milliseconds after which
+                              //   the MNG library wants to be called again
+                              // (members named *_ms are in  milliseconds)
+} mng_priv_t;
+
+// MNG library callback: allocate a new memory block and fill it with zeros
+static mng_ptr demux_mng_alloc(mng_size_t size)
+{
+  return calloc(1, size);
+}
+
+// MNG library callback: free memory block
+static void demux_mng_free(mng_ptr ptr, mng_size_t size)
+{
+  free(ptr);
+}
+
+// MNG library callback: open MNG stream
+static mng_bool demux_mng_openstream(mng_handle h_mng)
+{
+  mng_priv_t * mng_priv = mng_get_userdata(h_mng);
+  demuxer_t * demuxer = mng_priv->demuxer;
+
+  // rewind stream to the beginning
+  stream_seek(demuxer->stream, demuxer->stream->start_pos);
+
+  return MNG_TRUE;
+}
+
+// MNG library callback: close MNG stream
+static mng_bool demux_mng_closestream(mng_handle h_mng)
+{
+  return MNG_TRUE;
+}
+
+// MNG library callback: read data from stream
+static mng_bool demux_mng_readdata(mng_handle h_mng, mng_ptr buf,
+                                   mng_uint32 size, mng_uint32 * read)
+{
+  mng_priv_t * mng_priv = mng_get_userdata(h_mng);
+  demuxer_t * demuxer = mng_priv->demuxer;
+
+  // simply read data from stream and return number of bytes or error
+  *read = stream_read(demuxer->stream, buf, size);
+
+  return MNG_TRUE;
+}
+
+// MNG library callback: header information is processed now
+static mng_bool demux_mng_processheader(mng_handle h_mng, mng_uint32 width,
+                                        mng_uint32 height)
+{
+  mng_priv_t * mng_priv = mng_get_userdata(h_mng);
+
+  // remember size in private data
+  mng_priv->header_processed = 1;
+  mng_priv->width = width;
+  mng_priv->height = height;
+
+  // get total time of animation
+  mng_priv->total_time_ms = mng_get_playtime(h_mng);
+
+  // allocate canvas
+  mng_priv->canvas = malloc(height * width * 3);
+  if (!mng_priv->canvas) {
+    mp_msg(MSGT_DEMUX, MSGL_ERR,
+           "demux_mng: could not allocate canvas of size %dx%d\n",
+           width, height);
+    return MNG_FALSE;
+  }
+
+  return MNG_TRUE;
+}
+
+// MNG library callback: get access to a line of the canvas
+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 line of canvas
+  if (line < mng_priv->height && mng_priv->canvas)
+    return (mng_ptr)(mng_priv->canvas + line * mng_priv->width * 3);
+  else
+    return (mng_ptr)NULL;
+}
+
+// MNG library callback: (a part of) the canvas should be shown
+static mng_bool demux_mng_refresh(mng_handle h_mng,
+                                  mng_uint32 x,
+                                  mng_uint32 y,
+                                  mng_uint32 width,
+                                  mng_uint32 height)
+{
+  // nothing to do here, the image data is already on the canvas
+  // (This function is called by libmng whenever it thinks a part
+  //  of the display should be updated. This can happen multiple
+  //  times for a frame and/or a single tieme for a frame. Only
+  //  the part of the display indicated by x, y, width, height is
+  //  to be updated. It is possible that some parts of the display
+  //  are not updated for many frames. There is no chance here to
+  //  find out if the current frame is done with this update or not.)
+  // a new frame is generated in the demux_mng_fill_buffer() function
+  // whenever the libmng tells us to wait for some time
+  return MNG_TRUE;
+}
+
+// MNG library callback: get how many milliseconds have passed
+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;
+}
+
+// the MNG library wants to be be called again after some milliseconds
+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 MNG library again
+  // in private data
+  mng_priv->timer_ms = msecs;
+  return MNG_TRUE;
+}
+
+// MPlayer callback: check if stream contains MNG data
+static int demux_mng_check_file(demuxer_t *demuxer)
+{
+  char buf[4];
+  if (stream_read(demuxer->stream, buf, 4) != 4)
+    return 0;
+  if (memcmp(buf, "\x8AMNG", 4))
+    return 0;
+  return DEMUXER_TYPE_MNG;
+}
+
+// MPlayer callback: fill buffer from MNG stream
+static int demux_mng_fill_buffer(demuxer_t * demuxer,
+                                 demux_stream_t * ds)
+{
+  mng_priv_t * mng_priv = demuxer->priv;
+  mng_handle h_mng = mng_priv->h_mng;
+  mng_retcode mng_ret;
+  demux_packet_t * dp;
+
+  // exit if animation is finished
+  if (mng_priv->finished)
+    return 0;
+
+  // advance animation to requested next show time
+  while (mng_priv->anim_cur_time_ms + mng_priv->anim_frame_duration_ms
+         <= mng_priv->show_next_time_ms && !mng_priv->finished) {
+
+    // advance global and animation time
+    mng_priv->global_time_ms += mng_priv->anim_frame_duration_ms;
+    mng_priv->anim_cur_time_ms += mng_priv->anim_frame_duration_ms;
+
+    // clear variable MNG library will write number of milliseconds to
+    // (via settimer callback)
+    mng_priv->timer_ms = 0;
+
+    // get next image from MNG library
+    if (mng_priv->displaying)
+      mng_ret = mng_display_resume(h_mng); // resume displaying MNG data
+                                           // to canvas
+    else
+      mng_ret = mng_display(h_mng); // start displaying MNG data to canvas
+    if (mng_ret && mng_ret != MNG_NEEDTIMERWAIT) {
+      mp_msg(MSGT_DEMUX, MSGL_ERR,
+             "demux_mng: could not display MNG data to canvas: "
+             "mng_retcode %d\n", mng_ret);
+      return 0;
+    }
+    mng_priv->displaying = 1; // mng_display() has been called now
+    mng_priv->finished = mng_ret == 0; // animation is finished if and
+                                       // only if mng_display() returned 0
+
+    // save duration of current frame
+    mng_priv->anim_frame_duration_ms = mng_priv->timer_ms < 1
+                                       ? 1 : mng_priv->timer_ms;
+
+  } // while (mng_priv->anim_cur_time_ms + ...
+
+  // create a new demuxer packet
+  dp = new_demux_packet(mng_priv->height * mng_priv->width * 3);
+
+  // copy image data into demuxer packet
+  memcpy(dp->buffer, mng_priv->canvas,
+         mng_priv->height * mng_priv->width * 3);
+
+  // set current show time to requested show time
+  mng_priv->show_cur_time_ms = mng_priv->show_next_time_ms;
+
+  // get time of next frame to show
+  mng_priv->show_next_time_ms = mng_priv->anim_cur_time_ms
+                              + mng_priv->anim_frame_duration_ms;
+
+  // set position and timing information in demuxer video and demuxer packet
+  //  - time must be time of next frame and always be > 0 for the variable
+  //    frame time mechanism (GIF, MATROSKA, MNG) in video.c to work
+  demuxer->video->dpos++;
+  dp->pts = (float)mng_priv->show_next_time_ms / 1000.0f + MNG_START_PTS;
+  dp->pos = stream_tell(demuxer->stream);
+  ds_add_packet(demuxer->video, dp);
+
+  return 1;
+}
+
+// MPlayer callback: open MNG stream
+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));
+
+  // remember pointer to demuxer in private data
+  mng_priv->demuxer = demuxer;
+
+  // 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;
+  }
+
+  // remember handle to MNG image in private data
+  mng_priv->h_mng = h_mng;
+
+  // set 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_RGB8)) {
+    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(24, '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 parameters of video frames
+  sh_video->bih = malloc(sizeof(BITMAPINFOHEADER));
+  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 = 24;
+  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;
+}
+
+// MPlayer callback: close MNG stream
+static void demux_mng_close(demuxer_t* demuxer)
+{
+  mng_priv_t * mng_priv = demuxer->priv;
+
+  if (mng_priv) {
+
+    // shutdown MNG image instance
+    if (mng_priv->h_mng)
+      mng_cleanup(&mng_priv->h_mng);
+
+    // free private data
+    if (mng_priv->canvas)
+      free(mng_priv->canvas);
+
+    free(mng_priv);
+  }
+}
+
+// MPlayer callback: seek in MNG stream
+static void demux_mng_seek(demuxer_t * demuxer, float rel_seek_secs,
+                           float audio_delay, int flags)
+{
+  mng_priv_t * mng_priv = demuxer->priv;
+  mng_handle h_mng = mng_priv->h_mng;
+  mng_retcode mng_ret;
+  int seek_ms, pos_ms;
+
+  // exit if not ready to seek (header not yet read or not yet displaying)
+  if (!mng_priv->header_processed || !mng_priv->displaying)
+    return;
+
+  // get number of milliseconds to seek
+  if (flags & 2) // seek by relative position (0.0 ... 1.0)
+    seek_ms = (int)(rel_seek_secs * (float)mng_priv->total_time_ms);
+  else // seek by time in seconds
+    seek_ms = (int)(rel_seek_secs * 1000.0f + 0.5f);
+
+  // get new position in milliseconds
+  if (flags & 1) // absolute
+    pos_ms = seek_ms;
+  else { // relative
+    pos_ms = mng_priv->show_cur_time_ms + seek_ms;
+  }
+
+  // fix position
+  if (pos_ms < 0)
+    pos_ms = 0;
+  if (pos_ms > mng_priv->total_time_ms)
+    pos_ms = mng_priv->total_time_ms;
+
+  // FIXME
+  // in principle there is a function to seek in MNG: mng_display_gotime()
+  //  - using it did not work out (documentation is very brief,
+  //    example code does not exist?)
+  //  - the following code works, but its performance is quite bad
+
+  // seeking forward
+  if (pos_ms >= mng_priv->show_cur_time_ms) {
+
+    // simply advance show time to seek position
+    //  - everything else will be handled in demux_mng_fill_buffer()
+    mng_priv->show_next_time_ms = pos_ms;
+
+  } // if (pos_ms > mng_priv->show_time_ms)
+
+  // seeking backward
+  else { // if (pos_ms > mng_priv->show_time_ms)
+
+    // clear variable MNG library will write number of milliseconds to
+    // (via settimer callback)
+    mng_priv->timer_ms = 0;
+
+    // restart displaying and advance show time to seek position
+    //  - everything else will be handled in demux_mng_fill_buffer()
+    mng_ret = mng_display_reset(h_mng);
+    if (mng_ret == MNG_NEEDTIMERWAIT) {   // if timer wait is needed,
+      mng_priv->global_time_ms            // fool libmng
+        += mng_priv->timer_ms;            // that requested time passed
+      mng_ret = mng_display_reset(h_mng); // and try again
+    }
+    if (mng_ret) {
+      mp_msg(MSGT_DEMUX, MSGL_ERR,
+             "demux_mng: could not reset MNG display state: "
+             "mng_retcode %d\n", mng_ret);
+      return;
+    }
+    mng_priv->displaying = 0;
+    mng_priv->finished = 0;
+    mng_priv->anim_cur_time_ms = 0;
+    mng_priv->anim_frame_duration_ms = 0;
+    mng_priv->show_next_time_ms = pos_ms;
+
+  } // if (pos_ms > mng_priv->show_time_ms) ... else
+}
+
+// MPlayer callback: control MNG stream
+static int demux_mng_control(demuxer_t * demuxer, int cmd, void * arg)
+{
+  mng_priv_t * mng_priv = demuxer->priv;
+
+  switch(cmd) {
+
+    // get total length of movie
+    case DEMUXER_CTRL_GET_TIME_LENGTH:
+      if (mng_priv->header_processed) {
+        *(double *)arg = (double)mng_priv->total_time_ms / 1000.0;
+        return DEMUXER_CTRL_OK;
+      } else {
+        return DEMUXER_CTRL_DONTKNOW;
+      }
+      break;
+
+    // get position in movie
+    case DEMUXER_CTRL_GET_PERCENT_POS:
+      if (mng_priv->header_processed && mng_priv->total_time_ms > 0) {
+        *(int *)arg = (100 * mng_priv->show_cur_time_ms
+                       + mng_priv->total_time_ms / 2)
+                      / mng_priv->total_time_ms;
+        return DEMUXER_CTRL_OK;
+      } else {
+        return DEMUXER_CTRL_DONTKNOW;
+      }
+      break;
+
+    default:
+      return DEMUXER_CTRL_NOTIMPL;
+
+  } // switch (cmd)
+}
+
+const demuxer_desc_t demuxer_desc_mng = {
+  "MNG demuxer",
+  "mng",
+  "MNG",
+  "Stefan Schuermans <stefan@blinkenarea.org>",
+  "MNG files, using libmng",
+  DEMUXER_TYPE_MNG,
+  0, // unsafe autodetect (only checking magic at beginning of stream)
+  demux_mng_check_file,
+  demux_mng_fill_buffer,
+  demux_mng_open,
+  demux_mng_close,
+  demux_mng_seek,
+  demux_mng_control
+};
+
