/* GStreamer

 * Copyright (C) <2006> Renato Araujo Oliveira Filho <renato.filho@indt.org.br>

 *                      Rosfran Borges <rosfran.borges@indt.org.br>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/* Element-Checklist-Version: 5 */

/**

 * SECTION:element-nuvdemux

 *

 * <refsect2>

 * <para>

 * Demuxes an .nuv file into raw or compressed audio and/or video streams.

 * </para>

 * <para>

 * This element currently only supports pull-based scheduling.

 * </para>

 * <title>Example launch line</title>

 * <para>

 * <programlisting>

 * gst-launch filesrc test.nuv ! nuvdemux name=demux  demux.audio_00 ! decodebin ! audioconvert ! audioresample ! autoaudiosink   demux.video_00 ! queue ! decodebin ! ffmpegcolorspace ! videoscale ! autovideosink

 * </programlisting>

 * Play (parse and decode) an .nuv file and try to output it to

 * an automatically detected soundcard and videosink. If the NUV file contains

 * compressed audio or video data, this will only work if you have the

 * right decoder elements/plugins installed.

 * </para>

 * </refsect2>

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/gsterror.h>

#include <gst/gstplugin.h>

#include <string.h>

#include <math.h>

#include "glib/gi18n.h"

#include "gstnuvdemux.h"

#define GST_NUV_DEMUX_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_NUV_DEMUX, GstNuvDemuxPrivate))

GST_DEBUG_CATEGORY_STATIC(nuvdemux_debug);

#define GST_CAT_DEFAULT nuvdemux_debug

#define GST_FLOW_ERROR_NO_DATA  -101

#define GST_FLOW_ERROR_EOS	-102

enum

{

  NUV_PUSH_MODE = 0,

  NUV_PULL_MODE

};

GST_DEBUG_CATEGORY_EXTERN(GST_CAT_EVENT);

static const GstElementDetails gst_nuv_demux_details =

GST_ELEMENT_DETAILS("Nuv demuxer",

					"Codec/Demuxer",

					"Demultiplex a .nuv file into audio and video",

					"Renato Araujo Oliveira Filho <renato.filho@indt.org.br>,"

					"Rosfran Borges <rosfran.borges@indt.org.br>");

/* file header */

typedef struct

{

  gchar id[12];					/* "NuppelVideo\0" or "MythTVVideo\0" */

  gchar version[5];				/* "x.xx\0" */

  gint i_width;

  gint i_height;

  gint i_width_desired;

  gint i_height_desired;

  gchar i_mode;					/* P progressive, I interlaced */

  gdouble d_aspect;				/* 1.0 squared pixel */

  gdouble d_fps;

 //fps num/denom

  gint i_fpsn;

  gint i_fpsd;

  gint i_video_blocks;			/* 0 no video, -1 unknown */

  gint i_audio_blocks;

  gint i_text_blocks;

  gint i_keyframe_distance;

} nuv_header;

/* frame header */

typedef struct

{

  gchar i_type;					/* A: audio, V: video, S: sync; T: test

								   R: Seekpoint (string:RTjjjjjjjj)

								   D: Extra data for codec */

  gchar i_compression;			/* V: 0 uncompressed

								   1 RTJpeg

								   2 RTJpeg+lzo

								   N black frame

								   L copy last

								   A: 0 uncompressed (44100 1-bits, 2ch)

								   1 lzo

								   2 layer 2

								   3 layer 3

								   F flac

								   S shorten

								   N null frame loudless

								   L copy last

								   S: B audio and vdeo sync point

								   A audio sync info (timecode == effective

								   dsp frequency*100)

								   V next video sync (timecode == next video

								   frame num)

								   S audio,video,text correlation */

  gchar i_keyframe;				/* 0 keyframe, else no no key frame */

  guint8 i_filters;				/* 0x01: gauss 5 pixel (8,2,2,2,2)/16

								   0x02: gauss 5 pixel (8,1,1,1,1)/12

								   0x04: cartoon filter */

  gint32 i_timecode;			/* ms */

  gint i_length;				/* V,A,T: length of following data

								   S: length of packet correl */

} nuv_frame_header;

