From: Grazvydas Ignotas Date: Fri, 10 Oct 2014 00:09:48 +0000 (+0300) Subject: gstreamer: update to 0.10.32 X-Git-Tag: sz_173~101 X-Git-Url: http://git.openpandora.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=4a5c9378887b07d18a65dc370dd0cfbb9bea9b32;p=openembedded.git gstreamer: update to 0.10.32 --- diff --git a/recipes/gstreamer/gst-plugins-base_0.10.32.bb b/recipes/gstreamer/gst-plugins-base_0.10.32.bb new file mode 100644 index 0000000000..6394f44f30 --- /dev/null +++ b/recipes/gstreamer/gst-plugins-base_0.10.32.bb @@ -0,0 +1,64 @@ +require gst-plugins.inc + +SRC_URI += " \ + file://ivorbis-thumb.patch;patch=1 \ +" + +SRC_URI[archive.md5sum] = "2920af2b3162f3d9fbaa7fabc8ed4d38" +SRC_URI[archive.sha256sum] = "e9aabfac83f6480896da0686e9c911989f896fbad634821b7771ed84a446172b" + +PR = "${INC_PR}.1" + +PROVIDES += "gst-plugins" + +# gst-plugins-base only builds the alsa plugin +# if alsa has been built and is present. You will +# not get an error if this is not present, just +# a missing alsa plugin +DEPENDS += "udev cdparanoia pango libtheora alsa-lib libsm virtual/libx11 freetype libxv libxrandr gtk+" + +def get_gstreamer_fpu_setting(bb, d): + if bb.data.getVar('TARGET_FPU', d, 1) in [ 'soft' ]: + return "--with-audioresample-format=int" + return "" + +# Needs a udev that enabled gudev, which isn't the default +EXTRA_OECONF += "--with-gudev --disable-gnome_vfs ${@get_gstreamer_fpu_setting(bb, d)}" + +do_configure_prepend() { + sed -i -e s:QtGui:NoQtGui:g ${S}/configure.ac +} + +PACKAGES_DYNAMIC = "\ +gst-plugin-adder* \ +gst-plugin-alsa* \ +gst-plugin-app* \ +gst-plugin-audioconvert* \ +gst-plugin-audiorate* \ +gst-plugin-audioresample* \ +gst-plugin-audiotestsrc* \ +gst-plugin-cdparanoia* \ +gst-plugin-decodebin2* \ +gst-plugin-decodebin* \ +gst-plugin-encodebin* \ +gst-plugin-ffmpegcolorspace* \ +gst-plugin-gdp* \ +gst-plugin-gio* \ +gst-plugin-ivorbisdec* \ +gst-plugin-libvisual* \ +gst-plugin-ogg* \ +gst-plugin-pango* \ +gst-plugin-playbin* \ +gst-plugin-subparse* \ +gst-plugin-tcp* \ +gst-plugin-theora* \ +gst-plugin-typefindfunctions* \ +gst-plugin-video4linux* \ +gst-plugin-videorate* \ +gst-plugin-videoscale* \ +gst-plugin-videotestsrc* \ +gst-plugin-volume* \ +gst-plugin-vorbis* \ +gst-plugin-ximagesink* \ +gst-plugin-xvimagesink* \ +" diff --git a/recipes/gstreamer/gstreamer/0001-add-GstQueryBuffers-query.patch b/recipes/gstreamer/gstreamer/0001-add-GstQueryBuffers-query.patch new file mode 100644 index 0000000000..bdc053afb6 --- /dev/null +++ b/recipes/gstreamer/gstreamer/0001-add-GstQueryBuffers-query.patch @@ -0,0 +1,810 @@ +From 45ef073f7c7748376f11ae2dea372eea6dc3a04a Mon Sep 17 00:00:00 2001 +From: Rob Clark +Date: Wed, 19 May 2010 15:48:09 -0500 +Subject: [PATCH 1/3] add GstQueryBuffers query + +This query is used by buffer allocator, for example a video sink element, +to find out any minimum buffer requirements of upstream elements that uses +pad_alloc() to allocate buffers. For example, some cameras may have need +for additional padding/boarder around the frame (for vstab), or some video +decoders may have requirements for a certain minimum number of buffers (so +they can hold refs to reference-frames) +--- + gst/gstquark.c | 3 +- + gst/gstquark.c.BACKUP.9714.c | 74 +++++++++++++++++++++ + gst/gstquark.c.BASE.9714.c | 69 +++++++++++++++++++ + gst/gstquark.c.LOCAL.9714.c | 69 +++++++++++++++++++ + gst/gstquark.c.REMOTE.9714.c | 70 ++++++++++++++++++++ + gst/gstquark.c.orig | 74 +++++++++++++++++++++ + gst/gstquark.h | 7 ++- + gst/gstquark.h.orig | 148 ++++++++++++++++++++++++++++++++++++++++++ + gst/gstquery.c | 141 ++++++++++++++++++++++++++++++++++++++++ + gst/gstquery.h | 16 ++++- + 10 files changed, 668 insertions(+), 3 deletions(-) + create mode 100644 gst/gstquark.c.BACKUP.9714.c + create mode 100644 gst/gstquark.c.BASE.9714.c + create mode 100644 gst/gstquark.c.LOCAL.9714.c + create mode 100644 gst/gstquark.c.REMOTE.9714.c + create mode 100644 gst/gstquark.c.orig + create mode 100644 gst/gstquark.h.orig + +diff --git a/gst/gstquark.c b/gst/gstquark.c +index 4073eb4..58badca 100644 +--- a/gst/gstquark.c ++++ b/gst/gstquark.c +@@ -49,7 +49,8 @@ static const gchar *_quark_strings[] = { + "GstQueryURI", "GstEventStep", "GstMessageStepDone", "amount", "flush", + "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", + "message", "GstMessageQOS", "running-time", "stream-time", "jitter", +- "quality", "processed", "dropped", "buffering-ranges" ++ "quality", "processed", "dropped", "buffering-ranges", "GstQueryBuffers", ++ "caps", "count", "width", "height" + }; + + GQuark _priv_gst_quark_table[GST_QUARK_MAX]; +diff --git a/gst/gstquark.c.BACKUP.9714.c b/gst/gstquark.c.BACKUP.9714.c +new file mode 100644 +index 0000000..e1fc9b1 +--- /dev/null ++++ b/gst/gstquark.c.BACKUP.9714.c +@@ -0,0 +1,74 @@ ++/* GStreamer ++ * Copyright (C) 2006 Jan Schmidt ++ * ++ * gstquark.c: Registered quarks for the _priv_gst_quark_table, private to ++ * GStreamer ++ * ++ * 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. ++ */ ++ ++#include "gst_private.h" ++#include "gstquark.h" ++ ++/* These strings must match order and number declared in the GstQuarkId ++ * enum in gstquark.h! */ ++static const gchar *_quark_strings[] = { ++ "format", "current", "duration", "rate", ++ "seekable", "segment-start", "segment-end", ++ "src_format", "src_value", "dest_format", "dest_value", ++ "start_format", "start_value", "stop_format", "stop_value", ++ "gerror", "debug", "buffer-percent", "buffering-mode", ++ "avg-in-rate", "avg-out-rate", "buffering-left", ++ "estimated-total", "old-state", "new-state", "pending-state", ++ "clock", "ready", "position", "new-base-time", "live", "min-latency", ++ "max-latency", "busy", "type", "owner", "update", "applied-rate", ++ "start", "stop", "minsize", "maxsize", "async", "proportion", ++ "diff", "timestamp", "flags", "cur-type", "cur", "stop-type", ++ "latency", "uri", "object", "taglist", "GstEventNewsegment", ++ "GstEventBufferSize", "GstEventQOS", "GstEventSeek", "GstEventLatency", ++ "GstMessageError", "GstMessageWarning", "GstMessageInfo", ++ "GstMessageBuffering", "GstMessageState", "GstMessageClockProvide", ++ "GstMessageClockLost", "GstMessageNewClock", "GstMessageStructureChange", ++ "GstMessageSegmentStart", "GstMessageSegmentDone", "GstMessageDuration", ++ "GstMessageAsyncStart", "GstMessageRequestState", "GstMessageStreamStatus", ++ "GstQueryPosition", "GstQueryDuration", "GstQueryLatency", "GstQueryConvert", ++ "GstQuerySegment", "GstQuerySeeking", "GstQueryFormats", "GstQueryBuffering", ++ "GstQueryURI", "GstEventStep", "GstMessageStepDone", "amount", "flush", ++ "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", ++ "message", "GstMessageQOS", "running-time", "stream-time", "jitter", ++<<<<<<< HEAD ++ "quality", "processed", "dropped", "buffering-ranges" ++======= ++ "quality", "processed", "dropped", "GstQueryBuffers", "caps", "count", ++ "width", "height" ++>>>>>>> 1ff1ed7... add GstQueryBuffers query ++}; ++ ++GQuark _priv_gst_quark_table[GST_QUARK_MAX]; ++ ++void ++_priv_gst_quarks_initialize (void) ++{ ++ gint i; ++ ++ if (G_N_ELEMENTS (_quark_strings) != GST_QUARK_MAX) ++ g_warning ("the quark table is not consistent! %d != %d", ++ (int) G_N_ELEMENTS (_quark_strings), GST_QUARK_MAX); ++ ++ for (i = 0; i < GST_QUARK_MAX; i++) { ++ _priv_gst_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); ++ } ++} +diff --git a/gst/gstquark.c.BASE.9714.c b/gst/gstquark.c.BASE.9714.c +new file mode 100644 +index 0000000..a4253a9 +--- /dev/null ++++ b/gst/gstquark.c.BASE.9714.c +@@ -0,0 +1,69 @@ ++/* GStreamer ++ * Copyright (C) 2006 Jan Schmidt ++ * ++ * gstquark.c: Registered quarks for the _priv_gst_quark_table, private to ++ * GStreamer ++ * ++ * 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. ++ */ ++ ++#include "gst_private.h" ++#include "gstquark.h" ++ ++/* These strings must match order and number declared in the GstQuarkId ++ * enum in gstquark.h! */ ++static const gchar *_quark_strings[] = { ++ "format", "current", "duration", "rate", ++ "seekable", "segment-start", "segment-end", ++ "src_format", "src_value", "dest_format", "dest_value", ++ "start_format", "start_value", "stop_format", "stop_value", ++ "gerror", "debug", "buffer-percent", "buffering-mode", ++ "avg-in-rate", "avg-out-rate", "buffering-left", ++ "estimated-total", "old-state", "new-state", "pending-state", ++ "clock", "ready", "position", "new-base-time", "live", "min-latency", ++ "max-latency", "busy", "type", "owner", "update", "applied-rate", ++ "start", "stop", "minsize", "maxsize", "async", "proportion", ++ "diff", "timestamp", "flags", "cur-type", "cur", "stop-type", ++ "latency", "uri", "object", "taglist", "GstEventNewsegment", ++ "GstEventBufferSize", "GstEventQOS", "GstEventSeek", "GstEventLatency", ++ "GstMessageError", "GstMessageWarning", "GstMessageInfo", ++ "GstMessageBuffering", "GstMessageState", "GstMessageClockProvide", ++ "GstMessageClockLost", "GstMessageNewClock", "GstMessageStructureChange", ++ "GstMessageSegmentStart", "GstMessageSegmentDone", "GstMessageDuration", ++ "GstMessageAsyncStart", "GstMessageRequestState", "GstMessageStreamStatus", ++ "GstQueryPosition", "GstQueryDuration", "GstQueryLatency", "GstQueryConvert", ++ "GstQuerySegment", "GstQuerySeeking", "GstQueryFormats", "GstQueryBuffering", ++ "GstQueryURI", "GstEventStep", "GstMessageStepDone", "amount", "flush", ++ "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", ++ "message", "GstMessageQOS", "running-time", "stream-time", "jitter", ++ "quality", "processed", "dropped" ++}; ++ ++GQuark _priv_gst_quark_table[GST_QUARK_MAX]; ++ ++void ++_priv_gst_quarks_initialize (void) ++{ ++ gint i; ++ ++ if (G_N_ELEMENTS (_quark_strings) != GST_QUARK_MAX) ++ g_warning ("the quark table is not consistent! %d != %d", ++ (int) G_N_ELEMENTS (_quark_strings), GST_QUARK_MAX); ++ ++ for (i = 0; i < GST_QUARK_MAX; i++) { ++ _priv_gst_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); ++ } ++} +diff --git a/gst/gstquark.c.LOCAL.9714.c b/gst/gstquark.c.LOCAL.9714.c +new file mode 100644 +index 0000000..4073eb4 +--- /dev/null ++++ b/gst/gstquark.c.LOCAL.9714.c +@@ -0,0 +1,69 @@ ++/* GStreamer ++ * Copyright (C) 2006 Jan Schmidt ++ * ++ * gstquark.c: Registered quarks for the _priv_gst_quark_table, private to ++ * GStreamer ++ * ++ * 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. ++ */ ++ ++#include "gst_private.h" ++#include "gstquark.h" ++ ++/* These strings must match order and number declared in the GstQuarkId ++ * enum in gstquark.h! */ ++static const gchar *_quark_strings[] = { ++ "format", "current", "duration", "rate", ++ "seekable", "segment-start", "segment-end", ++ "src_format", "src_value", "dest_format", "dest_value", ++ "start_format", "start_value", "stop_format", "stop_value", ++ "gerror", "debug", "buffer-percent", "buffering-mode", ++ "avg-in-rate", "avg-out-rate", "buffering-left", ++ "estimated-total", "old-state", "new-state", "pending-state", ++ "clock", "ready", "position", "new-base-time", "live", "min-latency", ++ "max-latency", "busy", "type", "owner", "update", "applied-rate", ++ "start", "stop", "minsize", "maxsize", "async", "proportion", ++ "diff", "timestamp", "flags", "cur-type", "cur", "stop-type", ++ "latency", "uri", "object", "taglist", "GstEventNewsegment", ++ "GstEventBufferSize", "GstEventQOS", "GstEventSeek", "GstEventLatency", ++ "GstMessageError", "GstMessageWarning", "GstMessageInfo", ++ "GstMessageBuffering", "GstMessageState", "GstMessageClockProvide", ++ "GstMessageClockLost", "GstMessageNewClock", "GstMessageStructureChange", ++ "GstMessageSegmentStart", "GstMessageSegmentDone", "GstMessageDuration", ++ "GstMessageAsyncStart", "GstMessageRequestState", "GstMessageStreamStatus", ++ "GstQueryPosition", "GstQueryDuration", "GstQueryLatency", "GstQueryConvert", ++ "GstQuerySegment", "GstQuerySeeking", "GstQueryFormats", "GstQueryBuffering", ++ "GstQueryURI", "GstEventStep", "GstMessageStepDone", "amount", "flush", ++ "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", ++ "message", "GstMessageQOS", "running-time", "stream-time", "jitter", ++ "quality", "processed", "dropped", "buffering-ranges" ++}; ++ ++GQuark _priv_gst_quark_table[GST_QUARK_MAX]; ++ ++void ++_priv_gst_quarks_initialize (void) ++{ ++ gint i; ++ ++ if (G_N_ELEMENTS (_quark_strings) != GST_QUARK_MAX) ++ g_warning ("the quark table is not consistent! %d != %d", ++ (int) G_N_ELEMENTS (_quark_strings), GST_QUARK_MAX); ++ ++ for (i = 0; i < GST_QUARK_MAX; i++) { ++ _priv_gst_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); ++ } ++} +diff --git a/gst/gstquark.c.REMOTE.9714.c b/gst/gstquark.c.REMOTE.9714.c +new file mode 100644 +index 0000000..7277593 +--- /dev/null ++++ b/gst/gstquark.c.REMOTE.9714.c +@@ -0,0 +1,70 @@ ++/* GStreamer ++ * Copyright (C) 2006 Jan Schmidt ++ * ++ * gstquark.c: Registered quarks for the _priv_gst_quark_table, private to ++ * GStreamer ++ * ++ * 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. ++ */ ++ ++#include "gst_private.h" ++#include "gstquark.h" ++ ++/* These strings must match order and number declared in the GstQuarkId ++ * enum in gstquark.h! */ ++static const gchar *_quark_strings[] = { ++ "format", "current", "duration", "rate", ++ "seekable", "segment-start", "segment-end", ++ "src_format", "src_value", "dest_format", "dest_value", ++ "start_format", "start_value", "stop_format", "stop_value", ++ "gerror", "debug", "buffer-percent", "buffering-mode", ++ "avg-in-rate", "avg-out-rate", "buffering-left", ++ "estimated-total", "old-state", "new-state", "pending-state", ++ "clock", "ready", "position", "new-base-time", "live", "min-latency", ++ "max-latency", "busy", "type", "owner", "update", "applied-rate", ++ "start", "stop", "minsize", "maxsize", "async", "proportion", ++ "diff", "timestamp", "flags", "cur-type", "cur", "stop-type", ++ "latency", "uri", "object", "taglist", "GstEventNewsegment", ++ "GstEventBufferSize", "GstEventQOS", "GstEventSeek", "GstEventLatency", ++ "GstMessageError", "GstMessageWarning", "GstMessageInfo", ++ "GstMessageBuffering", "GstMessageState", "GstMessageClockProvide", ++ "GstMessageClockLost", "GstMessageNewClock", "GstMessageStructureChange", ++ "GstMessageSegmentStart", "GstMessageSegmentDone", "GstMessageDuration", ++ "GstMessageAsyncStart", "GstMessageRequestState", "GstMessageStreamStatus", ++ "GstQueryPosition", "GstQueryDuration", "GstQueryLatency", "GstQueryConvert", ++ "GstQuerySegment", "GstQuerySeeking", "GstQueryFormats", "GstQueryBuffering", ++ "GstQueryURI", "GstEventStep", "GstMessageStepDone", "amount", "flush", ++ "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", ++ "message", "GstMessageQOS", "running-time", "stream-time", "jitter", ++ "quality", "processed", "dropped", "GstQueryBuffers", "caps", "count", ++ "width", "height" ++}; ++ ++GQuark _priv_gst_quark_table[GST_QUARK_MAX]; ++ ++void ++_priv_gst_quarks_initialize (void) ++{ ++ gint i; ++ ++ if (G_N_ELEMENTS (_quark_strings) != GST_QUARK_MAX) ++ g_warning ("the quark table is not consistent! %d != %d", ++ (int) G_N_ELEMENTS (_quark_strings), GST_QUARK_MAX); ++ ++ for (i = 0; i < GST_QUARK_MAX; i++) { ++ _priv_gst_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); ++ } ++} +diff --git a/gst/gstquark.c.orig b/gst/gstquark.c.orig +new file mode 100644 +index 0000000..e1fc9b1 +--- /dev/null ++++ b/gst/gstquark.c.orig +@@ -0,0 +1,74 @@ ++/* GStreamer ++ * Copyright (C) 2006 Jan Schmidt ++ * ++ * gstquark.c: Registered quarks for the _priv_gst_quark_table, private to ++ * GStreamer ++ * ++ * 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. ++ */ ++ ++#include "gst_private.h" ++#include "gstquark.h" ++ ++/* These strings must match order and number declared in the GstQuarkId ++ * enum in gstquark.h! */ ++static const gchar *_quark_strings[] = { ++ "format", "current", "duration", "rate", ++ "seekable", "segment-start", "segment-end", ++ "src_format", "src_value", "dest_format", "dest_value", ++ "start_format", "start_value", "stop_format", "stop_value", ++ "gerror", "debug", "buffer-percent", "buffering-mode", ++ "avg-in-rate", "avg-out-rate", "buffering-left", ++ "estimated-total", "old-state", "new-state", "pending-state", ++ "clock", "ready", "position", "new-base-time", "live", "min-latency", ++ "max-latency", "busy", "type", "owner", "update", "applied-rate", ++ "start", "stop", "minsize", "maxsize", "async", "proportion", ++ "diff", "timestamp", "flags", "cur-type", "cur", "stop-type", ++ "latency", "uri", "object", "taglist", "GstEventNewsegment", ++ "GstEventBufferSize", "GstEventQOS", "GstEventSeek", "GstEventLatency", ++ "GstMessageError", "GstMessageWarning", "GstMessageInfo", ++ "GstMessageBuffering", "GstMessageState", "GstMessageClockProvide", ++ "GstMessageClockLost", "GstMessageNewClock", "GstMessageStructureChange", ++ "GstMessageSegmentStart", "GstMessageSegmentDone", "GstMessageDuration", ++ "GstMessageAsyncStart", "GstMessageRequestState", "GstMessageStreamStatus", ++ "GstQueryPosition", "GstQueryDuration", "GstQueryLatency", "GstQueryConvert", ++ "GstQuerySegment", "GstQuerySeeking", "GstQueryFormats", "GstQueryBuffering", ++ "GstQueryURI", "GstEventStep", "GstMessageStepDone", "amount", "flush", ++ "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", ++ "message", "GstMessageQOS", "running-time", "stream-time", "jitter", ++<<<<<<< HEAD ++ "quality", "processed", "dropped", "buffering-ranges" ++======= ++ "quality", "processed", "dropped", "GstQueryBuffers", "caps", "count", ++ "width", "height" ++>>>>>>> 1ff1ed7... add GstQueryBuffers query ++}; ++ ++GQuark _priv_gst_quark_table[GST_QUARK_MAX]; ++ ++void ++_priv_gst_quarks_initialize (void) ++{ ++ gint i; ++ ++ if (G_N_ELEMENTS (_quark_strings) != GST_QUARK_MAX) ++ g_warning ("the quark table is not consistent! %d != %d", ++ (int) G_N_ELEMENTS (_quark_strings), GST_QUARK_MAX); ++ ++ for (i = 0; i < GST_QUARK_MAX; i++) { ++ _priv_gst_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); ++ } ++} +diff --git a/gst/gstquark.h b/gst/gstquark.h +index c95d9cd..f4c8e0f 100644 +--- a/gst/gstquark.h ++++ b/gst/gstquark.h +@@ -127,8 +127,13 @@ typedef enum _GstQuarkId + GST_QUARK_PROCESSED = 98, + GST_QUARK_DROPPED = 99, + GST_QUARK_BUFFERING_RANGES = 100, ++ GST_QUARK_QUERY_BUFFERS = 101, ++ GST_QUARK_CAPS = 102, ++ GST_QUARK_COUNT = 103, ++ GST_QUARK_WIDTH = 104, ++ GST_QUARK_HEIGHT = 105, + +- GST_QUARK_MAX = 101 ++ GST_QUARK_MAX = 106 + } GstQuarkId; + + extern GQuark _priv_gst_quark_table[GST_QUARK_MAX]; +diff --git a/gst/gstquark.h.orig b/gst/gstquark.h.orig +new file mode 100644 +index 0000000..1662daf +--- /dev/null ++++ b/gst/gstquark.h.orig +@@ -0,0 +1,148 @@ ++/* GStreamer ++ * Copyright (C) 2006 Jan Schmidt ++ * ++ * gstquark.h: Private header for storing quark info ++ * ++ * 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_QUARK_H__ ++#define __GST_QUARK_H__ ++ ++/* These enums need to match the number and order ++ * of strings declared in _quark_table, in gstquark.c */ ++typedef enum _GstQuarkId ++{ ++ GST_QUARK_FORMAT = 0, ++ GST_QUARK_CURRENT = 1, ++ GST_QUARK_DURATION = 2, ++ GST_QUARK_RATE = 3, ++ GST_QUARK_SEEKABLE = 4, ++ GST_QUARK_SEGMENT_START = 5, ++ GST_QUARK_SEGMENT_END = 6, ++ GST_QUARK_SRC_FORMAT = 7, ++ GST_QUARK_SRC_VALUE = 8, ++ GST_QUARK_DEST_FORMAT = 9, ++ GST_QUARK_DEST_VALUE = 10, ++ GST_QUARK_START_FORMAT = 11, ++ GST_QUARK_START_VALUE = 12, ++ GST_QUARK_STOP_FORMAT = 13, ++ GST_QUARK_STOP_VALUE = 14, ++ GST_QUARK_GERROR = 15, ++ GST_QUARK_DEBUG = 16, ++ GST_QUARK_BUFFER_PERCENT = 17, ++ GST_QUARK_BUFFERING_MODE = 18, ++ GST_QUARK_AVG_IN_RATE = 19, ++ GST_QUARK_AVG_OUT_RATE = 20, ++ GST_QUARK_BUFFERING_LEFT = 21, ++ GST_QUARK_ESTIMATED_TOTAL = 22, ++ GST_QUARK_OLD_STATE = 23, ++ GST_QUARK_NEW_STATE = 24, ++ GST_QUARK_PENDING_STATE = 25, ++ GST_QUARK_CLOCK = 26, ++ GST_QUARK_READY = 27, ++ GST_QUARK_POSITION = 28, ++ GST_QUARK_NEW_BASE_TIME = 29, ++ GST_QUARK_LIVE = 30, ++ GST_QUARK_MIN_LATENCY = 31, ++ GST_QUARK_MAX_LATENCY = 32, ++ GST_QUARK_BUSY = 33, ++ GST_QUARK_TYPE = 34, ++ GST_QUARK_OWNER = 35, ++ GST_QUARK_UPDATE = 36, ++ GST_QUARK_APPLIED_RATE = 37, ++ GST_QUARK_START = 38, ++ GST_QUARK_STOP = 39, ++ GST_QUARK_MINSIZE = 40, ++ GST_QUARK_MAXSIZE = 41, ++ GST_QUARK_ASYNC = 42, ++ GST_QUARK_PROPORTION = 43, ++ GST_QUARK_DIFF = 44, ++ GST_QUARK_TIMESTAMP = 45, ++ GST_QUARK_FLAGS = 46, ++ GST_QUARK_CUR_TYPE = 47, ++ GST_QUARK_CUR = 48, ++ GST_QUARK_STOP_TYPE = 49, ++ GST_QUARK_LATENCY = 50, ++ GST_QUARK_URI = 51, ++ GST_QUARK_OBJECT = 52, ++ GST_QUARK_TAGLIST = 53, ++ GST_QUARK_EVENT_NEWSEGMENT = 54, ++ GST_QUARK_EVENT_BUFFER_SIZE = 55, ++ GST_QUARK_EVENT_QOS = 56, ++ GST_QUARK_EVENT_SEEK = 57, ++ GST_QUARK_EVENT_LATENCY = 58, ++ GST_QUARK_MESSAGE_ERROR = 59, ++ GST_QUARK_MESSAGE_WARNING = 60, ++ GST_QUARK_MESSAGE_INFO = 61, ++ GST_QUARK_MESSAGE_BUFFERING = 62, ++ GST_QUARK_MESSAGE_STATE = 63, ++ GST_QUARK_MESSAGE_CLOCK_PROVIDE = 64, ++ GST_QUARK_MESSAGE_CLOCK_LOST = 65, ++ GST_QUARK_MESSAGE_NEW_CLOCK = 66, ++ GST_QUARK_MESSAGE_STRUCTURE_CHANGE = 67, ++ GST_QUARK_MESSAGE_SEGMENT_START = 68, ++ GST_QUARK_MESSAGE_SEGMENT_DONE = 69, ++ GST_QUARK_MESSAGE_DURATION = 70, ++ GST_QUARK_MESSAGE_ASYNC_START = 71, ++ GST_QUARK_MESSAGE_REQUEST_STATE = 72, ++ GST_QUARK_MESSAGE_STREAM_STATUS = 73, ++ GST_QUARK_QUERY_POSITION = 74, ++ GST_QUARK_QUERY_DURATION = 75, ++ GST_QUARK_QUERY_LATENCY = 76, ++ GST_QUARK_QUERY_CONVERT = 77, ++ GST_QUARK_QUERY_SEGMENT = 78, ++ GST_QUARK_QUERY_SEEKING = 79, ++ GST_QUARK_QUERY_FORMATS = 80, ++ GST_QUARK_QUERY_BUFFERING = 81, ++ GST_QUARK_QUERY_URI = 82, ++ GST_QUARK_EVENT_STEP = 83, ++ GST_QUARK_MESSAGE_STEP_DONE = 84, ++ GST_QUARK_AMOUNT = 85, ++ GST_QUARK_FLUSH = 86, ++ GST_QUARK_INTERMEDIATE = 87, ++ GST_QUARK_MESSAGE_STEP_START = 88, ++ GST_QUARK_ACTIVE = 89, ++ GST_QUARK_EOS = 90, ++ GST_QUARK_EVENT_SINK_MESSAGE = 91, ++ GST_QUARK_MESSAGE = 92, ++ GST_QUARK_MESSAGE_QOS = 93, ++ GST_QUARK_RUNNING_TIME = 94, ++ GST_QUARK_STREAM_TIME = 95, ++ GST_QUARK_JITTER = 96, ++ GST_QUARK_QUALITY = 97, ++ GST_QUARK_PROCESSED = 98, ++ GST_QUARK_DROPPED = 99, ++<<<<<<< HEAD ++ GST_QUARK_BUFFERING_RANGES = 100, ++ ++ GST_QUARK_MAX = 101 ++======= ++ GST_QUARK_QUERY_BUFFERS = 100, ++ GST_QUARK_CAPS = 101, ++ GST_QUARK_COUNT = 102, ++ GST_QUARK_WIDTH = 103, ++ GST_QUARK_HEIGHT = 104, ++ ++ GST_QUARK_MAX = 105 ++>>>>>>> 1ff1ed7... add GstQueryBuffers query ++} GstQuarkId; ++ ++extern GQuark _priv_gst_quark_table[GST_QUARK_MAX]; ++ ++#define GST_QUARK(q) _priv_gst_quark_table[GST_QUARK_##q] ++ ++#endif +diff --git a/gst/gstquery.c b/gst/gstquery.c +index 44ffa59..86e9f38 100644 +--- a/gst/gstquery.c ++++ b/gst/gstquery.c +@@ -94,6 +94,7 @@ static GstQueryTypeDefinition standard_definitions[] = { + {GST_QUERY_BUFFERING, "buffering", "Buffering status", 0}, + {GST_QUERY_CUSTOM, "custom", "Custom query", 0}, + {GST_QUERY_URI, "uri", "URI of the source or sink", 0}, ++ {GST_QUERY_BUFFERS, "buffers", "Minimum buffer requirements", 0}, + {0, NULL, NULL, 0} + }; + +@@ -1480,3 +1481,143 @@ gst_query_parse_uri (GstQuery * query, gchar ** uri) + *uri = g_value_dup_string (gst_structure_id_get_value (structure, + GST_QUARK (URI))); + } ++ ++/** ++ * gst_query_new_buffers: ++ * @caps: the #GstCaps for the buffers that are going to be allocated ++ * ++ * Constructs a new buffer requirements query object to query buffer ++ * requirements for a particular caps. Use gst_query_unref() when done ++ * with it. ++ * ++ * Returns: A #GstQuery ++ */ ++GstQuery * ++gst_query_new_buffers (GstCaps * caps) ++{ ++ GstQuery *query; ++ GstStructure *structure; ++ ++ /* XXX could add size here, for linear (non YUV/RGB) buffers? But I'm not ++ * entirely sure what is the use-case for that.. it should be easy enough ++ * to add more optional reply fields later ++ */ ++ structure = gst_structure_id_new (GST_QUARK (QUERY_BUFFERS), ++ GST_QUARK (CAPS), GST_TYPE_CAPS, caps, ++ GST_QUARK (COUNT), G_TYPE_INT, -1, ++ GST_QUARK (WIDTH), G_TYPE_INT, -1, ++ GST_QUARK (HEIGHT), G_TYPE_INT, -1, NULL); ++ ++ query = gst_query_new (GST_QUERY_BUFFERS, structure); ++ ++ return query; ++} ++ ++/** ++ * gst_query_set_buffers_count: ++ * @count: minimum number of buffers required ++ * ++ * Answer a buffers query by setting the minimum number of buffers required. ++ * If there is no minimum buffer count requirement, don't set this field in ++ * the query. ++ */ ++void ++gst_query_set_buffers_count (GstQuery * query, gint count) ++{ ++ GstStructure *structure; ++ ++ g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERS); ++ ++ structure = gst_query_get_structure (query); ++ gst_structure_id_set (structure, GST_QUARK (COUNT), G_TYPE_INT, count, NULL); ++} ++ ++/** ++ * gst_query_set_buffers_dimensions: ++ * @width: minimum buffer width ++ * @height: minimum buffer height ++ * ++ * Answer a buffers query by setting the minimum buffer dimensions required. ++ * If there is no minimum buffer dimensions (beyond the width/height specified ++ * in the #GstCaps), don't set this field in the query. ++ */ ++void ++gst_query_set_buffers_dimensions (GstQuery * query, gint width, gint height) ++{ ++ GstStructure *structure; ++ ++ g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERS); ++ ++ structure = gst_query_get_structure (query); ++ gst_structure_id_set (structure, ++ GST_QUARK (WIDTH), G_TYPE_INT, width, ++ GST_QUARK (HEIGHT), G_TYPE_INT, height, NULL); ++} ++ ++/** ++ * gst_query_parse_buffers_caps: ++ * @query: a #GstQuery ++ * @caps: the storage for the #GstCaps pointer, or NULL ++ * ++ * Parse a buffers query. ++ */ ++void ++gst_query_parse_buffers_caps (GstQuery * query, const GstCaps ** caps) ++{ ++ GstStructure *structure; ++ ++ g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERS); ++ ++ structure = gst_query_get_structure (query); ++ if (caps) ++ *caps = gst_value_get_caps (gst_structure_id_get_value (structure, ++ GST_QUARK (CAPS))); ++} ++ ++/** ++ * gst_query_parse_buffers_count: ++ * @query: a #GstQuery ++ * @count: the storage for minimum number of buffers, or NULL ++ * ++ * Parse a buffers query answer to see the minimum number of buffers ++ * required. A returned value of -1 means there is no minimum requirement ++ */ ++void ++gst_query_parse_buffers_count (GstQuery * query, gint * count) ++{ ++ GstStructure *structure; ++ ++ g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERS); ++ ++ structure = gst_query_get_structure (query); ++ if (count) ++ *count = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (COUNT))); ++} ++ ++/** ++ * gst_query_parse_buffers_dimensions: ++ * @query: a #GstQuery ++ * @width: the storage for minimum width, or NULL ++ * @height: the storage for minimum height, or NULL ++ * ++ * Parse a buffers query answer to see the minimum buffer dimensions required. ++ * A returned value of -1 for either dimension means there is no minimum ++ * requirement in that axis ++ */ ++void ++gst_query_parse_buffers_dimensions (GstQuery * query, gint * width, ++ gint * height) ++{ ++ GstStructure *structure; ++ ++ g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERS); ++ ++ structure = gst_query_get_structure (query); ++ if (width) ++ *width = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (WIDTH))); ++ if (height) ++ *height = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (HEIGHT))); ++} +diff --git a/gst/gstquery.h b/gst/gstquery.h +index 0284a29..e95d85b 100644 +--- a/gst/gstquery.h ++++ b/gst/gstquery.h +@@ -31,6 +31,7 @@ + #include + #include + #include ++#include + + G_BEGIN_DECLS + +@@ -51,6 +52,9 @@ G_BEGIN_DECLS + * @GST_QUERY_CUSTOM: a custom application or element defined query. Since + * 0.10.22. + * @GST_QUERY_URI: query the URI of the source or sink. Since 0.10.22. ++ * @GST_QUERY_BUFFERS: query the upstream users of pad_alloc()'d buffers to ++ * find any particular requirements about buffer size (padding) or numbers of ++ * buffers. Since ?.?.?. + * + * Standard predefined Query types + */ +@@ -69,7 +73,8 @@ typedef enum { + GST_QUERY_FORMATS, + GST_QUERY_BUFFERING, + GST_QUERY_CUSTOM, +- GST_QUERY_URI ++ GST_QUERY_URI, ++ GST_QUERY_BUFFERS + } GstQueryType; + + /** +@@ -332,6 +337,15 @@ GstQuery * gst_query_new_uri (void); + void gst_query_parse_uri (GstQuery *query, gchar **uri); + void gst_query_set_uri (GstQuery *query, const gchar *uri); + ++/* buffer requirements query */ ++GstQuery * gst_query_new_buffers (GstCaps * caps); ++void gst_query_set_buffers_count (GstQuery * query, gint count); ++void gst_query_set_buffers_dimensions (GstQuery * query, gint width, gint height); ++void gst_query_parse_buffers_caps (GstQuery * query, const GstCaps ** caps); ++void gst_query_parse_buffers_count (GstQuery * query, gint * count); ++void gst_query_parse_buffers_dimensions (GstQuery * query, gint * width, gint * height); ++ ++ + G_END_DECLS + + #endif /* __GST_QUERY_H__ */ +-- +1.6.6.1 + diff --git a/recipes/gstreamer/gstreamer/0002-gstevent-add-crop-event.patch b/recipes/gstreamer/gstreamer/0002-gstevent-add-crop-event.patch new file mode 100644 index 0000000000..44a3f7a138 --- /dev/null +++ b/recipes/gstreamer/gstreamer/0002-gstevent-add-crop-event.patch @@ -0,0 +1,199 @@ +From a3f0f0da45500e89fa005bd078b2a31ce7c8b9a1 Mon Sep 17 00:00:00 2001 +From: Rob Clark +Date: Mon, 24 May 2010 16:49:20 -0500 +Subject: [PATCH 2/3] gstevent: add crop event + +This replaces vstab event, and includes width/height as well. + +Note vstab event remains as wrapper for crop event for now for +compatibility. But once other trees are updated, vstab event +should be removed and the patch squashed with this. + +Signed-off-by: Daniel Diaz +--- + gst/gstevent.c | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + gst/gstevent.h | 15 +++++++++ + gst/gstquark.c | 2 +- + gst/gstquark.h | 5 ++- + 4 files changed, 112 insertions(+), 2 deletions(-) + +diff --git a/gst/gstevent.c b/gst/gstevent.c +index 3c1b0b9..96add3c 100644 +--- a/gst/gstevent.c ++++ b/gst/gstevent.c +@@ -116,6 +116,7 @@ static GstEventQuarks event_quarks[] = { + {GST_EVENT_TAG, "tag", 0}, + {GST_EVENT_BUFFERSIZE, "buffersize", 0}, + {GST_EVENT_SINK_MESSAGE, "sink-message", 0}, ++ {GST_EVENT_CROP, "crop", 0}, + {GST_EVENT_QOS, "qos", 0}, + {GST_EVENT_SEEK, "seek", 0}, + {GST_EVENT_NAVIGATION, "navigation", 0}, +@@ -1236,3 +1237,94 @@ gst_event_parse_sink_message (GstEvent * event, GstMessage ** msg) + GST_MESSAGE (gst_value_dup_mini_object (gst_structure_id_get_value + (structure, GST_QUARK (MESSAGE)))); + } ++ ++/** ++ * gst_event_new_vstab: ++ * @top: the new offset to top of sub-image ++ * @left: the new offset to left of sub-image ++ * ++ * Create a new vstab event. ++ */ ++GstEvent * ++gst_event_new_vstab (gint top, gint left) ++{ ++ return gst_event_new_crop (top, left, -1, -1); ++} ++ ++/** ++ * gst_event_parse_vstab: ++ * @event: The event to query ++ * @top: A pointer to store top offset in ++ * @left: A pointer to store left offset in ++ * ++ * Parse the vstab event. ++ */ ++void ++gst_event_parse_vstab (GstEvent * event, gint * top, gint * left) ++{ ++ gst_event_parse_crop (event, top, left, NULL, NULL); ++} ++ ++/* TODO remove vstab event functions.. use crop instead.. */ ++ ++/** ++ * gst_event_new_crop: ++ * @top: the new offset to top of sub-image ++ * @left: the new offset to left of sub-image ++ * @width: the new width ++ * @height: the new height ++ * ++ * Create a new vstab event. ++ */ ++GstEvent * ++gst_event_new_crop (gint top, gint left, gint width, gint height) ++{ ++ GstEvent *event; ++ GstStructure *structure; ++ ++ GST_CAT_INFO (GST_CAT_EVENT, "creating crop event: %d,%d %dx%d", ++ top, left, width, height); ++ ++ structure = gst_structure_id_new (GST_QUARK (EVENT_CROP), ++ GST_QUARK (TOP), G_TYPE_INT, top, ++ GST_QUARK (LEFT), G_TYPE_INT, left, ++ GST_QUARK (WIDTH), G_TYPE_INT, width, ++ GST_QUARK (HEIGHT), G_TYPE_INT, height, NULL); ++ event = gst_event_new_custom (GST_EVENT_CROP, structure); ++ ++ return event; ++} ++ ++/** ++ * gst_event_parse_vstab: ++ * @event: The event to query ++ * @top: A pointer to store top offset in ++ * @left: A pointer to store left offset in ++ * @width: A pointer to store width in ++ * @height: A pointer to store height in ++ * ++ * Parse the vstab event. ++ */ ++void ++gst_event_parse_crop (GstEvent * event, gint * top, gint * left, ++ gint * width, gint * height) ++{ ++ const GstStructure *structure; ++ ++ g_return_if_fail (GST_IS_EVENT (event)); ++ g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_CROP); ++ ++ structure = gst_event_get_structure (event); ++ if (top) ++ *top = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (TOP))); ++ if (left) ++ *left = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (LEFT))); ++ if (width) ++ *width = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (WIDTH))); ++ if (height) ++ *height = g_value_get_int (gst_structure_id_get_value (structure, ++ GST_QUARK (HEIGHT))); ++} +diff --git a/gst/gstevent.h b/gst/gstevent.h +index 7ee460d..e600e25 100644 +--- a/gst/gstevent.h ++++ b/gst/gstevent.h +@@ -93,6 +93,9 @@ typedef enum { + * @GST_EVENT_SINK_MESSAGE: An event that sinks turn into a message. Used to + * send messages that should be emitted in sync with + * rendering. ++ * @GST_EVENT_VSTAB: An event that can set horizontal (pan/scan) and vertical ++ * (tilt/scan) offset within a larger image. This event ++ * precedes the buffer to which it applies. + * @GST_EVENT_QOS: A quality message. Used to indicate to upstream elements + * that the downstream elements are being starved of or + * flooded with data. +@@ -133,6 +136,8 @@ typedef enum { + GST_EVENT_TAG = GST_EVENT_MAKE_TYPE (7, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), + GST_EVENT_BUFFERSIZE = GST_EVENT_MAKE_TYPE (8, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), + GST_EVENT_SINK_MESSAGE = GST_EVENT_MAKE_TYPE (9, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), ++ GST_EVENT_CROP = GST_EVENT_MAKE_TYPE (10, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), ++ GST_EVENT_VSTAB = GST_EVENT_CROP, + /* upstream events */ + GST_EVENT_QOS = GST_EVENT_MAKE_TYPE (15, FLAG(UPSTREAM)), + GST_EVENT_SEEK = GST_EVENT_MAKE_TYPE (16, FLAG(UPSTREAM)), +@@ -483,6 +488,16 @@ GstEvent* gst_event_new_step (GstFormat format, guint64 amoun + void gst_event_parse_step (GstEvent *event, GstFormat *format, guint64 *amount, + gdouble *rate, gboolean *flush, gboolean *intermediate); + ++/* vstab event */ ++GstEvent * gst_event_new_vstab (gint top, gint left); ++void gst_event_parse_vstab (GstEvent * event, gint * top, gint * left); ++ ++/* crop event */ ++GstEvent * gst_event_new_crop (gint top, gint left, gint width, gint height); ++void gst_event_parse_crop (GstEvent * event, gint * top, gint * left, ++ gint * width, gint * height); ++ ++ + G_END_DECLS + + #endif /* __GST_EVENT_H__ */ +diff --git a/gst/gstquark.c b/gst/gstquark.c +index 58badca..f8716cc 100644 +--- a/gst/gstquark.c ++++ b/gst/gstquark.c +@@ -50,7 +50,7 @@ static const gchar *_quark_strings[] = { + "intermediate", "GstMessageStepStart", "active", "eos", "sink-message", + "message", "GstMessageQOS", "running-time", "stream-time", "jitter", + "quality", "processed", "dropped", "buffering-ranges", "GstQueryBuffers", +- "caps", "count", "width", "height" ++ "caps", "count", "width", "height", "GstEventCrop", "top", "left" + }; + + GQuark _priv_gst_quark_table[GST_QUARK_MAX]; +diff --git a/gst/gstquark.h b/gst/gstquark.h +index f4c8e0f..6eeb77f 100644 +--- a/gst/gstquark.h ++++ b/gst/gstquark.h +@@ -132,8 +132,11 @@ typedef enum _GstQuarkId + GST_QUARK_COUNT = 103, + GST_QUARK_WIDTH = 104, + GST_QUARK_HEIGHT = 105, ++ GST_QUARK_EVENT_CROP = 106, ++ GST_QUARK_TOP = 107, ++ GST_QUARK_LEFT = 108, + +- GST_QUARK_MAX = 106 ++ GST_QUARK_MAX = 109 + } GstQuarkId; + + extern GQuark _priv_gst_quark_table[GST_QUARK_MAX]; +-- +1.6.6.1 + diff --git a/recipes/gstreamer/gstreamer/0003-basetransform-don-t-do-unnecessary-pad_alloc.patch b/recipes/gstreamer/gstreamer/0003-basetransform-don-t-do-unnecessary-pad_alloc.patch new file mode 100644 index 0000000000..114b9082fc --- /dev/null +++ b/recipes/gstreamer/gstreamer/0003-basetransform-don-t-do-unnecessary-pad_alloc.patch @@ -0,0 +1,52 @@ +From 380ca4382237afe8535ab8c3c44e64adb4d73e71 Mon Sep 17 00:00:00 2001 +From: Rob Clark +Date: Wed, 26 May 2010 14:42:40 -0500 +Subject: [PATCH 3/3] basetransform: don't do unnecessary pad_alloc() + +Don't allocate a buffer in passthrough mode. +--- + libs/gst/base/gstbasetransform.c | 28 ++++++++++++++++++++-------- + 1 files changed, 20 insertions(+), 8 deletions(-) + +diff --git a/libs/gst/base/gstbasetransform.c b/libs/gst/base/gstbasetransform.c +index 62731c5..dfc61a8 100644 +--- a/libs/gst/base/gstbasetransform.c ++++ b/libs/gst/base/gstbasetransform.c +@@ -2182,14 +2182,26 @@ gst_base_transform_handle_buffer (GstBaseTransform * trans, GstBuffer * inbuf, + + no_qos: + +- /* first try to allocate an output buffer based on the currently negotiated +- * format. While we call pad-alloc we could renegotiate the srcpad format or +- * have a new suggestion for upstream buffer-alloc. +- * In any case, outbuf will contain a buffer suitable for doing the configured +- * transform after this function. */ +- ret = gst_base_transform_prepare_output_buffer (trans, inbuf, outbuf); +- if (G_UNLIKELY (ret != GST_FLOW_OK)) +- goto no_buffer; ++ if (trans->passthrough) { ++ /* I'm not yet sure if we should bypass allocating output buffer in case of ++ * passthrough, or if I should override the prepare_output_buffer vmethod.. ++ * I think the argument for always doing buffer allocation is to give a ++ * chance for upstream caps-renegotiation.. except I think the existing ++ * gst_base_transform_buffer_alloc() which itself does a pad_alloc() should ++ * be sufficient.. ++ */ ++ GST_DEBUG_OBJECT (trans, "reuse input buffer"); ++ *outbuf = inbuf; ++ } else { ++ /* first try to allocate an output buffer based on the currently negotiated ++ * format. While we call pad-alloc we could renegotiate the srcpad format or ++ * have a new suggestion for upstream buffer-alloc. ++ * In any case, outbuf will contain a buffer suitable for doing the configured ++ * transform after this function. */ ++ ret = gst_base_transform_prepare_output_buffer (trans, inbuf, outbuf); ++ if (G_UNLIKELY (ret != GST_FLOW_OK)) ++ goto no_buffer; ++ } + + /* now perform the needed transform */ + if (trans->passthrough) { +-- +1.6.6.1 + diff --git a/recipes/gstreamer/gstreamer_0.10.32.bb b/recipes/gstreamer/gstreamer_0.10.32.bb new file mode 100644 index 0000000000..a48e407458 --- /dev/null +++ b/recipes/gstreamer/gstreamer_0.10.32.bb @@ -0,0 +1,13 @@ +require gstreamer.inc + +SRC_URI[archive.md5sum] = "442bc3d37b8511a73379143e7531d726" +SRC_URI[archive.sha256sum] = "3bf4e46a186ee9a1f5e212aaf651d67cffb4f5f05345a7c99ae71d5d992be133" + +SRC_URI += " \ + file://0001-add-GstQueryBuffers-query.patch;patch=1 \ + file://0002-gstevent-add-crop-event.patch;patch=1 \ + file://0003-basetransform-don-t-do-unnecessary-pad_alloc.patch;patch=1 \ +" + +EXTRA_OECONF += "ac_cv_func_register_printf_function=no" +