summaryrefslogtreecommitdiff
path: root/sys/vdpau
diff options
context:
space:
mode:
Diffstat (limited to 'sys/vdpau')
-rw-r--r--sys/vdpau/Makefile.am10
-rw-r--r--sys/vdpau/gstvdpau.c3
-rw-r--r--sys/vdpau/mpeg4/gstmpeg4frame.c109
-rw-r--r--sys/vdpau/mpeg4/gstmpeg4frame.h64
-rw-r--r--sys/vdpau/mpeg4/gstvdpmpeg4dec.c483
-rw-r--r--sys/vdpau/mpeg4/gstvdpmpeg4dec.h62
-rw-r--r--sys/vdpau/mpeg4/mpeg4util.c466
-rw-r--r--sys/vdpau/mpeg4/mpeg4util.h179
8 files changed, 1374 insertions, 2 deletions
diff --git a/sys/vdpau/Makefile.am b/sys/vdpau/Makefile.am
index 658183eeb..dabba0896 100644
--- a/sys/vdpau/Makefile.am
+++ b/sys/vdpau/Makefile.am
@@ -13,7 +13,10 @@ libgstvdpau_la_SOURCES = \
h264/gsth264parser.c \
h264/gsth264frame.c \
h264/gsth264dpb.c \
- h264/gstvdph264dec.c
+ h264/gstvdph264dec.c \
+ mpeg4/mpeg4util.c \
+ mpeg4/gstmpeg4frame.c \
+ mpeg4/gstvdpmpeg4dec.c
libgstvdpau_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_CFLAGS) $(X11_CFLAGS) $(VDPAU_CFLAGS)
@@ -36,4 +39,7 @@ noinst_HEADERS = \
h264/gsth264parser.h \
h264/gsth264frame.h \
h264/gsth264dpb.h \
- h264/gstvdph264dec.h \ No newline at end of file
+ h264/gstvdph264dec.h \
+ mpeg4/mpeg4util.h \
+ mpeg4/gstmpeg4frame.h \
+ mpeg4/gstvdpmpeg4dec.h
diff --git a/sys/vdpau/gstvdpau.c b/sys/vdpau/gstvdpau.c
index 5a8383c75..a8bd629d7 100644
--- a/sys/vdpau/gstvdpau.c
+++ b/sys/vdpau/gstvdpau.c
@@ -9,6 +9,7 @@
#include "mpeg/gstvdpmpegdec.h"
#include "h264/gstvdph264dec.h"
+#include "mpeg4/gstvdpmpeg4dec.h"
#include "gstvdpvideopostprocess.h"
#include "gstvdpsink.h"
@@ -23,6 +24,8 @@ vdpau_init (GstPlugin * vdpau_plugin)
GST_RANK_NONE, GST_TYPE_VDP_MPEG_DEC);
gst_element_register (vdpau_plugin, "vdpauh264dec",
GST_RANK_NONE, GST_TYPE_VDP_H264_DEC);
+ gst_element_register (vdpau_plugin, "vdpaumpeg4dec",
+ GST_RANK_NONE, GST_TYPE_VDP_MPEG4_DEC);
gst_element_register (vdpau_plugin, "vdpauvideopostprocess",
GST_RANK_NONE, GST_TYPE_VDP_VIDEO_POST_PROCESS);
gst_element_register (vdpau_plugin, "vdpausink",
diff --git a/sys/vdpau/mpeg4/gstmpeg4frame.c b/sys/vdpau/mpeg4/gstmpeg4frame.c
new file mode 100644
index 000000000..26ac896c1
--- /dev/null
+++ b/sys/vdpau/mpeg4/gstmpeg4frame.c
@@ -0,0 +1,109 @@
+/*
+* GStreamer
+* Copyright (C) 2009 Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>
+*
+* 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.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstmpeg4frame.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_mpeg4_frame_debug);
+#define GST_CAT_DEFAULT gst_mpeg4_frame_debug
+
+#define DEBUG_INIT(bla) \
+GST_DEBUG_CATEGORY_INIT (gst_mpeg4_frame_debug, "gstmpeg4frame", 0, "Mpeg4 Frame");
+
+GstMpeg4Frame *
+gst_mpeg4_frame_new (void)
+{
+ GstMpeg4Frame *frame;
+
+ frame = (GstMpeg4Frame *) gst_mini_object_new (GST_TYPE_MPEG4_FRAME);
+
+ return frame;
+}
+
+static GObjectClass *gst_mpeg4_frame_parent_class;
+
+static void
+gst_mpeg4_frame_finalize (GstMpeg4Frame * mpeg4_frame)
+{
+ if (mpeg4_frame->vos_buf)
+ gst_buffer_unref (mpeg4_frame->vos_buf);
+
+ if (mpeg4_frame->vo_buf)
+ gst_buffer_unref (mpeg4_frame->vo_buf);
+
+ if (mpeg4_frame->vol_buf)
+ gst_buffer_unref (mpeg4_frame->vol_buf);
+
+ if (mpeg4_frame->gov_buf)
+ gst_buffer_unref (mpeg4_frame->gov_buf);
+
+ if (mpeg4_frame->vop_buf)
+ gst_buffer_unref (mpeg4_frame->vop_buf);
+
+
+ GST_MINI_OBJECT_CLASS (gst_mpeg4_frame_parent_class)->finalize
+ (GST_MINI_OBJECT (mpeg4_frame));
+}
+
+static void
+gst_mpeg4_frame_init (GstMpeg4Frame * mpeg4_frame, gpointer g_class)
+{
+}
+
+static void
+gst_mpeg4_frame_class_init (gpointer g_class, gpointer class_data)
+{
+ GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);
+
+ gst_mpeg4_frame_parent_class = g_type_class_peek_parent (g_class);
+
+ mini_object_class->finalize = (GstMiniObjectFinalizeFunction)
+ gst_mpeg4_frame_finalize;
+}
+
+
+GType
+gst_mpeg4_frame_get_type (void)
+{
+ static GType _gst_mpeg4_frame_type = 0;
+
+ if (G_UNLIKELY (_gst_mpeg4_frame_type == 0)) {
+ static const GTypeInfo info = {
+ sizeof (GstMpeg4FrameClass),
+ NULL,
+ NULL,
+ gst_mpeg4_frame_class_init,
+ NULL,
+ NULL,
+ sizeof (GstMpeg4Frame),
+ 0,
+ (GInstanceInitFunc) gst_mpeg4_frame_init,
+ NULL
+ };
+ _gst_mpeg4_frame_type = g_type_register_static (GST_TYPE_VIDEO_FRAME,
+ "GstMpeg4Frame", &info, 0);
+
+ DEBUG_INIT ();
+ }
+ return _gst_mpeg4_frame_type;
+}
diff --git a/sys/vdpau/mpeg4/gstmpeg4frame.h b/sys/vdpau/mpeg4/gstmpeg4frame.h
new file mode 100644
index 000000000..3bcbd05bd
--- /dev/null
+++ b/sys/vdpau/mpeg4/gstmpeg4frame.h
@@ -0,0 +1,64 @@
+/*
+* GStreamer
+* Copyright (C) 2009 Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>
+*
+* 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.
+*/
+
+#ifndef _GST_MPEG4_FRAME_H_
+#define _GST_MPEG4_FRAME_H_
+
+#include <gst/gst.h>
+
+#include "../basevideodecoder/gstvideoframe.h"
+
+#include "mpeg4util.h"
+
+#define GST_TYPE_MPEG4_FRAME (gst_mpeg4_frame_get_type())
+#define GST_IS_MPEG4_FRAME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MPEG4_FRAME))
+#define GST_MPEG4_FRAME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_MPEG4_FRAME, GstMpeg4Frame))
+#define GST_MPEG4_FRAME_CAST(obj) ((GstMpeg4Frame *)obj)
+
+#define GST_MPEG4_FRAME_GOT_PRIMARY GST_VIDEO_FRAME_FLAG_LAST
+
+typedef struct _GstMpeg4Frame GstMpeg4Frame;
+typedef struct _GstMpeg4FrameClass GstMpeg4FrameClass;
+
+struct _GstMpeg4Frame
+{
+ GstVideoFrame video_frame;
+
+ GstBuffer *vos_buf;
+ GstBuffer *vo_buf;
+ GstBuffer *vol_buf;
+ GstBuffer *gov_buf;
+ GstBuffer *vop_buf;
+
+ GstClockTime vop_time;
+};
+
+struct _GstMpeg4FrameClass
+{
+ GstVideoFrameClass video_frame_class;
+};
+
+
+
+GstMpeg4Frame *gst_mpeg4_frame_new (void);
+
+GType gst_mpeg4_frame_get_type (void);
+
+#endif \ No newline at end of file
diff --git a/sys/vdpau/mpeg4/gstvdpmpeg4dec.c b/sys/vdpau/mpeg4/gstvdpmpeg4dec.c
new file mode 100644
index 000000000..abb5f43a3
--- /dev/null
+++ b/sys/vdpau/mpeg4/gstvdpmpeg4dec.c
@@ -0,0 +1,483 @@
+/*
+ * GStreamer
+ * Copyright (C) 2009 Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>
+ *
+ * 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.
+ */
+
+/**
+ * SECTION:element-vdpaumpeg4dec
+ *
+ * FIXME:Describe vdpaumpeg4dec here.
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch -v -m fakesrc ! vdpaumpeg4dec ! fakesink silent=TRUE
+ * ]|
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gst/gst.h>
+#include <vdpau/vdpau.h>
+#include <string.h>
+
+#include "gstvdpmpeg4dec.h"
+
+GST_DEBUG_CATEGORY (gst_vdp_mpeg4_dec_debug);
+#define GST_CAT_DEFAULT gst_vdp_mpeg4_dec_debug
+
+/* the capabilities of the inputs and outputs.
+ *
+ * describe the real formats here.
+ */
+static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
+ GST_PAD_SINK,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("video/mpeg, mpegversion = (int) 4, "
+ "systemstream = (boolean) false; "
+ "video/x-divx, divxversion = (int) [4, 5]; " "video/x-xvid"));
+
+#define DEBUG_INIT(bla) \
+ GST_DEBUG_CATEGORY_INIT (gst_vdp_mpeg4_dec_debug, "vdpaumpeg4dec", 0, \
+ "VDPAU mpeg4 decoder");
+
+GST_BOILERPLATE_FULL (GstVdpMpeg4Dec, gst_vdp_mpeg4_dec,
+ GstVdpDecoder, GST_TYPE_VDP_DECODER, DEBUG_INIT);
+
+#define SYNC_CODE_SIZE 3
+
+static VdpPictureInfoMPEG4Part2
+gst_vdp_mpeg4_dec_fill_info (GstVdpMpeg4Dec * mpeg4_dec,
+ GstMpeg4Frame * mpeg4_frame, Mpeg4VideoObjectPlane * vop)
+{
+ Mpeg4VideoObjectLayer *vol;
+ VdpPictureInfoMPEG4Part2 info;
+
+ vol = &mpeg4_dec->vol;
+
+ info.forward_reference = VDP_INVALID_HANDLE;
+ info.backward_reference = VDP_INVALID_HANDLE;
+
+ /* forward reference */
+ if (vop->coding_type != I_VOP && mpeg4_dec->f_frame) {
+ info.forward_reference =
+ GST_VDP_VIDEO_BUFFER (GST_VIDEO_FRAME (mpeg4_dec->
+ f_frame)->src_buffer)->surface;
+ }
+
+ if (vop->coding_type == B_VOP) {
+ guint32 p_field_period;
+ gint32 trd, trb;
+
+ p_field_period = mpeg4_dec->f_frame->vop_time / mpeg4_dec->tframe;
+
+ trd =
+ 2 * (mpeg4_dec->b_frame->vop_time / mpeg4_dec->tframe - p_field_period);
+ trb = 2 * (mpeg4_frame->vop_time / mpeg4_dec->tframe - p_field_period);
+
+ info.trd[0] = trd;
+ info.trd[1] = trd;
+ info.trb[0] = trb;
+ info.trb[1] = trb;
+
+ /* backward reference */
+ if (mpeg4_dec->b_frame) {
+ info.forward_reference =
+ GST_VDP_VIDEO_BUFFER (GST_VIDEO_FRAME (mpeg4_dec->
+ f_frame)->src_buffer)->surface;
+ }
+ }
+
+ memcpy (info.intra_quantizer_matrix, vol->intra_quant_mat, 64);
+ memcpy (info.non_intra_quantizer_matrix, vol->non_intra_quant_mat, 64);
+
+ info.vop_time_increment_resolution = vol->vop_time_increment_resolution;
+ info.resync_marker_disable = vol->resync_marker_disable;
+ info.interlaced = vol->interlaced;
+ info.quant_type = vol->quant_type;
+ info.quarter_sample = vol->quarter_sample;
+ /* FIXME: support short video header */
+ info.short_video_header = FALSE;
+
+ info.vop_coding_type = vop->coding_type;
+ info.vop_fcode_forward = vop->fcode_forward;
+ info.vop_fcode_backward = vop->fcode_backward;
+ info.rounding_control = vop->rounding_type;
+ info.alternate_vertical_scan_flag = vop->alternate_vertical_scan_flag;
+ info.top_field_first = vop->top_field_first;
+
+ return info;
+}
+
+static gboolean
+gst_vdp_mpeg4_dec_handle_configuration (GstVdpMpeg4Dec * mpeg4_dec,
+ GstMpeg4Frame * mpeg4_frame)
+{
+ Mpeg4VisualObjectSequence vos;
+ Mpeg4VisualObject vo;
+ Mpeg4VideoObjectLayer vol;
+
+ GstVideoState state;
+ guint8 profile_indication;
+ VdpDecoderProfile profile;
+
+ GstFlowReturn ret;
+
+ if (mpeg4_dec->is_configured)
+ return GST_FLOW_OK;
+
+ if (!mpeg4_frame->vos_buf || !mpeg4_frame->vo_buf || !mpeg4_frame->vol_buf)
+ goto skip_frame;
+
+ if (!mpeg4_util_parse_VOS (mpeg4_frame->vos_buf, &vos))
+ goto skip_frame;
+
+ if (!mpeg4_util_parse_VO (mpeg4_frame->vo_buf, &vo))
+ goto skip_frame;
+
+ if (!mpeg4_util_parse_VOL (mpeg4_frame->vol_buf, &vo, &vol))
+ goto skip_frame;
+
+ state = gst_base_video_decoder_get_state (GST_BASE_VIDEO_DECODER (mpeg4_dec));
+
+ state.width = vol.width;
+ state.height = vol.height;
+
+ if (vol.fixed_vop_rate) {
+ state.fps_n = vol.vop_time_increment_resolution;
+ state.fps_d = vol.fixed_vop_time_increment;
+ }
+
+ state.par_n = vol.par_n;
+ state.par_d = vol.par_d;
+
+ gst_base_video_decoder_set_state (GST_BASE_VIDEO_DECODER (mpeg4_dec), state);
+
+ profile_indication = vos.profile_and_level_indication >> 4;
+ switch (profile_indication) {
+ case 0x0:
+ profile = VDP_DECODER_PROFILE_MPEG4_PART2_SP;
+ break;
+
+ case 0xf:
+ profile = VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
+ break;
+
+ default:
+ goto unsupported_profile;
+ }
+ ret = gst_vdp_decoder_init_decoder (GST_VDP_DECODER (mpeg4_dec), profile, 2);
+ if (ret != GST_FLOW_OK)
+ return ret;
+
+ mpeg4_dec->vol = vol;
+ mpeg4_dec->is_configured = TRUE;
+
+ return GST_FLOW_OK;
+
+skip_frame:
+ GST_WARNING ("Skipping frame since we're not configured yet");
+ gst_base_video_decoder_skip_frame (GST_BASE_VIDEO_DECODER (mpeg4_dec),
+ GST_VIDEO_FRAME (mpeg4_frame));
+ return GST_FLOW_CUSTOM_ERROR;
+
+unsupported_profile:
+ GST_ELEMENT_ERROR (mpeg4_dec, STREAM, WRONG_TYPE,
+ ("vdpaumpeg4dec doesn't support this streams profile"),
+ ("profile_and_level_indication: %d", vos.profile_and_level_indication));
+ return GST_FLOW_ERROR;
+}
+
+static GstFlowReturn
+gst_vdp_mpeg4_dec_handle_frame (GstBaseVideoDecoder * base_video_decoder,
+ GstVideoFrame * frame, GstClockTimeDiff deadline)
+{
+ GstVdpMpeg4Dec *mpeg4_dec = GST_VDP_MPEG4_DEC (base_video_decoder);
+
+ GstMpeg4Frame *mpeg4_frame;
+ GstFlowReturn ret;
+
+ Mpeg4VideoObjectLayer *vol;
+ Mpeg4VideoObjectPlane vop;
+
+ VdpPictureInfoMPEG4Part2 info;
+ VdpBitstreamBuffer bufs[1];
+ GstVdpVideoBuffer *video_buf;
+
+ mpeg4_frame = GST_MPEG4_FRAME (frame);
+
+ ret = gst_vdp_mpeg4_dec_handle_configuration (mpeg4_dec, mpeg4_frame);
+ if (ret != GST_FLOW_OK)
+ return ret;
+
+ vol = &mpeg4_dec->vol;
+ if (!mpeg4_util_parse_VOP (mpeg4_frame->vop_buf, vol, &vop)) {
+ gst_base_video_decoder_skip_frame (base_video_decoder, frame);
+ return GST_FLOW_CUSTOM_ERROR;
+ }
+
+ /* calculate vop time */
+ mpeg4_frame->vop_time = vop.modulo_time_base * GST_SECOND +
+ gst_util_uint64_scale (vop.time_increment, GST_SECOND,
+ vol->vop_time_increment_resolution);
+ GST_DEBUG ("vop_time: %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (mpeg4_frame->vop_time));
+
+ if (mpeg4_dec->tframe == GST_CLOCK_TIME_NONE && vop.coding_type == B_VOP)
+ mpeg4_dec->tframe = mpeg4_frame->vop_time - mpeg4_dec->f_frame->vop_time;
+
+ if (vop.coding_type != B_VOP) {
+ if (mpeg4_dec->b_frame) {
+
+ gst_base_video_decoder_finish_frame (base_video_decoder,
+ GST_VIDEO_FRAME_CAST (mpeg4_dec->b_frame));
+
+ if (mpeg4_dec->f_frame)
+ gst_video_frame_unref (GST_VIDEO_FRAME_CAST (mpeg4_dec->f_frame));
+
+ mpeg4_dec->f_frame = mpeg4_dec->b_frame;
+ mpeg4_dec->b_frame = NULL;
+ }
+ }
+
+ info = gst_vdp_mpeg4_dec_fill_info (mpeg4_dec, mpeg4_frame, &vop);
+ bufs[0].struct_version = VDP_BITSTREAM_BUFFER_VERSION;
+ bufs[0].bitstream = GST_BUFFER_DATA (mpeg4_frame->vop_buf);
+ bufs[0].bitstream_bytes = GST_BUFFER_SIZE (mpeg4_frame->vop_buf);
+
+ ret = gst_vdp_decoder_render (GST_VDP_DECODER (base_video_decoder),
+ (VdpPictureInfo *) & info, 1, bufs, &video_buf);
+ if (ret != GST_FLOW_OK) {
+ gst_base_video_decoder_skip_frame (base_video_decoder, frame);
+ return ret;
+ }
+
+ frame->src_buffer = GST_BUFFER_CAST (video_buf);
+
+ if (vop.coding_type == B_VOP)
+ ret = gst_base_video_decoder_finish_frame (base_video_decoder, frame);
+ else {
+ gst_video_frame_ref (GST_VIDEO_FRAME_CAST (mpeg4_frame));
+ mpeg4_dec->b_frame = mpeg4_frame;
+ ret = GST_FLOW_OK;
+ }
+
+ return ret;
+}
+
+static GstFlowReturn
+gst_vdp_mpeg4_dec_parse_data (GstBaseVideoDecoder * base_video_decoder,
+ GstBuffer * buf, gboolean at_eos)
+{
+ GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf);
+ guint8 start_code;
+ GstMpeg4Frame *mpeg4_frame;
+
+ GstFlowReturn ret = GST_FLOW_OK;
+
+ /* start code prefix */
+ SKIP (&reader, 24);
+
+ /* start_code */
+ READ_UINT8 (&reader, start_code, 8);
+
+ mpeg4_frame =
+ GST_MPEG4_FRAME_CAST (gst_base_video_decoder_get_current_frame
+ (base_video_decoder));
+
+ /* collect packages */
+ if (start_code == MPEG4_PACKET_VOS) {
+ if (mpeg4_frame->vop_buf)
+ ret = gst_base_video_decoder_have_frame (base_video_decoder, FALSE,
+ (GstVideoFrame **) & mpeg4_frame);
+
+ gst_buffer_replace (&mpeg4_frame->vos_buf, buf);
+ }
+
+ else if (start_code == MPEG4_PACKET_EVOS) {
+ if (mpeg4_frame->vop_buf)
+ ret = gst_base_video_decoder_have_frame (base_video_decoder, FALSE,
+ (GstVideoFrame **) & mpeg4_frame);
+ }
+
+ else if (start_code == MPEG4_PACKET_VO)
+ gst_buffer_replace (&mpeg4_frame->vo_buf, buf);
+
+ else if (start_code >= MPEG4_PACKET_VOL_MIN &&
+ start_code <= MPEG4_PACKET_VOL_MAX)
+ gst_buffer_replace (&mpeg4_frame->vol_buf, buf);
+
+ else if (start_code == MPEG4_PACKET_GOV) {
+ if (mpeg4_frame->vop_buf)
+ ret = gst_base_video_decoder_have_frame (base_video_decoder, FALSE,
+ (GstVideoFrame **) & mpeg4_frame);
+
+ gst_buffer_replace (&mpeg4_frame->gov_buf, buf);
+ }
+
+ else if (start_code == MPEG4_PACKET_VOP) {
+ if (mpeg4_frame->vop_buf)
+ ret = gst_base_video_decoder_have_frame (base_video_decoder, FALSE,
+ (GstVideoFrame **) & mpeg4_frame);
+
+ mpeg4_frame->vop_buf = buf;
+ }
+
+ else
+ gst_buffer_unref (buf);
+
+
+ if (at_eos && mpeg4_frame->vop_buf)
+ ret = gst_base_video_decoder_have_frame (base_video_decoder, TRUE,
+ (GstVideoFrame **) & mpeg4_frame);
+
+ return ret;
+
+error:
+ gst_buffer_unref (buf);
+ GST_WARNING ("error parsing packet");
+ return GST_FLOW_OK;
+}
+
+static gint
+gst_vdp_mpeg4_dec_scan_for_sync (GstBaseVideoDecoder * base_video_decoder,
+ GstAdapter * adapter)
+{
+ gint m;
+
+ m = gst_adapter_masked_scan_uint32 (adapter, 0xffffff00, 0x00000100, 0,
+ gst_adapter_available (adapter));
+ if (m == -1)
+ return gst_adapter_available (adapter) - SYNC_CODE_SIZE;
+
+ return m;
+}
+
+static GstBaseVideoDecoderScanResult
+gst_vdp_mpeg4_dec_scan_for_packet_end (GstBaseVideoDecoder * base_video_decoder,
+ GstAdapter * adapter, guint * size, gboolean at_eos)
+{
+ guint8 *data;
+ guint32 sync_code;
+
+ data = g_slice_alloc (SYNC_CODE_SIZE);
+ gst_adapter_copy (adapter, data, 0, SYNC_CODE_SIZE);
+ sync_code = ((data[0] << 16) | (data[1] << 8) | data[2]);
+
+ if (sync_code != 0x000001)
+ return GST_BASE_VIDEO_DECODER_SCAN_RESULT_LOST_SYNC;
+
+ *size = gst_adapter_masked_scan_uint32 (adapter, 0xffffff00, 0x00000100,
+ SYNC_CODE_SIZE, gst_adapter_available (adapter) - SYNC_CODE_SIZE);
+
+ if (*size == -1)
+ return GST_BASE_VIDEO_DECODER_SCAN_RESULT_NEED_DATA;
+
+ return GST_BASE_VIDEO_DECODER_SCAN_RESULT_OK;
+}
+
+static GstVideoFrame *
+gst_vdp_mpeg4_dec_create_frame (GstBaseVideoDecoder * base_video_decoder)
+{
+ return GST_VIDEO_FRAME_CAST (gst_mpeg4_frame_new ());
+}
+
+static gboolean
+gst_vdp_mpeg4_dec_flush (GstBaseVideoDecoder * base_video_decoder)
+{
+ GstVdpMpeg4Dec *mpeg4_dec = GST_VDP_MPEG4_DEC (base_video_decoder);
+
+ if (mpeg4_dec->b_frame) {
+ gst_video_frame_unref (GST_VIDEO_FRAME_CAST (mpeg4_dec->b_frame));
+ mpeg4_dec->b_frame = NULL;
+ }
+
+ if (mpeg4_dec->f_frame) {
+ gst_video_frame_unref (GST_VIDEO_FRAME_CAST (mpeg4_dec->f_frame));
+ mpeg4_dec->f_frame = NULL;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+gst_vdp_mpeg4_dec_start (GstBaseVideoDecoder * base_video_decoder)
+{
+ GstVdpMpeg4Dec *mpeg4_dec = GST_VDP_MPEG4_DEC (base_video_decoder);
+
+ mpeg4_dec->is_configured = FALSE;
+ mpeg4_dec->tframe = GST_CLOCK_TIME_NONE;
+
+ mpeg4_dec->b_frame = NULL;
+ mpeg4_dec->f_frame = NULL;
+
+ return GST_BASE_VIDEO_DECODER_CLASS
+ (parent_class)->start (base_video_decoder);
+}
+
+static gboolean
+gst_vdp_mpeg4_dec_stop (GstBaseVideoDecoder * base_video_decoder)
+{
+ return GST_BASE_VIDEO_DECODER_CLASS (parent_class)->stop (base_video_decoder);
+}
+
+static void
+gst_vdp_mpeg4_dec_base_init (gpointer gclass)
+{
+ GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
+
+ gst_element_class_set_details_simple (element_class,
+ "VDPAU Mpeg4 Decoder",
+ "Decoder",
+ "Decode mpeg4 stream with vdpau",
+ "Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>");
+
+ gst_element_class_add_pad_template (element_class,
+ gst_static_pad_template_get (&sink_template));
+}
+
+/* initialize the vdpaumpeg4decoder's class */
+static void
+gst_vdp_mpeg4_dec_class_init (GstVdpMpeg4DecClass * klass)
+{
+ GstBaseVideoDecoderClass *base_video_decoder_class;
+
+ base_video_decoder_class = GST_BASE_VIDEO_DECODER_CLASS (klass);
+
+ base_video_decoder_class->start = gst_vdp_mpeg4_dec_start;
+ base_video_decoder_class->stop = gst_vdp_mpeg4_dec_stop;
+ base_video_decoder_class->flush = gst_vdp_mpeg4_dec_flush;
+
+ base_video_decoder_class->create_frame = gst_vdp_mpeg4_dec_create_frame;
+
+ base_video_decoder_class->scan_for_sync = gst_vdp_mpeg4_dec_scan_for_sync;
+ base_video_decoder_class->scan_for_packet_end =
+ gst_vdp_mpeg4_dec_scan_for_packet_end;
+ base_video_decoder_class->parse_data = gst_vdp_mpeg4_dec_parse_data;
+
+ base_video_decoder_class->handle_frame = gst_vdp_mpeg4_dec_handle_frame;
+}
+
+static void
+gst_vdp_mpeg4_dec_init (GstVdpMpeg4Dec * mpeg4_dec,
+ GstVdpMpeg4DecClass * gclass)
+{
+}
diff --git a/sys/vdpau/mpeg4/gstvdpmpeg4dec.h b/sys/vdpau/mpeg4/gstvdpmpeg4dec.h
new file mode 100644
index 000000000..7aa8f5a8d
--- /dev/null
+++ b/sys/vdpau/mpeg4/gstvdpmpeg4dec.h
@@ -0,0 +1,62 @@
+/*
+ * GStreamer
+ * Copyright (C) 2009 Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>
+ *
+ * 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.
+ */
+
+#ifndef __GST_VDP_MPEG4_DEC_H__
+#define __GST_VDP_MPEG4_DEC_H__
+
+#include <gst/gst.h>
+
+#include "../gstvdp/gstvdpdecoder.h"
+
+#include "mpeg4util.h"
+#include "gstmpeg4frame.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_VDP_MPEG4_DEC (gst_vdp_mpeg4_dec_get_type())
+#define GST_VDP_MPEG4_DEC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VDP_MPEG4_DEC,GstVdpMpeg4Dec))
+#define GST_VDP_MPEG4_DEC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VDP_MPEG4_DEC,GstVdpMpeg4DecClass))
+#define GST_IS_VDP_MPEG4_DEC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VDP_MPEG4_DEC))
+#define GST_IS_VDP_MPEG4_DEC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VDP_MPEG4_DEC))
+
+typedef struct _GstVdpMpeg4Dec GstVdpMpeg4Dec;
+typedef struct _GstVdpMpeg4DecClass GstVdpMpeg4DecClass;
+
+struct _GstVdpMpeg4Dec
+{
+ GstVdpDecoder vdp_decoder;
+
+ gboolean is_configured;
+ Mpeg4VideoObjectLayer vol;
+ GstClockTime tframe;
+
+ GstMpeg4Frame *f_frame, *b_frame;
+};
+
+struct _GstVdpMpeg4DecClass
+{
+ GstVdpDecoderClass vdp_decoder_class;
+};
+
+GType gst_vdp_mpeg4_dec_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_VDP_MPEG4_DEC_H__ */
diff --git a/sys/vdpau/mpeg4/mpeg4util.c b/sys/vdpau/mpeg4/mpeg4util.c
new file mode 100644
index 000000000..d7e57b639
--- /dev/null
+++ b/sys/vdpau/mpeg4/mpeg4util.c
@@ -0,0 +1,466 @@
+/*
+* GStreamer
+* Copyright (C) 2009 Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>
+*
+* 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.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+#include "mpeg4util.h"
+
+GST_DEBUG_CATEGORY_EXTERN (gst_vdp_mpeg4_dec_debug);
+#define GST_CAT_DEFAULT gst_vdp_mpeg4_dec_debug
+
+const guint8 default_intra_quant_mat[64] = {
+ 8, 17, 18, 19, 21, 23, 25, 27,
+ 17, 18, 19, 21, 23, 25, 27, 28,
+ 20, 21, 22, 23, 24, 26, 28, 30,
+ 21, 22, 23, 24, 26, 28, 30, 32,
+ 22, 23, 24, 26, 28, 30, 32, 35,
+ 23, 24, 26, 28, 30, 32, 35, 38,
+ 25, 26, 28, 30, 32, 35, 38, 41,
+ 27, 28, 30, 32, 35, 38, 41, 45
+};
+
+const guint8 default_non_intra_quant_mat[64] = {
+ 6, 17, 18, 19, 20, 21, 22, 23,
+ 17, 18, 19, 20, 21, 22, 23, 24,
+ 18, 19, 20, 21, 22, 23, 24, 25,
+ 19, 20, 21, 22, 23, 24, 26, 27,
+ 20, 21, 22, 23, 25, 26, 27, 28,
+ 21, 22, 23, 24, 26, 27, 28, 30,
+ 22, 23, 24, 26, 27, 28, 30, 31,
+ 23, 24, 25, 27, 28, 30, 31, 33,
+};
+
+const guint8 mpeg4_zigzag_8x8[64] = {
+ 0, 1, 8, 16, 9, 2, 3, 10,
+ 17, 24, 32, 25, 18, 11, 4, 5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13, 6, 7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63
+};
+
+gboolean
+mpeg4_util_parse_VOP (GstBuffer * buf, Mpeg4VideoObjectLayer * vol,
+ Mpeg4VideoObjectPlane * vop)
+{
+ GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf);
+
+ guint8 vop_start_code;
+ guint8 modulo_time_base;
+
+ /* set default values */
+ vop->modulo_time_base = 0;
+ vop->rounding_type = 0;
+
+ /* start code prefix */
+ SKIP (&reader, 24);
+
+ READ_UINT8 (&reader, vop_start_code, 8);
+ if (vop_start_code != MPEG4_PACKET_VOP)
+ goto wrong_start_code;
+
+ READ_UINT8 (&reader, vop->coding_type, 2);
+
+ READ_UINT8 (&reader, modulo_time_base, 1);
+ while (modulo_time_base) {
+ vop->modulo_time_base++;
+
+ READ_UINT8 (&reader, modulo_time_base, 1);
+ }
+
+ /* marker bit */
+ SKIP (&reader, 1);
+ READ_UINT16 (&reader, vop->time_increment, vol->vop_time_increment_bits);
+ /* marker bit */
+ SKIP (&reader, 1);
+
+ READ_UINT8 (&reader, vop->coded, 1);
+ if (!vop->coded)
+ return TRUE;
+
+ if (vop->coding_type == P_VOP)
+ READ_UINT8 (&reader, vop->rounding_type, 1);
+
+ READ_UINT8 (&reader, vop->intra_dc_vlc_thr, 3);
+
+ if (vol->interlaced) {
+ READ_UINT8 (&reader, vop->top_field_first, 1);
+ READ_UINT8 (&reader, vop->alternate_vertical_scan_flag, 1);
+ }
+
+ READ_UINT16 (&reader, vop->quant, vol->quant_precision);
+
+ if (vop->coding_type != I_VOP) {
+ READ_UINT8 (&reader, vop->fcode_forward, 3);
+ CHECK_ALLOWED (vop->fcode_forward, 1, 7);
+ }
+
+ if (vop->coding_type == B_VOP) {
+ READ_UINT8 (&reader, vop->fcode_backward, 3);
+ CHECK_ALLOWED (vop->fcode_backward, 1, 7);
+ }
+
+ return TRUE;
+
+error:
+ GST_WARNING ("error parsing \"Video Object Plane\"");
+ return FALSE;
+
+wrong_start_code:
+ GST_WARNING ("got buffer with wrong start code");
+ goto error;
+}
+
+gboolean
+mpeg4_util_parse_GOV (GstBuffer * buf, Mpeg4GroupofVideoObjectPlane * gov)
+{
+ GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf);
+
+ guint8 gov_start_code;
+
+ /* start code prefix */
+ SKIP (&reader, 24);
+
+ READ_UINT8 (&reader, gov_start_code, 8);
+ if (gov_start_code != MPEG4_PACKET_GOV)
+ goto wrong_start_code;
+
+ READ_UINT8 (&reader, gov->hours, 5);
+ READ_UINT8 (&reader, gov->minutes, 6);
+ /* marker bit */
+ SKIP (&reader, 1);
+ READ_UINT8 (&reader, gov->seconds, 6);
+
+ READ_UINT8 (&reader, gov->closed, 1);
+ READ_UINT8 (&reader, gov->broken_link, 1);
+
+ return TRUE;
+
+error:
+ GST_WARNING ("error parsing \"Group of Video Object Plane\"");
+ return FALSE;
+
+wrong_start_code:
+ GST_WARNING ("got buffer with wrong start code");
+ goto error;
+}
+
+static void
+mpeg4_util_par_from_info (guint8 aspect_ratio_info, guint8 * par_n,
+ guint8 * par_d)
+{
+ switch (aspect_ratio_info) {
+ case 0x02:
+ *par_n = 12;
+ *par_d = 11;
+ break;
+ case 0x03:
+ *par_n = 10;
+ *par_d = 11;
+ break;
+ case 0x04:
+ *par_n = 16;
+ *par_d = 11;
+ break;
+ case 0x05:
+ *par_n = 40;
+ *par_d = 33;
+ break;
+
+ case 0x01:
+ default:
+ *par_n = 1;
+ *par_d = 1;
+ }
+}
+
+static gboolean
+mpeg4_util_parse_quant (GstBitReader * reader, guint8 quant_mat[64],
+ const guint8 default_quant_mat[64])
+{
+ guint8 load_quant_mat;
+
+ READ_UINT8 (reader, load_quant_mat, 1);
+ if (load_quant_mat) {
+ guint i;
+ guint8 val;
+
+ val = 1;
+ for (i = 0; i < 64; i++) {
+
+ if (val != 0)
+ READ_UINT8 (reader, val, 8);
+
+ if (val == 0) {
+ if (i == 0)
+ goto invalid_quant_mat;
+ quant_mat[mpeg4_zigzag_8x8[i]] = quant_mat[mpeg4_zigzag_8x8[i - 1]];
+ } else
+ quant_mat[mpeg4_zigzag_8x8[i]] = val;
+ }
+ } else
+ memcpy (quant_mat, default_quant_mat, 64);
+
+ return TRUE;
+
+error:
+ GST_WARNING ("error parsing quant matrix");
+ return FALSE;
+
+invalid_quant_mat:
+ GST_WARNING ("the first value should be non zero");
+ goto error;
+}
+
+gboolean
+mpeg4_util_parse_VOL (GstBuffer * buf, Mpeg4VisualObject * vo,
+ Mpeg4VideoObjectLayer * vol)
+{
+ GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf);
+
+ guint8 video_object_layer_start_code;
+ guint8 aspect_ratio_info;
+ guint8 control_parameters;
+ guint8 not_8_bit;
+
+ /* set default values */
+ vol->verid = vo->verid;
+ vol->priority = vo->priority;
+
+ vol->low_delay = FALSE;
+ vol->chroma_format = 1;
+ vol->vbv_parameters = FALSE;
+ vol->quant_precision = 5;
+ vol->bits_per_pixel = 8;
+ vol->quarter_sample = FALSE;
+
+ /* start code prefix */
+ SKIP (&reader, 24);
+
+ READ_UINT8 (&reader, video_object_layer_start_code, 8);
+ if (!(video_object_layer_start_code >= MPEG4_PACKET_VOL_MIN &&
+ video_object_layer_start_code <= MPEG4_PACKET_VOL_MAX))
+ goto wrong_start_code;
+
+ READ_UINT8 (&reader, vol->random_accesible_vol, 1);
+ READ_UINT8 (&reader, vol->video_object_type_indication, 8);
+
+ READ_UINT8 (&reader, vol->is_object_layer_identifier, 1);
+ if (vol->is_object_layer_identifier) {
+ READ_UINT8 (&reader, vol->verid, 4);
+ READ_UINT8 (&reader, vol->priority, 3);
+ }
+
+ READ_UINT8 (&reader, aspect_ratio_info, 4);
+ if (aspect_ratio_info != 0xff)
+ mpeg4_util_par_from_info (aspect_ratio_info, &vol->par_n, &vol->par_d);
+
+ else {
+ READ_UINT8 (&reader, vol->par_n, 8);
+ CHECK_ALLOWED (vol->par_n, 1, 255);
+ READ_UINT8 (&reader, vol->par_d, 8);
+ CHECK_ALLOWED (vol->par_d, 1, 255);
+ }
+
+ READ_UINT8 (&reader, control_parameters, 1);
+ if (control_parameters) {
+ READ_UINT8 (&reader, vol->chroma_format, 2);
+ READ_UINT8 (&reader, vol->low_delay, 1);
+
+ READ_UINT8 (&reader, vol->vbv_parameters, 1);
+ if (vol->vbv_parameters) {
+ guint16 first_half, latter_half;
+ guint8 latter_part;
+
+ READ_UINT16 (&reader, first_half, 15);
+ SKIP (&reader, 1);
+ READ_UINT16 (&reader, latter_half, 15);
+ SKIP (&reader, 1);
+ vol->bit_rate = (first_half << 15) | latter_half;
+
+ READ_UINT16 (&reader, first_half, 15);
+ SKIP (&reader, 1);
+ READ_UINT8 (&reader, latter_part, 3);
+ SKIP (&reader, 1);
+ vol->vbv_buffer_size = (first_half << 15) | latter_part;
+ }
+ }
+
+ READ_UINT8 (&reader, vol->shape, 2);
+ if (vol->shape != 0x0)
+ goto invalid_shape;
+
+ /* marker_bit */
+ SKIP (&reader, 1);
+ READ_UINT16 (&reader, vol->vop_time_increment_resolution, 16);
+ CHECK_ALLOWED (vol->vop_time_increment_resolution, 1, G_MAXUINT16);
+ vol->vop_time_increment_bits =
+ g_bit_storage (vol->vop_time_increment_resolution);
+ /* marker_bit */
+ SKIP (&reader, 1);
+
+ READ_UINT8 (&reader, vol->fixed_vop_rate, 1);
+ if (vol->fixed_vop_rate)
+ READ_UINT16 (&reader, vol->fixed_vop_time_increment,
+ vol->vop_time_increment_bits);
+
+ /* marker bit */
+ SKIP (&reader, 1);
+ READ_UINT16 (&reader, vol->width, 13);
+ /* marker bit */
+ SKIP (&reader, 1);
+ READ_UINT16 (&reader, vol->height, 13);
+ /* marker bit */
+ SKIP (&reader, 1);
+
+ READ_UINT8 (&reader, vol->interlaced, 1);
+ READ_UINT8 (&reader, vol->obmc_disable, 1);
+
+ if (vol->verid == 0x1) {
+ READ_UINT8 (&reader, vol->sprite_enable, 1);
+ } else
+ READ_UINT8 (&reader, vol->sprite_enable, 2);
+
+ if (vol->sprite_enable != 0x0)
+ goto invalid_sprite_enable;
+
+ READ_UINT8 (&reader, not_8_bit, 1);
+ if (not_8_bit) {
+ READ_UINT8 (&reader, vol->quant_precision, 4);
+ CHECK_ALLOWED (vol->quant_precision, 3, 9);
+
+ READ_UINT8 (&reader, vol->bits_per_pixel, 4);
+ CHECK_ALLOWED (vol->bits_per_pixel, 4, 12);
+ }
+
+
+ READ_UINT8 (&reader, vol->quant_type, 1);
+ if (vol->quant_type) {
+ if (!mpeg4_util_parse_quant (&reader, vol->intra_quant_mat,
+ default_intra_quant_mat))
+ goto error;
+
+ if (!mpeg4_util_parse_quant (&reader, vol->non_intra_quant_mat,
+ default_non_intra_quant_mat))
+ goto error;
+ }
+
+ if (vol->verid != 0x1)
+ READ_UINT8 (&reader, vol->quarter_sample, 1);
+
+ READ_UINT8 (&reader, vol->complexity_estimation_disable, 1);
+ if (!vol->complexity_estimation_disable)
+ goto complexity_estimation_error;
+
+ READ_UINT8 (&reader, vol->resync_marker_disable, 1);
+
+ return TRUE;
+
+error:
+ GST_WARNING ("error parsing \"Video Object Layer\"");
+ return FALSE;
+
+wrong_start_code:
+ GST_WARNING ("got buffer with wrong start code");
+ goto error;
+
+invalid_shape:
+ GST_WARNING ("we only support rectangular shape");
+ goto error;
+
+invalid_sprite_enable:
+ GST_WARNING ("we only support sprite_enable == 0");
+ goto error;
+
+complexity_estimation_error:
+ GST_WARNING ("don't support complexity estimation");
+ goto error;
+}
+
+gboolean
+mpeg4_util_parse_VO (GstBuffer * buf, Mpeg4VisualObject * vo)
+{
+ GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf);
+
+ guint8 visual_object_start_code;
+ guint8 is_visual_object_identifier;
+
+ /* set defualt values */
+ vo->verid = 0x1;
+ vo->priority = 1;
+
+ /* start code prefix */
+ SKIP (&reader, 24);
+
+ READ_UINT8 (&reader, visual_object_start_code, 8);
+ if (visual_object_start_code != MPEG4_PACKET_VO)
+ goto wrong_start_code;
+
+ READ_UINT8 (&reader, is_visual_object_identifier, 1);
+ if (is_visual_object_identifier) {
+ READ_UINT8 (&reader, vo->verid, 4);
+ READ_UINT8 (&reader, vo->priority, 3);
+ }
+
+ READ_UINT8 (&reader, vo->type, 4);
+
+ return TRUE;
+
+wrong_start_code:
+ GST_WARNING ("got buffer with wrong start code");
+ return FALSE;
+
+error:
+ GST_WARNING ("error parsing \"Visual Object\"");
+ return FALSE;
+}
+
+gboolean
+mpeg4_util_parse_VOS (GstBuffer * buf, Mpeg4VisualObjectSequence * vos)
+{
+ GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf);
+
+ guint8 visual_object_sequence_start_code;
+
+ /* start code prefix */
+ SKIP (&reader, 24);
+
+ READ_UINT8 (&reader, visual_object_sequence_start_code, 8);
+ if (visual_object_sequence_start_code != MPEG4_PACKET_VOS)
+ goto wrong_start_code;
+
+ READ_UINT8 (&reader, vos->profile_and_level_indication, 8);
+
+ return TRUE;
+
+wrong_start_code:
+ GST_WARNING ("got buffer with wrong start code");
+ return FALSE;
+
+error:
+ GST_WARNING ("error parsing \"Visual Object\"");
+ return FALSE;
+}
diff --git a/sys/vdpau/mpeg4/mpeg4util.h b/sys/vdpau/mpeg4/mpeg4util.h
new file mode 100644
index 000000000..a069003b1
--- /dev/null
+++ b/sys/vdpau/mpeg4/mpeg4util.h
@@ -0,0 +1,179 @@
+/*
+ * GStreamer
+ * Copyright (C) 2009 Carl-Anton Ingmarsson <ca.ingmarsson@gmail.com>
+ *
+ * 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.
+ */
+
+#ifndef __GST_MPEG4UTIL_H__
+#define __GST_MPEG4UTIL_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstbitreader.h>
+
+#define CHECK_ALLOWED(val, min, max) { \
+ if (val < min || val > max) { \
+ GST_WARNING ("value not in allowed range. value: %d, range %d-%d", \
+ val, min, max); \
+ goto error; \
+ } \
+}
+
+#define READ_UINT8(reader, val, nbits) { \
+ if (!gst_bit_reader_get_bits_uint8 (reader, &val, nbits)) { \
+ GST_WARNING ("failed to read uint8, nbits: %d", nbits); \
+ goto error; \
+ } \
+}
+
+#define READ_UINT16(reader, val, nbits) { \
+ if (!gst_bit_reader_get_bits_uint16 (reader, &val, nbits)) { \
+ GST_WARNING ("failed to read uint16, nbits: %d", nbits); \
+ goto error; \
+ } \
+}
+
+#define READ_UINT32(reader, val, nbits) { \
+ if (!gst_bit_reader_get_bits_uint32 (reader, &val, nbits)) { \
+ GST_WARNING ("failed to read uint32, nbits: %d", nbits); \
+ goto error; \
+ } \
+}
+
+#define READ_UINT64(reader, val, nbits) { \
+ if (!gst_bit_reader_get_bits_uint64 (reader, &val, nbits)) { \
+ GST_WARNING ("failed to read uint64, nbits: %d", nbits); \
+ goto error; \
+ } \
+}
+
+#define SKIP(reader, nbits) { \
+ if (!gst_bit_reader_skip (reader, nbits)) { \
+ GST_WARNING ("failed to skip nbits: %d", nbits); \
+ goto error; \
+ } \
+}
+
+typedef struct _Mpeg4VisualObjectSequence Mpeg4VisualObjectSequence;
+typedef struct _Mpeg4VisualObject Mpeg4VisualObject;
+typedef struct _Mpeg4VideoObjectLayer Mpeg4VideoObjectLayer;
+typedef struct _Mpeg4GroupofVideoObjectPlane Mpeg4GroupofVideoObjectPlane;
+typedef struct _Mpeg4VideoObjectPlane Mpeg4VideoObjectPlane;
+
+#define MPEG4_PACKET_VOL_MIN 0x20
+#define MPEG4_PACKET_VOL_MAX 0x2f
+
+#define MPEG4_PACKET_VOS 0xb0
+#define MPEG4_PACKET_EVOS 0xb1
+#define MPEG4_PACKET_GOV 0xb3
+#define MPEG4_PACKET_VO 0xb5
+#define MPEG4_PACKET_VOP 0xb6
+
+#define I_VOP 0x0
+#define P_VOP 0x1
+#define B_VOP 0x2
+#define S_VOP 0x3
+
+struct _Mpeg4VisualObjectSequence {
+ guint8 profile_and_level_indication;
+};
+
+struct _Mpeg4VisualObject {
+ guint8 verid;
+ guint8 priority;
+ guint8 type;
+};
+
+struct _Mpeg4VideoObjectLayer {
+ guint8 random_accesible_vol;
+ guint8 video_object_type_indication;
+
+ guint8 is_object_layer_identifier;
+ /* if is_object_layer_identifier */
+ guint8 verid;
+ guint8 priority;
+
+ guint8 par_n;
+ guint8 par_d;
+
+ guint8 chroma_format;
+ guint8 low_delay;
+ guint8 vbv_parameters;
+ /* if vbv_parameters */
+ guint32 bit_rate;
+ guint32 vbv_buffer_size;
+
+ guint8 shape;
+
+ guint16 vop_time_increment_resolution;
+ guint8 vop_time_increment_bits;
+ guint8 fixed_vop_rate;
+ /* if fixed_vop_rate */
+ guint16 fixed_vop_time_increment;
+
+ guint16 width;
+ guint16 height;
+ guint8 interlaced;
+ guint8 obmc_disable;
+
+ guint8 sprite_enable;
+
+ guint8 quant_precision;
+ guint8 bits_per_pixel;
+
+ guint8 quant_type;
+ guint8 intra_quant_mat[64];
+ guint8 non_intra_quant_mat[64];
+
+ guint8 quarter_sample;
+ guint8 complexity_estimation_disable;
+ guint8 resync_marker_disable;
+};
+
+struct _Mpeg4GroupofVideoObjectPlane {
+ guint8 hours;
+ guint8 minutes;
+ guint8 seconds;
+
+ guint8 closed;
+ guint8 broken_link;
+};
+
+struct _Mpeg4VideoObjectPlane {
+ guint8 coding_type;
+ guint8 modulo_time_base;
+ guint16 time_increment;
+
+ guint8 coded;
+ guint8 rounding_type;
+ guint8 intra_dc_vlc_thr;
+
+ guint8 top_field_first;
+ guint8 alternate_vertical_scan_flag;
+
+ guint16 quant;
+
+ guint8 fcode_forward;
+ guint8 fcode_backward;
+};
+
+gboolean mpeg4_util_parse_VOP (GstBuffer *buf, Mpeg4VideoObjectLayer *vol, Mpeg4VideoObjectPlane *vop);
+gboolean mpeg4_util_parse_GOV (GstBuffer *buf, Mpeg4GroupofVideoObjectPlane *gov);
+gboolean mpeg4_util_parse_VOL (GstBuffer *buf, Mpeg4VisualObject *vo, Mpeg4VideoObjectLayer *vol);
+gboolean mpeg4_util_parse_VO (GstBuffer *buf, Mpeg4VisualObject *vo);
+gboolean mpeg4_util_parse_VOS (GstBuffer *buf, Mpeg4VisualObjectSequence *vos);
+
+#endif /* __GST_MPEG4UTIL_H__ */ \ No newline at end of file