/* FIXME Not sure of this one */

typedef struct

{

  gint i_version;

  guint32 i_video_fcc;

  guint32 i_audio_fcc;

  gint i_audio_sample_rate;

  gint i_audio_bits_per_sample;

  gint i_audio_channels;

  gint i_audio_compression_ratio;

  gint i_audio_quality;

  gint i_rtjpeg_quality;

  gint i_rtjpeg_luma_filter;

  gint i_rtjpeg_chroma_filter;

  gint i_lavc_bitrate;

  gint i_lavc_qmin;

  gint i_lavc_qmax;

  gint i_lavc_maxqdiff;

  gint64 i_seekable_offset;

  gint64 i_keyframe_adjust_offset;

} nuv_extended_header;

typedef struct

{

  gint64 timecode;

  gint64 offset;

} frame_index_data;

typedef enum

{

  GST_NUV_DEMUX_START,

  GST_NUV_DEMUX_HEADER_DATA,

  GST_NUV_DEMUX_EXTRA_DATA,

  GST_NUV_DEMUX_MPEG_DATA,

  GST_NUV_DEMUX_EXTEND_HEADER,

  GST_NUV_DEMUX_EXTEND_HEADER_DATA,

  GST_NUV_DEMUX_INDEX_CREATE,

  GST_NUV_DEMUX_FRAME_HEADER,

  GST_NUV_DEMUX_MOVI,

  GST_NUV_DEMUX_INVALID_DATA

} GstNuvDemuxState;

struct _GstNuvDemuxPrivate

{

 /* used for indicate the mode */

  guint mode;

 /* used on push mode */

  GstAdapter *adapter;

 /* pads */

  GstPad *sinkpad;

  GstPad *src_video_pad;

  GstPad *src_audio_pad;

 /* Flow control */

  GstFlowReturn last_video_return;

  GstFlowReturn last_audio_return;

  gboolean more_data;

  gboolean eos;

  gboolean new_file;

  guint segment;

 /* NUV decoding state */

  GstNuvDemuxState state;

  guint64 offset;

 /* duration information */

  guint64 duration_bytes;

  guint64 duration_time;

  guint64 segment_stop;

  guint64 segment_start;

 /* segment control info */

  gboolean new_audio_segment;

  gboolean new_video_segment;

 /* Mpeg ExtraData */

  guint64 mpeg_data_size;

  GstBuffer *mpeg_buffer;

 /* Headers */

  nuv_header h;

  nuv_extended_header eh;

  nuv_frame_header fh;

 /* anothers info */

  guint64 header_lengh;

  gint64 time_start;

  gint64 time_diff;

  gint64 time_qos;

  guint64 last_frame_time;

  GSList *index;

};

static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE("sink",

																	GST_PAD_SINK,

																	GST_PAD_ALWAYS,

																	GST_STATIC_CAPS

																	("video/x-nuv"));

static GstStaticPadTemplate audio_src_template =

GST_STATIC_PAD_TEMPLATE("audio_src",

						GST_PAD_SRC,

						GST_PAD_SOMETIMES,

						GST_STATIC_CAPS_ANY);

static GstStaticPadTemplate video_src_template =

GST_STATIC_PAD_TEMPLATE("video_src",

						GST_PAD_SRC,

						GST_PAD_SOMETIMES,

						GST_STATIC_CAPS_ANY);

static void gst_nuv_demux_dispose(GObject * object);

static void gst_nuv_demux_finalize(GObject * object);

static GstStateChangeReturn gst_nuv_demux_change_state(GstElement * element,

													   GstStateChange

													   transition);

static void gst_nuv_demux_loop(GstPad * pad);

static GstFlowReturn gst_nuv_demux_chain(GstPad * pad, GstBuffer * buf);

static GstFlowReturn gst_nuv_demux_play(GstPad * pad);

static gboolean gst_nuv_demux_sink_activate_pull(GstPad * sinkpad,

												 gboolean active);

static gboolean gst_nuv_demux_sink_activate_push(GstPad * pad,

												 gboolean active);

