mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-30 05:31:15 +00:00
Code Issues 1 Projects Releases Wiki Activity

query: improve scheduling query

Browse source 
Turns some boolean arguments in the scheduling query to flags, which are easier
to extend and makes the code easier to read.
Make extra methods for configuring and querying the supported scheduling modes.
This should make it easier to add new modes later.
This commit is contained in:
Wim Taymans 2011-11-18 17:27:16 +01:00
parent 016d404ccf
commit 770159fb1c
11 changed files with 253 additions and 178 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
gst/gstpad.h
View file

@ -44,6 +44,22 @@ typedef enum {
GST_PAD_SINK GST_PAD_SINK
} GstPadDirection; } GstPadDirection;
/**
* GstPadMode:
* @GST_PAD_MODE_NONE: Pad will not handle dataflow
* @GST_PAD_MODE_PUSH: Pad handles dataflow in downstream push mode
* @GST_PAD_MODE_PULL: Pad handles dataflow in upstream pull mode
*
* The status of a GstPad. After activating a pad, which usually happens when the
* parent element goes from READY to PAUSED, the GstPadMode defines if the
* pad operates in push or pull mode.
*/
typedef enum {
GST_PAD_MODE_NONE,
GST_PAD_MODE_PUSH,
GST_PAD_MODE_PULL
} GstPadMode;
#include <gst/gstobject.h> #include <gst/gstobject.h>
#include <gst/gstbuffer.h> #include <gst/gstbuffer.h>
#include <gst/gstbufferlist.h> #include <gst/gstbufferlist.h>
@ -211,26 +227,11 @@ typedef enum {
*/ */
#define GST_PAD_LINK_CHECK_DEFAULT ((GstPadLinkCheck) (GST_PAD_LINK_CHECK_HIERARCHY | GST_PAD_LINK_CHECK_CAPS)) #define GST_PAD_LINK_CHECK_DEFAULT ((GstPadLinkCheck) (GST_PAD_LINK_CHECK_HIERARCHY | GST_PAD_LINK_CHECK_CAPS))
/**
* GstPadMode:
* @GST_PAD_MODE_NONE: Pad will not handle dataflow
* @GST_PAD_MODE_PUSH: Pad handles dataflow in downstream push mode
* @GST_PAD_MODE_PULL: Pad handles dataflow in upstream pull mode
*
* The status of a GstPad. After activating a pad, which usually happens when the
* parent element goes from READY to PAUSED, the GstPadMode defines if the
* pad operates in push or pull mode.
*/
typedef enum {
GST_PAD_MODE_NONE,
GST_PAD_MODE_PUSH,
GST_PAD_MODE_PULL
} GstPadMode;
/* pad states */ /* pad states */
/** /**
* GstPadActivateFunction: * GstPadActivateFunction:
* @pad: a #GstPad * @pad: a #GstPad
* @parent: the parent of @pad
* *
* This function is called when the pad is activated during the element * This function is called when the pad is activated during the element
* READY to PAUSED state change. By default this function will call the * READY to PAUSED state change. By default this function will call the
@ -243,6 +244,7 @@ typedef gboolean (*GstPadActivateFunction) (GstPad *pad, GstObject *parent);
/** /**
* GstPadActivateModeFunction: * GstPadActivateModeFunction:
* @pad: a #GstPad * @pad: a #GstPad
* @parent: the parent of @pad
* @active: activate or deactivate the pad. * @active: activate or deactivate the pad.
* *
* The prototype of the push and pull activate functions. * The prototype of the push and pull activate functions.

4
gst/gstquark.c
View file

@ -54,8 +54,8 @@ static const gchar *_quark_strings[] = {
"min-buffers", "max-buffers", "prefix", "postfix", "align", "time", "min-buffers", "max-buffers", "prefix", "postfix", "align", "time",
"GstQueryAllocation", "need-pool", "meta", "pool", "GstEventCaps", "GstQueryAllocation", "need-pool", "meta", "pool", "GstEventCaps",
"GstEventReconfigure", "segment", "GstQueryScheduling", "pull-mode", "GstEventReconfigure", "segment", "GstQueryScheduling", "pull-mode",
"random-access", "sequential", "allocator", "GstEventFlushStop", "options", "allocator", "GstEventFlushStop", "options", "GstQueryAcceptCaps",
"GstQueryAcceptCaps", "result", "GstQueryCaps", "filter" "result", "GstQueryCaps", "filter", "modes"
}; };
GQuark _priv_gst_quark_table[GST_QUARK_MAX]; GQuark _priv_gst_quark_table[GST_QUARK_MAX];

19
gst/gstquark.h
View file

@ -150,17 +150,16 @@ typedef enum _GstQuarkId
GST_QUARK_SEGMENT = 121, GST_QUARK_SEGMENT = 121,
GST_QUARK_QUERY_SCHEDULING = 122, GST_QUARK_QUERY_SCHEDULING = 122,
GST_QUARK_PULL_MODE = 123, GST_QUARK_PULL_MODE = 123,
GST_QUARK_RANDOM_ACCESS = 124, GST_QUARK_ALLOCATOR = 124,
GST_QUARK_SEQUENTIAL = 125, GST_QUARK_EVENT_FLUSH_STOP = 125,
GST_QUARK_ALLOCATOR = 126, GST_QUARK_OPTIONS = 126,
GST_QUARK_EVENT_FLUSH_STOP = 127, GST_QUARK_QUERY_ACCEPT_CAPS = 127,
GST_QUARK_OPTIONS = 128, GST_QUARK_RESULT = 128,
GST_QUARK_QUERY_ACCEPT_CAPS = 129, GST_QUARK_QUERY_CAPS = 129,
GST_QUARK_RESULT = 130, GST_QUARK_FILTER = 130,
GST_QUARK_QUERY_CAPS = 131, GST_QUARK_MODES = 131,
GST_QUARK_FILTER = 132,
GST_QUARK_MAX = 133 GST_QUARK_MAX = 132
} GstQuarkId; } GstQuarkId;
extern GQuark _priv_gst_quark_table[GST_QUARK_MAX]; extern GQuark _priv_gst_quark_table[GST_QUARK_MAX];

325
gst/gstquery.c
View file

@ -963,6 +963,28 @@ gst_query_parse_seeking (GstQuery * query, GstFormat * format,
GST_QUARK (SEGMENT_END))); GST_QUARK (SEGMENT_END)));
} }
static GValueArray *
ensure_array (GstStructure * s, GQuark quark)
{
GValueArray *array;
const GValue *value;
value = gst_structure_id_get_value (s, quark);
if (value) {
array = (GValueArray *) g_value_get_boxed (value);
} else {
GValue new_array_val = { 0, };
array = g_value_array_new (0);
g_value_init (&new_array_val, G_TYPE_VALUE_ARRAY);
g_value_take_boxed (&new_array_val, array);
gst_structure_id_take_value (s, quark, &new_array_val);
}
return array;
}
/** /**
* gst_query_new_formats: * gst_query_new_formats:
* *
@ -1375,9 +1397,7 @@ gboolean
gst_query_add_buffering_range (GstQuery * query, gint64 start, gint64 stop) gst_query_add_buffering_range (GstQuery * query, gint64 start, gint64 stop)
{ {
GValueArray *array; GValueArray *array;
GValue *last_array_value; GValue value = { 0 };
const GValue *value;
GValue range_value = { 0 };
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, FALSE); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, FALSE);
@ -1387,30 +1407,19 @@ gst_query_add_buffering_range (GstQuery * query, gint64 start, gint64 stop)
return FALSE; return FALSE;
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (BUFFERING_RANGES)); array = ensure_array (structure, GST_QUARK (BUFFERING_RANGES));
if (value) { if (array->n_values > 1) {
array = (GValueArray *) g_value_get_boxed (value); GValue *last_array_value;
last_array_value = g_value_array_get_nth (array, array->n_values - 1); last_array_value = g_value_array_get_nth (array, array->n_values - 1);
if (G_UNLIKELY (start <= gst_value_get_int64_range_min (last_array_value))) if (G_UNLIKELY (start <= gst_value_get_int64_range_min (last_array_value)))
return FALSE; return FALSE;
} else {
GValue new_array_val = { 0, };
array = g_value_array_new (0);
g_value_init (&new_array_val, G_TYPE_VALUE_ARRAY);
g_value_take_boxed (&new_array_val, array);
/* set the value array only once, so we then modify (append to) the
* existing value array owned by the GstStructure / the field's GValue */
gst_structure_id_take_value (structure, GST_QUARK (BUFFERING_RANGES),
&new_array_val);
} }
g_value_init (&range_value, GST_TYPE_INT64_RANGE); g_value_init (&value, GST_TYPE_INT64_RANGE);
gst_value_set_int64_range (&range_value, start, stop); gst_value_set_int64_range (&value, start, stop);
g_value_array_append (array, &range_value); g_value_array_append (array, &value);
/* skip the g_value_unset(&range_value) here, we know it's not needed */ /* skip the g_value_unset(&value) here, we know it's not needed */
return TRUE; return TRUE;
} }
@ -1430,19 +1439,14 @@ guint
gst_query_get_n_buffering_ranges (GstQuery * query) gst_query_get_n_buffering_ranges (GstQuery * query)
{ {
GValueArray *array; GValueArray *array;
const GValue *value;
guint size = 0;
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, 0); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, 0);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (BUFFERING_RANGES)); array = ensure_array (structure, GST_QUARK (BUFFERING_RANGES));
if (value) {
array = (GValueArray *) g_value_get_boxed (value); return array->n_values;
size = array->n_values;
}
return size;
} }
@ -1464,23 +1468,21 @@ gboolean
gst_query_parse_nth_buffering_range (GstQuery * query, guint index, gst_query_parse_nth_buffering_range (GstQuery * query, guint index,
gint64 * start, gint64 * stop) gint64 * start, gint64 * stop)
{ {
GValueArray *array;
const GValue *value; const GValue *value;
GValueArray *ranges;
GValue *range_value;
gboolean ret = FALSE; gboolean ret = FALSE;
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, ret); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, ret);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (BUFFERING_RANGES)); array = ensure_array (structure, GST_QUARK (BUFFERING_RANGES));
ranges = (GValueArray *) g_value_get_boxed (value);
range_value = g_value_array_get_nth (ranges, index); if ((value = g_value_array_get_nth (array, index))) {
if (range_value) {
if (start) if (start)
*start = gst_value_get_int64_range_min (range_value); *start = gst_value_get_int64_range_min (value);
if (stop) if (stop)
*stop = gst_value_get_int64_range_max (range_value); *stop = gst_value_get_int64_range_max (value);
ret = TRUE; ret = TRUE;
} }
@ -1684,7 +1686,6 @@ void
gst_query_add_allocation_meta (GstQuery * query, const gchar * api) gst_query_add_allocation_meta (GstQuery * query, const gchar * api)
{ {
GValueArray *array; GValueArray *array;
const GValue *value;
GValue api_value = { 0 }; GValue api_value = { 0 };
GstStructure *structure; GstStructure *structure;
@ -1693,19 +1694,7 @@ gst_query_add_allocation_meta (GstQuery * query, const gchar * api)
g_return_if_fail (gst_query_is_writable (query)); g_return_if_fail (gst_query_is_writable (query));
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (META)); array = ensure_array (structure, GST_QUARK (META));
if (value) {
array = (GValueArray *) g_value_get_boxed (value);
} else {
GValue new_array_val = { 0, };
array = g_value_array_new (0);
g_value_init (&new_array_val, G_TYPE_VALUE_ARRAY);
g_value_take_boxed (&new_array_val, array);
gst_structure_id_take_value (structure, GST_QUARK (META), &new_array_val);
}
g_value_init (&api_value, G_TYPE_STRING); g_value_init (&api_value, G_TYPE_STRING);
g_value_set_string (&api_value, api); g_value_set_string (&api_value, api);
@ -1726,19 +1715,14 @@ guint
gst_query_get_n_allocation_metas (GstQuery * query) gst_query_get_n_allocation_metas (GstQuery * query)
{ {
GValueArray *array; GValueArray *array;
const GValue *value;
guint size = 0;
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (META)); array = ensure_array (structure, GST_QUARK (META));
if (value) {
array = (GValueArray *) g_value_get_boxed (value); return array->n_values;
size = array->n_values;
}
return size;
} }
/** /**
@ -1754,24 +1738,19 @@ gst_query_get_n_allocation_metas (GstQuery * query)
const gchar * const gchar *
gst_query_parse_nth_allocation_meta (GstQuery * query, guint index) gst_query_parse_nth_allocation_meta (GstQuery * query, guint index)
{ {
const GValue *value; GValueArray *array;
GValue *value;
const gchar *ret = NULL; const gchar *ret = NULL;
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, NULL); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, NULL);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (META)); array = ensure_array (structure, GST_QUARK (META));
if (value) {
GValueArray *meta;
GValue *api_value;
meta = (GValueArray *) g_value_get_boxed (value); if ((value = g_value_array_get_nth (array, index)))
api_value = g_value_array_get_nth (meta, index); ret = g_value_get_string (value);
if (api_value)
ret = g_value_get_string (api_value);
}
return ret; return ret;
} }
@ -1787,25 +1766,21 @@ gst_query_parse_nth_allocation_meta (GstQuery * query, guint index)
gboolean gboolean
gst_query_has_allocation_meta (GstQuery * query, const gchar * api) gst_query_has_allocation_meta (GstQuery * query, const gchar * api)
{ {
const GValue *value; GValueArray *array;
GValue *value;
GstStructure *structure; GstStructure *structure;
guint i;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, FALSE); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, FALSE);
g_return_val_if_fail (api != NULL, FALSE); g_return_val_if_fail (api != NULL, FALSE);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (META)); array = ensure_array (structure, GST_QUARK (META));
if (value) {
GValueArray *array;
GValue *api_value;
guint i;
array = (GValueArray *) g_value_get_boxed (value); for (i = 0; i < array->n_values; i++) {
for (i = 0; i < array->n_values; i++) { value = g_value_array_get_nth (array, i);
api_value = g_value_array_get_nth (array, i); if (!strcmp (api, g_value_get_string (value)))
if (!strcmp (api, g_value_get_string (api_value))) return TRUE;
return TRUE;
}
} }
return FALSE; return FALSE;
} }
@ -1821,33 +1796,19 @@ void
gst_query_add_allocation_memory (GstQuery * query, const gchar * alloc) gst_query_add_allocation_memory (GstQuery * query, const gchar * alloc)
{ {
GValueArray *array; GValueArray *array;
const GValue *value; GValue value = { 0 };
GValue alloc_value = { 0 };
GstStructure *structure; GstStructure *structure;
g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION); g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
g_return_if_fail (gst_query_is_writable (query)); g_return_if_fail (gst_query_is_writable (query));
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (ALLOCATOR)); array = ensure_array (structure, GST_QUARK (ALLOCATOR));
if (value) {
array = (GValueArray *) g_value_get_boxed (value);
} else {
GValue new_array_val = { 0, };
array = g_value_array_new (0); g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, alloc);
g_value_init (&new_array_val, G_TYPE_VALUE_ARRAY); g_value_array_append (array, &value);
g_value_take_boxed (&new_array_val, array); g_value_unset (&value);
gst_structure_id_take_value (structure, GST_QUARK (ALLOCATOR),
&new_array_val);
}
g_value_init (&alloc_value, G_TYPE_STRING);
g_value_set_string (&alloc_value, alloc);
g_value_array_append (array, &alloc_value);
g_value_unset (&alloc_value);
} }
/** /**
@ -1866,19 +1827,14 @@ guint
gst_query_get_n_allocation_memories (GstQuery * query) gst_query_get_n_allocation_memories (GstQuery * query)
{ {
GValueArray *array; GValueArray *array;
const GValue *value;
guint size = 0;
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (ALLOCATOR)); array = ensure_array (structure, GST_QUARK (ALLOCATOR));
if (value) {
array = (GValueArray *) g_value_get_boxed (value); return array->n_values;
size = array->n_values;
}
return size;
} }
/** /**
@ -1894,24 +1850,19 @@ gst_query_get_n_allocation_memories (GstQuery * query)
const gchar * const gchar *
gst_query_parse_nth_allocation_memory (GstQuery * query, guint index) gst_query_parse_nth_allocation_memory (GstQuery * query, guint index)
{ {
const GValue *value; GValueArray *array;
GValue *value;
const gchar *ret = NULL; const gchar *ret = NULL;
GstStructure *structure; GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, NULL); g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, NULL);
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
value = gst_structure_id_get_value (structure, GST_QUARK (ALLOCATOR)); array = ensure_array (structure, GST_QUARK (ALLOCATOR));
if (value) {
GValueArray *memory;
GValue *alloc_value;
memory = (GValueArray *) g_value_get_boxed (value); if ((value = g_value_array_get_nth (array, index)))
alloc_value = g_value_array_get_nth (memory, index); ret = g_value_get_string (value);
if (alloc_value)
ret = g_value_get_string (alloc_value);
}
return ret; return ret;
} }
@ -1931,9 +1882,7 @@ gst_query_new_scheduling (void)
GstStructure *structure; GstStructure *structure;
structure = gst_structure_new_id (GST_QUARK (QUERY_SCHEDULING), structure = gst_structure_new_id (GST_QUARK (QUERY_SCHEDULING),
GST_QUARK (PULL_MODE), G_TYPE_BOOLEAN, FALSE, GST_QUARK (FLAGS), GST_TYPE_SCHEDULING_FLAGS, 0,
GST_QUARK (RANDOM_ACCESS), G_TYPE_BOOLEAN, FALSE,
GST_QUARK (SEQUENTIAL), G_TYPE_BOOLEAN, TRUE,
GST_QUARK (MINSIZE), G_TYPE_INT, 1, GST_QUARK (MINSIZE), G_TYPE_INT, 1,
GST_QUARK (MAXSIZE), G_TYPE_INT, -1, GST_QUARK (MAXSIZE), G_TYPE_INT, -1,
GST_QUARK (ALIGN), G_TYPE_INT, 1, NULL); GST_QUARK (ALIGN), G_TYPE_INT, 1, NULL);
@ -1945,9 +1894,7 @@ gst_query_new_scheduling (void)
/** /**
* gst_query_set_scheduling * gst_query_set_scheduling
* @query: A valid #GstQuery of type GST_QUERY_SCHEDULING. * @query: A valid #GstQuery of type GST_QUERY_SCHEDULING.
* @pull_mode: if pull mode scheduling is supported * @flags: #GstSchedulingFlags
* @random_access: if random access is possible
* @sequential: if sequential access is recommended
* @minsize: the suggested minimum size of pull requests * @minsize: the suggested minimum size of pull requests
* @maxsize: the suggested maximum size of pull requests * @maxsize: the suggested maximum size of pull requests
* @align: the suggested alignment of pull requests * @align: the suggested alignment of pull requests
@ -1955,8 +1902,7 @@ gst_query_new_scheduling (void)
* Set the scheduling properties. * Set the scheduling properties.
*/ */
void void
gst_query_set_scheduling (GstQuery * query, gboolean pull_mode, gst_query_set_scheduling (GstQuery * query, GstSchedulingFlags flags,
gboolean random_access, gboolean sequential,
gint minsize, gint maxsize, gint align) gint minsize, gint maxsize, gint align)
{ {
GstStructure *structure; GstStructure *structure;
@ -1966,9 +1912,7 @@ gst_query_set_scheduling (GstQuery * query, gboolean pull_mode,
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
gst_structure_id_set (structure, gst_structure_id_set (structure,
GST_QUARK (PULL_MODE), G_TYPE_BOOLEAN, pull_mode, GST_QUARK (FLAGS), GST_TYPE_SCHEDULING_FLAGS, flags,
GST_QUARK (RANDOM_ACCESS), G_TYPE_BOOLEAN, random_access,
GST_QUARK (SEQUENTIAL), G_TYPE_BOOLEAN, sequential,
GST_QUARK (MINSIZE), G_TYPE_INT, minsize, GST_QUARK (MINSIZE), G_TYPE_INT, minsize,
GST_QUARK (MAXSIZE), G_TYPE_INT, maxsize, GST_QUARK (MAXSIZE), G_TYPE_INT, maxsize,
GST_QUARK (ALIGN), G_TYPE_INT, align, NULL); GST_QUARK (ALIGN), G_TYPE_INT, align, NULL);
@ -1977,9 +1921,7 @@ gst_query_set_scheduling (GstQuery * query, gboolean pull_mode,
/** /**
* gst_query_parse_scheduling * gst_query_parse_scheduling
* @query: A valid #GstQuery of type GST_QUERY_SCHEDULING. * @query: A valid #GstQuery of type GST_QUERY_SCHEDULING.
* @pull_mode: if pull mode scheduling is supported * @flags: #GstSchedulingFlags
* @random_access: if random access is possible
* @sequential: if sequential access is recommended
* @minsize: the suggested minimum size of pull requests * @minsize: the suggested minimum size of pull requests
* @maxsize: the suggested maximum size of pull requests: * @maxsize: the suggested maximum size of pull requests:
* @align: the suggested alignment of pull requests * @align: the suggested alignment of pull requests
@ -1987,8 +1929,7 @@ gst_query_set_scheduling (GstQuery * query, gboolean pull_mode,
* Set the scheduling properties. * Set the scheduling properties.
*/ */
void void
gst_query_parse_scheduling (GstQuery * query, gboolean * pull_mode, gst_query_parse_scheduling (GstQuery * query, GstSchedulingFlags * flags,
gboolean * random_access, gboolean * sequential,
gint * minsize, gint * maxsize, gint * align) gint * minsize, gint * maxsize, gint * align)
{ {
GstStructure *structure; GstStructure *structure;
@ -1997,14 +1938,120 @@ gst_query_parse_scheduling (GstQuery * query, gboolean * pull_mode,
structure = GST_QUERY_STRUCTURE (query); structure = GST_QUERY_STRUCTURE (query);
gst_structure_id_get (structure, gst_structure_id_get (structure,
GST_QUARK (PULL_MODE), G_TYPE_BOOLEAN, pull_mode, GST_QUARK (FLAGS), GST_TYPE_SCHEDULING_FLAGS, flags,
GST_QUARK (RANDOM_ACCESS), G_TYPE_BOOLEAN, random_access,
GST_QUARK (SEQUENTIAL), G_TYPE_BOOLEAN, sequential,
GST_QUARK (MINSIZE), G_TYPE_INT, minsize, GST_QUARK (MINSIZE), G_TYPE_INT, minsize,
GST_QUARK (MAXSIZE), G_TYPE_INT, maxsize, GST_QUARK (MAXSIZE), G_TYPE_INT, maxsize,
GST_QUARK (ALIGN), G_TYPE_INT, align, NULL); GST_QUARK (ALIGN), G_TYPE_INT, align, NULL);
} }
/**
* gst_query_add_scheduling_mode
* @query: a GST_QUERY_SCHEDULING type query #GstQuery
* @mode: a #GstPadMode
*
* Add @mode as aone of the supported scheduling modes to @query.
*/
void
gst_query_add_scheduling_mode (GstQuery * query, GstPadMode mode)
{
GValueArray *array;
GValue value = { 0 };
GstStructure *structure;
g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING);
g_return_if_fail (gst_query_is_writable (query));
structure = GST_QUERY_STRUCTURE (query);
array = ensure_array (structure, GST_QUARK (MODES));
g_value_init (&value, GST_TYPE_PAD_MODE);
g_value_set_enum (&value, mode);
g_value_array_append (array, &value);
g_value_unset (&value);
}
/**
* gst_query_get_n_scheduling_modes:
* @query: a GST_QUERY_SCHEDULING type query #GstQuery
*
* Retrieve the number of values currently stored in the
* scheduling mode array of the query's structure.
*
* Returns: the scheduling mode array size as a #guint.
*/
guint
gst_query_get_n_scheduling_modes (GstQuery * query)
{
GValueArray *array;
GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING, 0);
structure = GST_QUERY_STRUCTURE (query);
array = ensure_array (structure, GST_QUARK (MODES));
return array->n_values;
}
/**
* gst_query_parse_nth_scheduling_mode
* @query: a GST_QUERY_SCHEDULING type query #GstQuery
* @index: position in the scheduling modes array to read
*
* Parse an available query and get the scheduling mode
* at @index of the scheduling modes array.
*
* Returns: a #GstPadMode of the scheduling mode at @index.
*/
GstPadMode
gst_query_parse_nth_scheduling_mode (GstQuery * query, guint index)
{
GValueArray *array;
GValue *value;
GstPadMode ret = GST_PAD_MODE_NONE;
GstStructure *structure;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING, ret);
structure = GST_QUERY_STRUCTURE (query);
array = ensure_array (structure, GST_QUARK (MODES));
if ((value = g_value_array_get_nth (array, index)))
ret = g_value_get_enum (value);
return ret;
}
/**
* gst_query_has_scheduling_mode
* @query: a GST_QUERY_SCHEDULING type query #GstQuery
* @mode: the scheduling mode
*
* Check if @query has scheduling mode set.
*
* Returns: TRUE when @mode is in the list of scheduling modes.
*/
gboolean
gst_query_has_scheduling_mode (GstQuery * query, GstPadMode mode)
{
GValueArray *array;
GValue *value;
GstStructure *structure;
guint i;
g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING, FALSE);
structure = GST_QUERY_STRUCTURE (query);
array = ensure_array (structure, GST_QUARK (MODES));
for (i = 0; i < array->n_values; i++) {
value = g_value_array_get_nth (array, i);
if (mode == g_value_get_enum (value))
return TRUE;
}
return FALSE;
}
/** /**
* gst_query_new_accept_caps * gst_query_new_accept_caps
* @caps: a #GstCaps * @caps: a #GstCaps

24
gst/gstquery.h
View file

@ -374,14 +374,30 @@ guint gst_query_get_n_allocation_memories (GstQuery *query);
const gchar * gst_query_parse_nth_allocation_memory (GstQuery *query, guint index); const gchar * gst_query_parse_nth_allocation_memory (GstQuery *query, guint index);
/* scheduling query */ /* scheduling query */
/**
* GstSchedulingFlags:
* @GST_SCHEDULING_FLAG_SEEKABLE: if seeking is possible
* @GST_SCHEDULING_FLAG_SEQUENTIAL: if sequential access is recommended
*
* The different scheduling flags.
*/
typedef enum {
GST_SCHEDULING_FLAG_SEEKABLE = (1 << 0),
GST_SCHEDULING_FLAG_SEQUENTIAL = (1 << 1)
} GstSchedulingFlags;
GstQuery * gst_query_new_scheduling (void); GstQuery * gst_query_new_scheduling (void);
void gst_query_set_scheduling (GstQuery *query, gboolean pull_mode, void gst_query_set_scheduling (GstQuery *query, GstSchedulingFlags flags,
gboolean random_access, gboolean sequential,
gint minsize, gint maxsize, gint align); gint minsize, gint maxsize, gint align);
void gst_query_parse_scheduling (GstQuery *query, gboolean *pull_mode, void gst_query_parse_scheduling (GstQuery *query, GstSchedulingFlags *flags,
gboolean *random_access, gboolean *sequential,
gint *minsize, gint *maxsize, gint *align); gint *minsize, gint *maxsize, gint *align);
void gst_query_add_scheduling_mode (GstQuery *query, GstPadMode mode);
guint gst_query_get_n_scheduling_modes (GstQuery *query);
GstPadMode gst_query_parse_nth_scheduling_mode (GstQuery *query, guint index);
gboolean gst_query_has_scheduling_mode (GstQuery *query, GstPadMode mode);
/* accept-caps query */ /* accept-caps query */
GstQuery * gst_query_new_accept_caps (GstCaps *caps); GstQuery * gst_query_new_accept_caps (GstCaps *caps);
void gst_query_parse_accept_caps (GstQuery *query, GstCaps **caps); void gst_query_parse_accept_caps (GstQuery *query, GstCaps **caps);

3
libs/gst/base/gstbaseparse.c
View file

@ -2949,8 +2949,7 @@ gst_base_parse_sink_activate (GstPad * sinkpad, GstObject * parent)
query = gst_query_new_scheduling (); query = gst_query_new_scheduling ();
result = gst_pad_peer_query (sinkpad, query); result = gst_pad_peer_query (sinkpad, query);
if (result) { if (result) {
gst_query_parse_scheduling (query, &pull_mode, NULL, NULL, NULL, NULL, pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
NULL);
} else { } else {
pull_mode = FALSE; pull_mode = FALSE;
} }

2
libs/gst/base/gstbasesink.c
View file

@ -4144,7 +4144,7 @@ gst_base_sink_pad_activate (GstPad * pad, GstObject * parent)
} }
/* parse result of the query */ /* parse result of the query */
gst_query_parse_scheduling (query, &pull_mode, NULL, NULL, NULL, NULL, NULL); pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
gst_query_unref (query); gst_query_unref (query);
if (!pull_mode) { if (!pull_mode) {

5
libs/gst/base/gstbasesrc.c
View file

@ -1117,7 +1117,10 @@ gst_base_src_default_query (GstBaseSrc * src, GstQuery * query)
/* we can operate in getrange mode if the native format is bytes /* we can operate in getrange mode if the native format is bytes
* and we are seekable, this condition is set in the random_access * and we are seekable, this condition is set in the random_access
* flag and is set in the _start() method. */ * flag and is set in the _start() method. */
gst_query_set_scheduling (query, random_access, TRUE, FALSE, 1, -1, 1); gst_query_set_scheduling (query, GST_SCHEDULING_FLAG_SEEKABLE, 1, -1, 0);
if (random_access)
gst_query_add_scheduling_mode (query, GST_PAD_MODE_PULL);
gst_query_add_scheduling_mode (query, GST_PAD_MODE_PUSH);
res = TRUE; res = TRUE;
break; break;

5
libs/gst/base/gstpushsrc.c
View file

@ -104,7 +104,10 @@ gst_push_src_query (GstBaseSrc * src, GstQuery * query)
{ {
/* a pushsrc can by default never operate in pull mode override /* a pushsrc can by default never operate in pull mode override
* if you want something different. */ * if you want something different. */
gst_query_set_scheduling (query, FALSE, FALSE, TRUE, 1, -1, 1); gst_query_set_scheduling (query, GST_SCHEDULING_FLAG_SEQUENTIAL, 1, -1,
0);
gst_query_add_scheduling_mode (query, GST_PAD_MODE_PUSH);
ret = TRUE; ret = TRUE;
break; break;
} }

8
plugins/elements/gstqueue2.c
View file

@ -2556,11 +2556,17 @@ gst_queue2_handle_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
case GST_QUERY_SCHEDULING: case GST_QUERY_SCHEDULING:
{ {
gboolean pull_mode; gboolean pull_mode;
GstSchedulingFlags flags = 0;
/* we can operate in pull mode when we are using a tempfile */ /* we can operate in pull mode when we are using a tempfile */
pull_mode = !QUEUE_IS_USING_QUEUE (queue); pull_mode = !QUEUE_IS_USING_QUEUE (queue);
gst_query_set_scheduling (query, pull_mode, pull_mode, FALSE, 0, -1, 1); if (pull_mode)
flags |= GST_SCHEDULING_FLAG_SEEKABLE;
gst_query_set_scheduling (query, flags, 0, -1, 0);
if (pull_mode)
gst_query_add_scheduling_mode (query, GST_PAD_MODE_PULL);
gst_query_add_scheduling_mode (query, GST_PAD_MODE_PUSH);
break; break;
} }
default: default:

2
plugins/elements/gsttypefindelement.c
View file

@ -923,7 +923,7 @@ gst_type_find_element_activate (GstPad * pad, GstObject * parent)
goto typefind_push; goto typefind_push;
} }
gst_query_parse_scheduling (query, &pull_mode, NULL, NULL, NULL, NULL, NULL); pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
gst_query_unref (query); gst_query_unref (query);
if (!pull_mode) if (!pull_mode)