static gboolean gst_nuv_demux_sink_activate(GstPad * sinkpad);

static gboolean gst_nuv_demux_sink_event(GstPad * pad, GstEvent * event);

static gboolean gst_nuv_demux_srcpad_event(GstPad * pad, GstEvent * event);

static frame_index_data *gst_nuv_demux_do_seek_index(GstNuvDemux * nuv,

													 gint64 seek_pos,

													 gint64 segment_stop,

													 GstFormat format);

static GstFlowReturn gst_nuv_demux_move_bytes(GstNuvDemux * nuv,

											  guint64 size);

static GstFlowReturn gst_nuv_demux_read_bytes(GstNuvDemux * nuv, guint64 size,

											  gboolean move,

											  GstBuffer ** buffer);

static void gst_nuv_demux_reset(GstNuvDemux * nuv);

static void gst_nuv_demux_destoy_src_pad(GstNuvDemux * nuv);

static void gst_nuv_demux_send_eos(GstNuvDemux * nuv);

static void gst_nuv_demux_create_seek_index(GstNuvDemux * nuv);

#if (GST_VERSION_MINOR == 10) && (GST_VERSION_MICRO < 6)

GstBuffer *gst_adapter_take_buffer(GstAdapter * adapter, guint nbytes);

#endif

GST_BOILERPLATE(GstNuvDemux, gst_nuv_demux, GstElement, GST_TYPE_ELEMENT);

/******************************************************************************

 * Utils function

 ******************************************************************************/

#if G_BYTE_ORDER == G_BIG_ENDIAN

static inline gdouble

_gdouble_swap_le_be(gdouble * d)

{

  union

  {

	guint64 i;

	gdouble d;

  } u;

  u.d = *d;

  u.i = GUINT64_SWAP_LE_BE(u.i);

  return u.d;

}

#define READ_DOUBLE_FROM_LE(d) (_gdouble_swap_le_be((gdouble* ) d))

#else /* G_BYTE_ORDER != G_BIG_ENDIAN */

#define READ_DOUBLE_FROM_LE(d) *((gdouble* ) (d))

#endif /* G_BYTE_ORDER != G_BIG_ENDIAN */

static void

double2fraction(double in, int *num, int *denom)

{

  if (in == 29.97)

	{

	  *num = 30000;

	  *denom = 1001;

	}

  else if (in == 23.976)

	{

	  *num = 24000;

	  *denom = 1001;

	}

  else

	{

	  *denom = 1;

	  while (in - floor(in) >= 0.1)

		{

		  *denom *= 10;

		  in *= 10.0;

		}

	  *num = (int) floor(in);

	}

}

/* GObject Functions */

static void

gst_nuv_demux_base_init(gpointer klass)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS(klass);

  gst_element_class_add_pad_template(element_class,

									 gst_static_pad_template_get

									 (&audio_src_template));

  gst_element_class_add_pad_template(element_class,

									 gst_static_pad_template_get

									 (&video_src_template));

  gst_element_class_add_pad_template(element_class,

									 gst_static_pad_template_get

									 (&sink_template));

  gst_element_class_set_details(element_class, &gst_nuv_demux_details);

}

static void

gst_nuv_demux_class_init(GstNuvDemuxClass * klass)

{

  GstElementClass *gstelement_class = GST_ELEMENT_CLASS(klass);

  GObjectClass *gobject_class = (GObjectClass *) klass;

  GST_DEBUG_CATEGORY_INIT(nuvdemux_debug, "nuvdemux",

						  0, "Demuxer for NUV streams");

  parent_class = g_type_class_peek_parent(klass);

  gobject_class->dispose = gst_nuv_demux_dispose;

  gobject_class->finalize = gst_nuv_demux_finalize;

  gstelement_class->change_state = gst_nuv_demux_change_state;

  g_type_class_add_private(gobject_class, sizeof(GstNuvDemuxPrivate));

}

static void

gst_nuv_demux_init(GstNuvDemux * nuv, GstNuvDemuxClass * nuv_class)

{

  nuv->priv = GST_NUV_DEMUX_GET_PRIVATE(nuv);

  nuv->priv->sinkpad =

	gst_pad_new_from_static_template(&sink_template, "sink");

 /* creating adapter */

  nuv->priv->mode = NUV_PUSH_MODE;

  nuv->priv->adapter = gst_adapter_new();

  nuv->priv->new_audio_segment = TRUE;

  nuv->priv->new_video_segment = TRUE;

  gst_pad_set_activate_function(nuv->priv->sinkpad,

								gst_nuv_demux_sink_activate);

  gst_pad_set_activatepull_function(nuv->priv->sinkpad,

									gst_nuv_demux_sink_activate_pull);

  gst_pad_set_activatepush_function(nuv->priv->sinkpad,

									gst_nuv_demux_sink_activate_push);

  gst_pad_set_chain_function(nuv->priv->sinkpad,

							 GST_DEBUG_FUNCPTR(gst_nuv_demux_chain));

  gst_pad_set_event_function(nuv->priv->sinkpad,

							 GST_DEBUG_FUNCPTR(gst_nuv_demux_sink_event));

  gst_element_add_pad(GST_ELEMENT(nuv), nuv->priv->sinkpad);

}

static void

gst_nuv_demux_dispose(GObject * object)

{

  GstNuvDemux *nuv = GST_NUV_DEMUX(object);

  if (nuv->priv->mpeg_buffer != NULL)

	{

	  gst_buffer_unref(nuv->priv->mpeg_buffer);

	}

  gst_nuv_demux_reset(GST_NUV_DEMUX(object));

  gst_nuv_demux_destoy_src_pad(GST_NUV_DEMUX(object));

  if (nuv->priv->adapter != NULL)

	{

	  gst_object_unref(nuv->priv->adapter);

	}

}

static void

gst_nuv_demux_finalize(GObject * object)

{

  G_OBJECT_CLASS(parent_class)->finalize(object);

}

/* HeaderLoad:

 */

static GstFlowReturn

gst_nuv_demux_header_load(GstNuvDemux * nuv, nuv_header * h)

{

  GstBuffer *buffer = NULL;

  GstFlowReturn res = gst_nuv_demux_read_bytes(nuv, 72, TRUE, &buffer);

  if ((res != GST_FLOW_OK) || (buffer == NULL))

	{

	  goto done;

	}

  if (h != NULL)

	{

	  memcpy(h->id, buffer->data, 12);

	  memcpy(h->version, buffer->data + 12, 5);

	  h->i_width = GST_READ_UINT32_LE(&buffer->data[20]);

	  h->i_height = GST_READ_UINT32_LE(&buffer->data[24]);

	  h->i_width_desired = GST_READ_UINT32_LE(&buffer->data[28]);

	  h->i_height_desired = GST_READ_UINT32_LE(&buffer->data[32]);

	  h->i_mode = GPOINTER_TO_INT(buffer->data[36]);

	  h->d_aspect = READ_DOUBLE_FROM_LE(&buffer->data[40]);

	  h->d_fps = READ_DOUBLE_FROM_LE(&buffer->data[48]);

	 /* get the num and denom values from fps */

	  double2fraction(h->d_fps, &h->i_fpsn, &h->i_fpsd);

	  h->i_video_blocks = GST_READ_UINT32_LE(&buffer->data[56]);

	  h->i_audio_blocks = GST_READ_UINT32_LE(&buffer->data[60]);

	  h->i_text_blocks = GST_READ_UINT32_LE(&buffer->data[64]);

	  h->i_keyframe_distance = GST_READ_UINT32_LE(&buffer->data[68]);

	  GST_DEBUG_OBJECT(nuv,

					   "nuv: h=%s v=%s %dx%d a=%f fps=%f v=%d a=%d t=%d kfd=%d",

					   h->id, h->version, h->i_width, h->i_height,

					   h->d_aspect, h->d_fps, h->i_video_blocks,

					   h->i_audio_blocks, h->i_text_blocks,

					   h->i_keyframe_distance);

	}

done:

  if (buffer != NULL)

	{

	  gst_buffer_unref(buffer);

	  buffer = NULL;

	}

  return res;

}

static GstFlowReturn

gst_nuv_demux_stream_header_data(GstNuvDemux * nuv)

{

  GstFlowReturn res;

  if (nuv->priv->new_file)

	res = gst_nuv_demux_header_load(nuv, NULL);

  else

	res = gst_nuv_demux_header_load(nuv, &nuv->priv->h);

  if (res == GST_FLOW_OK)

	nuv->priv->state = GST_NUV_DEMUX_EXTRA_DATA;

  return res;

}

/*

 * Read NUV file tag

 */

static GstFlowReturn

gst_nuv_demux_stream_file_header(GstNuvDemux * nuv)

{

  GstFlowReturn res = GST_FLOW_OK;

  GstBuffer *file_header = NULL;

  res = gst_nuv_demux_read_bytes(nuv, 12, FALSE, &file_header);

  if (res == GST_FLOW_OK)

	{

	  if (strncmp((gchar *) file_header->data, "MythTVVideo", 11) ||

		  strncmp((gchar *) file_header->data, "NuppelVideo", 11))

		{

		  nuv->priv->state = GST_NUV_DEMUX_HEADER_DATA;

		}

	  else

		{

		  GST_DEBUG_OBJECT(nuv, "error parsing file header");

		  nuv->priv->state = GST_NUV_DEMUX_INVALID_DATA;

		  res = GST_FLOW_ERROR;

		}

	}

  if (file_header != NULL)

	{

	  gst_buffer_unref(file_header);

	  file_header = NULL;

	}

  return res;

}

/* FrameHeaderLoad:

 */

static GstFlowReturn

gst_nuv_demux_frame_header_load(GstNuvDemux * nuv, nuv_frame_header * h)

{

  unsigned char *data;

  GstBuffer *buf = NULL;

  GstFlowReturn res = gst_nuv_demux_read_bytes(nuv, 12, TRUE, &buf);

  if ((res != GST_FLOW_OK) || (buf == NULL))

	{

	  goto done;

	}

  if (h == NULL)

	goto done;

  data = buf->data;

  h->i_type = GPOINTER_TO_INT(data[0]);

  h->i_compression = GPOINTER_TO_INT(data[1]);

  h->i_keyframe = GPOINTER_TO_INT(data[2]);

  h->i_filters = GPOINTER_TO_INT(data[3]);

  h->i_timecode = GST_READ_UINT32_LE(&data[4]);

  h->i_length = GST_READ_UINT32_LE(&data[8]);

  GST_DEBUG_OBJECT(nuv, "frame hdr: t=%c c=%c k=%d f=0x%x timecode=%d l=%d",

				   h->i_type,

				   h->i_compression ? h->i_compression : ' ',

				   h->i_keyframe ? h->i_keyframe : ' ',

				   h->i_filters, h->i_timecode, h->i_length);

done:

  if (buf != NULL)

	{

	  gst_buffer_unref(buf);

	  buf = NULL;

	}

  return res;

}

static GstFlowReturn

gst_nuv_demux_extended_header_load(GstNuvDemux * nuv, nuv_extended_header * h)

{

  unsigned char *data;

  GstBuffer *buff = NULL;

  GstFlowReturn res = gst_nuv_demux_read_bytes(nuv, 512, TRUE, &buff);

  if ((res != GST_FLOW_OK) || (buff == NULL))

	{

	  goto done;

	}

  if (h == NULL)

	goto done;

  data = buff->data;

  h->i_version = GST_READ_UINT32_LE(&data[0]);

  h->i_video_fcc = GST_MAKE_FOURCC(data[4], data[5], data[6], data[7]);

  h->i_audio_fcc = GST_MAKE_FOURCC(data[8], data[9], data[10], data[11]);

  h->i_audio_sample_rate = GST_READ_UINT32_LE(&data[12]);

  h->i_audio_bits_per_sample = GST_READ_UINT32_LE(&data[16]);

  h->i_audio_channels = GST_READ_UINT32_LE(&data[20]);

  h->i_audio_compression_ratio = GST_READ_UINT32_LE(&data[24]);

  h->i_audio_quality = GST_READ_UINT32_LE(&data[28]);

  h->i_rtjpeg_quality = GST_READ_UINT32_LE(&data[32]);

  h->i_rtjpeg_luma_filter = GST_READ_UINT32_LE(&data[36]);

  h->i_rtjpeg_chroma_filter = GST_READ_UINT32_LE(&data[40]);

  h->i_lavc_bitrate = GST_READ_UINT32_LE(&data[44]);

  h->i_lavc_qmin = GST_READ_UINT32_LE(&data[48]);

  h->i_lavc_qmin = GST_READ_UINT32_LE(&data[52]);

  h->i_lavc_maxqdiff = GST_READ_UINT32_LE(&data[56]);

  h->i_seekable_offset = GST_READ_UINT64_LE(&data[60]);

  h->i_keyframe_adjust_offset = GST_READ_UINT64_LE(&data[68]);

  GST_DEBUG_OBJECT(nuv,

				   "ex hdr: v=%d vffc=%4.4s afcc=%4.4s %dHz %dbits ach=%d acr=%d aq=%d"

				   "rtjpeg q=%d lf=%d lc=%d lavc br=%d qmin=%d qmax=%d maxqdiff=%d seekableoff=%lld keyfao=%lld",

				   h->i_version, (gchar *) & h->i_video_fcc,

				   (gchar *) & h->i_audio_fcc, h->i_audio_sample_rate,

				   h->i_audio_bits_per_sample, h->i_audio_channels,

				   h->i_audio_compression_ratio, h->i_audio_quality,

				   h->i_rtjpeg_quality, h->i_rtjpeg_luma_filter,

				   h->i_rtjpeg_chroma_filter, h->i_lavc_bitrate,

				   h->i_lavc_qmin, h->i_lavc_qmax, h->i_lavc_maxqdiff,

				   h->i_seekable_offset, h->i_keyframe_adjust_offset);

done:

  if (buff != NULL)

	{

	  gst_buffer_unref(buff);

	  buff = NULL;

	}

  return res;

}

/* Query Functions */

static const GstQueryType *

gst_nuv_demux_get_src_query_types(GstPad * pad)

{

  static const GstQueryType src_types[] = {

	GST_QUERY_POSITION,

	GST_QUERY_DURATION,

	0

  };

  return src_types;

}

static gboolean

gst_nuv_demux_handle_src_query(GstPad * pad, GstQuery * query)

{

  gboolean res = FALSE;

  GstNuvDemux *nuv = GST_NUV_DEMUX(gst_pad_get_parent(pad));

  switch (GST_QUERY_TYPE(query))

	{

	case GST_QUERY_POSITION:

	  {

		GstFormat format;

		gst_query_parse_position(query, &format, NULL);

		switch (format)

		  {

		  case GST_FORMAT_TIME:

			if (GST_CLOCK_TIME_IS_VALID(nuv->priv->last_frame_time))

			  {

				gst_query_set_position(query, GST_FORMAT_TIME,

									   nuv->priv->last_frame_time);

				res = TRUE;

			  }

			break;

		  default:

			break;

		  }

		break;

	  }

	case GST_QUERY_DURATION:

	  {

		GstFormat format;

		gst_query_parse_duration(query, &format, NULL);

		switch (format)

		  {

		  case GST_FORMAT_TIME:

			if (nuv->priv->duration_time != GST_CLOCK_TIME_NONE)

			  {

				gst_query_set_duration(query, GST_FORMAT_TIME,

									   nuv->priv->duration_time);

				res = TRUE;

			  }

			break;

		  default:

			break;

		  }

		break;

	  }

	default:

	  break;

	}

  if (res == FALSE)

	{

	  res = gst_pad_query_default(pad, query);

	}

  gst_object_unref(nuv);

  return res;

}

static GstPad *

gst_nuv_demux_create_pad(GstNuvDemux * nuv, GstCaps * caps,

						 GstStaticPadTemplate * template, const gchar * name)

{

  GstPad *pad = NULL;

  pad = gst_pad_new_from_static_template(template, name);

  gst_pad_set_caps(pad, caps);

  gst_pad_set_active(pad, TRUE);

  gst_pad_use_fixed_caps(pad);

  gst_element_add_pad(GST_ELEMENT(nuv), pad);

  gst_pad_set_event_function(pad,

							 GST_DEBUG_FUNCPTR(gst_nuv_demux_srcpad_event));

  gst_pad_set_query_type_function(pad,

								  GST_DEBUG_FUNCPTR

								  (gst_nuv_demux_get_src_query_types));

  gst_pad_set_query_function(pad,

							 GST_DEBUG_FUNCPTR

							 (gst_nuv_demux_handle_src_query));

  return pad;

}

static void

gst_nuv_demux_create_pads(GstNuvDemux * nuv)

{

  if (nuv->priv->h.i_video_blocks != 0)

	{

	  GstCaps *video_caps = NULL;

	  video_caps = gst_caps_new_simple("video/x-divx",

									   "divxversion", G_TYPE_INT, 4,

									   "width", G_TYPE_INT,

									   nuv->priv->h.i_width, "height",

									   G_TYPE_INT, nuv->priv->h.i_height,

									   "framerate", GST_TYPE_FRACTION,

									   nuv->priv->h.i_fpsn,

									   nuv->priv->h.i_fpsd, "format",

									   GST_TYPE_FOURCC,

									   nuv->priv->eh.i_video_fcc,

									   "pixel-aspect-ratio",

									   GST_TYPE_FRACTION,

									   (gint) (nuv->priv->h.d_aspect *

											   1000.0f), 1000, NULL);

	  nuv->priv->src_video_pad =

		gst_nuv_demux_create_pad(nuv, video_caps, &video_src_template,

								 "video_src");

	  gst_caps_unref(video_caps);

	}

  if (nuv->priv->h.i_audio_blocks != 0)

	{

	  GstCaps *audio_caps = NULL;

	  audio_caps = gst_caps_new_simple("audio/mpeg", "rate", G_TYPE_INT, nuv->priv->eh.i_audio_sample_rate, "format", GST_TYPE_FOURCC, nuv->priv->eh.i_audio_fcc, "channels", G_TYPE_INT, nuv->priv->eh.i_audio_channels, "layer", G_TYPE_INT, 3,	// fixme: magic number

									   "mpegversion", G_TYPE_INT,

									   nuv->priv->eh.i_version, NULL);

	  nuv->priv->src_audio_pad =

		gst_nuv_demux_create_pad(nuv, audio_caps, &audio_src_template,

								 "audio_src");

	  gst_caps_unref(audio_caps);

	}

  gst_element_no_more_pads(GST_ELEMENT(nuv));

}

static gboolean

gst_nuv_demux_validate_header(nuv_frame_header * h)

{

  gboolean valid = FALSE;

 //g_usleep (1 * G_USEC_PER_SEC );

  switch (h->i_type)

	{

/*

    case 'V':

      if (h->i_compression == 0 ||

          h->i_compression == 1 ||

          h->i_compression == 2 ||

          h->i_compression == 'N' ||

          h->i_compression == 'L') {

         valid = TRUE;

      }

      break;

    case 'A':

      if (h->i_compression == 0 ||

          h->i_compression == 1 ||

          h->i_compression == 2 ||

          h->i_compression == 3 ||

          h->i_compression == 'F' ||

          h->i_compression == 'S' ||

          h->i_compression == 'N' ||

          h->i_compression == 'L') {

         valid = TRUE;

      }

      break;

    case 'S':

      if (h->i_compression == 'B' ||

          h->i_compression == 'A' ||

          h->i_compression == 'V' ||

          h->i_compression == 'S') {

         valid = TRUE;

      }

      break;

*/

	case 'A':

	case 'V':

	case 'S':

	case 'R':

	case 'D':

	case 'Q':

	  valid = TRUE;

	  break;

	default:

	  valid = FALSE;

	}

  return valid;

}

static GstFlowReturn

gst_nuv_demux_read_head_frame(GstNuvDemux * nuv)

{

  GstFlowReturn ret = GST_FLOW_OK;

  gboolean valid = FALSE;

  do

	{

	  ret = gst_nuv_demux_frame_header_load(nuv, &nuv->priv->fh);

	  if (ret != GST_FLOW_OK)

		{

		  return ret;

		}

	  if (gst_nuv_demux_validate_header(&nuv->priv->fh) == TRUE)

		valid = TRUE;

	}

  while (valid == FALSE);

  nuv->priv->state = GST_NUV_DEMUX_MOVI;

  return ret;

}

static gboolean

gst_nuv_combine_flow(GstNuvDemux * nuv)

{

  GstFlowReturn ret_video = nuv->priv->last_video_return;

  GstFlowReturn ret_audio = nuv->priv->last_audio_return;

  if ((ret_video != GST_FLOW_OK) && (ret_audio != GST_FLOW_OK))

	return FALSE;

  if (GST_FLOW_IS_FATAL(ret_video))

	return FALSE;

  if (GST_FLOW_IS_FATAL(ret_audio))

	return FALSE;

  return TRUE;

}

static GstFlowReturn

gst_nuv_demux_stream_data(GstNuvDemux * nuv)

{

  GstFlowReturn ret = GST_FLOW_OK;

  GstPad *pad = NULL;

  guint64 timestamp;

  GstBuffer *buf = NULL;

  nuv_frame_header h;

  h = nuv->priv->fh;

  if (h.i_type == 'R')

	{

	  goto done;

	}

  if (h.i_length > 0)

	{

	  ret = gst_nuv_demux_read_bytes(nuv, h.i_length, TRUE, &buf);

	  if ((ret != GST_FLOW_OK) || (buf == NULL))

		{

		  goto done;

		}

	  if ((h.i_timecode < 0))

		{

		  h.i_timecode = 0;

		 //goto done;

		}

	  timestamp = h.i_timecode * GST_MSECOND;

	  GST_BUFFER_TIMESTAMP(buf) = timestamp;

	}

  else

	{

	  goto done;

	}

  switch (h.i_type)

	{

	case 'V':

	  {

		pad = nuv->priv->src_video_pad;

		if (nuv->priv->new_video_segment)

		  {

		   /* send new segment event */

			gst_pad_push_event(nuv->priv->src_video_pad,

							   gst_event_new_new_segment(TRUE, 1.0,

														 GST_FORMAT_TIME, 0,

														 GST_CLOCK_TIME_NONE,

														 0));

			if (nuv->priv->time_start == GST_CLOCK_TIME_NONE)

			  {

				nuv->priv->time_start = timestamp;

			  }

			nuv->priv->new_video_segment = FALSE;

		  }

		break;

	  }

	case 'A':

	  {

		pad = nuv->priv->src_audio_pad;

		if (nuv->priv->new_audio_segment)

		  {

		   /* send new segment event */

			gst_pad_push_event(nuv->priv->src_audio_pad,

							   gst_event_new_new_segment(TRUE, 1.0,

														 GST_FORMAT_TIME, 0,

														 GST_CLOCK_TIME_NONE,

														 0));

			if (nuv->priv->time_start == GST_CLOCK_TIME_NONE)

			  {

				nuv->priv->time_start = timestamp;

			  }

			nuv->priv->new_audio_segment = FALSE;

		  }

		break;

	  }

	case 'S':

	  {

		switch (h.i_compression)

		  {

		  case 'V':

			GST_DEBUG_OBJECT(nuv, "sending new video segment: %d",

							 h.i_timecode);

			gst_pad_push_event(nuv->priv->src_video_pad,

							   gst_event_new_new_segment(TRUE, 1.0,

														 GST_FORMAT_TIME,

														 h.i_timecode *

														 GST_MSECOND,

														 GST_CLOCK_TIME_NONE,

														 0));

			break;

		  case 'A':

			GST_DEBUG_OBJECT(nuv, "sending new audio segment: %d",

							 h.i_timecode);

			gst_pad_push_event(nuv->priv->src_audio_pad,

							   gst_event_new_new_segment(TRUE, 1.0,

														 GST_FORMAT_TIME, 0,

														 GST_CLOCK_TIME_NONE,

														 0));

			break;

		  default:

			break;

		  }