static gboolean
_gst_param_fraction_validate (GParamSpec * pspec, GValue * value)
{
GstParamSpecFraction *fspec = GST_PARAM_SPEC_FRACTION (pspec);
gboolean within_range = FALSE;
GValue f_this = { 0, };
GValue f_min = { 0, };
GValue f_max = { 0, };
gint res;
g_value_init (&f_this, GST_TYPE_FRACTION);
gst_value_set_fraction (&f_this, value->data[0].v_int, value->data[1].v_int);
g_value_init (&f_min, GST_TYPE_FRACTION);
gst_value_set_fraction (&f_min, fspec->min_num, fspec->min_den);
g_value_init (&f_max, GST_TYPE_FRACTION);
gst_value_set_fraction (&f_max, fspec->max_num, fspec->max_den);
res = gst_value_compare (&f_min, &f_this);
#ifndef GST_DISABLE_GST_DEBUG
GST_LOG ("comparing %d/%d to %d/%d, result = %d", fspec->min_num,
fspec->min_den, value->data[0].v_int, value->data[1].v_int, res);
#endif
if (res != GST_VALUE_LESS_THAN && res != GST_VALUE_EQUAL)
goto out;
#ifndef GST_DISABLE_GST_DEBUG
GST_LOG ("comparing %d/%d to %d/%d, result = %d", value->data[0].v_int,
value->data[1].v_int, fspec->max_num, fspec->max_den, res);
#endif
res = gst_value_compare (&f_this, &f_max);
if (res != GST_VALUE_LESS_THAN && res != GST_VALUE_EQUAL)
goto out;
within_range = TRUE;
out:
g_value_unset (&f_min);
g_value_unset (&f_max);
g_value_unset (&f_this);
#ifndef GST_DISABLE_GST_DEBUG
GST_LOG ("%swithin range", (within_range) ? "" : "not ");
#endif
/* return FALSE if everything ok, otherwise TRUE */
return !within_range;
}
static gboolean
sink_setcaps (GstPad *pad,
GstCaps *caps)
{
GstStructure *structure;
GstOmxBaseFilter21 *self;
GOmxCore *gomx;
GstVideoFormat format;
int sink_number;
self = GST_OMX_BASE_FILTER21 (GST_PAD_PARENT (pad));
if(strcmp(GST_PAD_NAME(pad), "sink_00") == 0){
sink_number=0;
}
else if(strcmp(GST_PAD_NAME(pad), "sink_01") == 0){
sink_number=1;
}
gomx = (GOmxCore *) self->gomx;
GST_INFO_OBJECT (self, "setcaps (sink): %d", sink_number);
GST_INFO_OBJECT (self, "setcaps (sink): %" GST_PTR_FORMAT, caps);
g_return_val_if_fail (caps, FALSE);
g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE);
structure = gst_caps_get_structure (caps, 0);
g_return_val_if_fail (structure, FALSE);
if (!gst_video_format_parse_caps_strided (caps,
&format, &self->in_width[sink_number], &self->in_height[sink_number], &self->in_stride[sink_number]))
{
GST_WARNING_OBJECT (self, "width and/or height is not set in caps");
return FALSE;
}
if (!self->in_stride[sink_number])
{
self->in_stride[sink_number] = gstomx_calculate_stride (self->in_width[sink_number], format);
}
{
/* Output framerate correspond to the minimum input framerate */
const GValue *sink_framerate = NULL;
sink_framerate = gst_structure_get_value (structure, "framerate");
if( GST_VALUE_HOLDS_FRACTION(sink_framerate) )
{
if( self->out_framerate == NULL || gst_value_compare(sink_framerate, self->out_framerate) == GST_VALUE_LESS_THAN )
{
self->out_framerate = sink_framerate;
self->duration = gst_util_uint64_scale_int(GST_SECOND, gst_value_get_fraction_denominator(sink_framerate),
gst_value_get_fraction_numerator(sink_framerate));
}
}
}
return gst_pad_set_caps (pad, caps);
}
EXPORT_C
#endif
gboolean
gst_controller_sync_values (GstController * self, GstClockTime timestamp)
{
GstControlledProperty *prop;
GList *node;
gboolean ret = TRUE, val_ret;
GValue value = { 0, };
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (timestamp), FALSE);
GST_LOG ("sync_values");
g_mutex_lock (self->lock);
g_object_freeze_notify (self->object);
/* go over the controlled properties of the controller */
for (node = self->properties; node; node = g_list_next (node)) {
prop = node->data;
if (!prop->csource || prop->disabled)
continue;
GST_LOG ("property '%s' at ts=%" G_GUINT64_FORMAT, prop->name, timestamp);
/* we can make this faster
* http://bugzilla.gnome.org/show_bug.cgi?id=536939
*/
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (prop->pspec));
val_ret = gst_control_source_get_value (prop->csource, timestamp, &value);
if (G_LIKELY (val_ret)) {
/* always set the value for first time, but then only if it changed
* this should limit g_object_notify invocations.
* FIXME: can we detect negative playback rates?
*/
if ((timestamp < self->priv->last_sync) ||
gst_value_compare (&value, &prop->last_value) != GST_VALUE_EQUAL) {
g_object_set_property (self->object, prop->name, &value);
g_value_copy (&value, &prop->last_value);
}
} else {
GST_DEBUG ("no control value for param %s", prop->name);
}
g_value_unset (&value);
ret &= val_ret;
}
self->priv->last_sync = timestamp;
g_object_thaw_notify (self->object);
g_mutex_unlock (self->lock);
return ret;
}
static gint
_gst_param_fraction_values_cmp (GParamSpec * pspec, const GValue * value1,
const GValue * value2)
{
gint res;
res = gst_value_compare (value1, value2);
g_assert (res != GST_VALUE_UNORDERED);
/* GST_VALUE_LESS_THAN is -1, EQUAL is 0, and GREATER_THAN is 1 */
return res;
}
tag_list calculate_new_tags(tag_list const &p_reference, tag_list const &p_other)
{
tag_list result;
guint num_tags;
if (p_other.is_empty())
return result;
num_tags = gst_tag_list_n_tags(p_other.get_tag_list());
for (guint num = 0; num < num_tags; ++num)
{
std::string name(gst_tag_list_nth_tag_name(p_other.get_tag_list(), num));
guint num_tag_values_in_other = get_num_values_for_tag(p_other, name);
// If the reference list already has this tag, check if the values differ.
// If it doesn't have this tag yet, it is an addition, so add the tag to
// the result right away.
if (has_value(p_reference, name))
{
guint num_tag_values_in_reference = get_num_values_for_tag(p_reference, name);
// If the number of tag values differ, add the other's values to
// the result, assuming a change (an addition).
// If the numbers are the same, compare each value pair.
if (num_tag_values_in_other == num_tag_values_in_reference)
{
bool equal = true;
for (guint index = 0; index < num_tag_values_in_other; ++index)
{
GValue const *other_value = get_raw_value(p_other, name, index);
GValue const *reference_value = get_raw_value(p_reference, name, index);
if (gst_value_compare(other_value, reference_value) != GST_VALUE_EQUAL)
{
equal = false;
break;
}
}
if (equal)
continue;
}
}
for (guint index = 0; index < num_tag_values_in_other; ++index)
add_raw_value(result, get_raw_value(p_other, name, index), name, GST_TAG_MERGE_APPEND);
}
return result;
}
static gboolean
date_times_are_equal (GstDateTime * d1, GstDateTime * d2)
{
GValue val1 = G_VALUE_INIT;
GValue val2 = G_VALUE_INIT;
int ret;
g_value_init (&val1, GST_TYPE_DATE_TIME);
g_value_set_boxed (&val1, d1);
g_value_init (&val2, GST_TYPE_DATE_TIME);
g_value_set_boxed (&val2, d2);
ret = gst_value_compare (&val1, &val2);
g_value_unset (&val2);
g_value_unset (&val1);
return ret == GST_VALUE_EQUAL;
}
static void
test_tags (const gchar * tag_str)
{
GstElement *pipeline;
GstBus *bus;
GMainLoop *loop;
GstTagList *sent_tags;
gint i, j, n_recv, n_sent;
const gchar *name_sent, *name_recv;
const GValue *value_sent, *value_recv;
gboolean found, ok;
gint comparison;
GstElement *videotestsrc, *jpegenc, *metadatamux, *metadatademux, *fakesink;
GstTagSetter *setter;
GST_DEBUG ("testing tags : %s", tag_str);
if (received_tags) {
gst_tag_list_free (received_tags);
received_tags = NULL;
}
pipeline = gst_pipeline_new ("pipeline");
fail_unless (pipeline != NULL);
videotestsrc = gst_element_factory_make ("videotestsrc", "src");
fail_unless (videotestsrc != NULL);
g_object_set (G_OBJECT (videotestsrc), "num-buffers", 1, NULL);
jpegenc = gst_element_factory_make ("jpegenc", "enc");
if (jpegenc == NULL) {
g_print ("Cannot test - jpegenc not available\n");
return;
}
metadatamux = gst_element_factory_make ("metadatamux", "mux");
g_object_set (G_OBJECT (metadatamux), "exif", TRUE, NULL);
fail_unless (metadatamux != NULL);
metadatademux = gst_element_factory_make ("metadatademux", "demux");
fail_unless (metadatademux != NULL);
fakesink = gst_element_factory_make ("fakesink", "sink");
fail_unless (fakesink != NULL);
gst_bin_add_many (GST_BIN (pipeline), videotestsrc, jpegenc, metadatamux,
metadatademux, fakesink, NULL);
ok = gst_element_link_many (videotestsrc, jpegenc, metadatamux, metadatademux,
fakesink, NULL);
fail_unless (ok == TRUE);
loop = g_main_loop_new (NULL, TRUE);
fail_unless (loop != NULL);
bus = gst_element_get_bus (pipeline);
fail_unless (bus != NULL);
gst_bus_add_watch (bus, bus_handler, loop);
gst_object_unref (bus);
gst_element_set_state (pipeline, GST_STATE_READY);
setter = GST_TAG_SETTER (metadatamux);
fail_unless (setter != NULL);
sent_tags = gst_structure_from_string (tag_str, NULL);
fail_unless (sent_tags != NULL);
gst_tag_setter_merge_tags (setter, sent_tags, GST_TAG_MERGE_REPLACE);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_main_loop_run (loop);
GST_DEBUG ("mainloop done : %p", received_tags);
/* verify tags */
fail_unless (received_tags != NULL);
n_recv = gst_structure_n_fields (received_tags);
n_sent = gst_structure_n_fields (sent_tags);
/* we also get e.g. an exif binary block */
fail_unless (n_recv >= n_sent);
/* FIXME: compare taglits values */
for (i = 0; i < n_sent; i++) {
name_sent = gst_structure_nth_field_name (sent_tags, i);
value_sent = gst_structure_get_value (sent_tags, name_sent);
found = FALSE;
for (j = 0; j < n_recv; j++) {
name_recv = gst_structure_nth_field_name (received_tags, j);
if (!strcmp (name_sent, name_recv)) {
value_recv = gst_structure_get_value (received_tags, name_recv);
comparison = gst_value_compare (value_sent, value_recv);
if (comparison != GST_VALUE_EQUAL) {
gchar *vs = g_strdup_value_contents (value_sent);
gchar *vr = g_strdup_value_contents (value_recv);
GST_DEBUG ("sent = %s:'%s', recv = %s:'%s'",
G_VALUE_TYPE_NAME (value_sent), vs,
G_VALUE_TYPE_NAME (value_recv), vr);
g_free (vs);
g_free (vr);
}
fail_unless (comparison == GST_VALUE_EQUAL,
"tag item %s has been received with different type or value",
name_sent);
found = TRUE;
break;
}
}
fail_unless (found, "tag item %s is lost", name_sent);
}
gst_tag_list_free (received_tags);
received_tags = NULL;
gst_tag_list_free (sent_tags);
gst_element_set_state (pipeline, GST_STATE_NULL);
g_main_loop_unref (loop);
g_object_unref (pipeline);
}
/*
* Makes a pipeline in the form:
* filesrc location=file ! demuxer ! fakesink
*
* And gets the tags that are posted on the bus to compare
* with the tags in 'tag_str'
*/
static void
test_demux_tags (const gchar * tag_str, const gchar * demuxer,
const gchar * file)
{
GstElement *pipeline;
GstBus *bus;
GMainLoop *loop;
GstTagList *sent_tags;
gint i, j, k, n_recv, n_sent;
const gchar *name_sent, *name_recv;
const GValue *value_sent, *value_recv;
gboolean found;
gint comparison;
GstElement *demux;
gchar *launch_str;
guint bus_watch = 0;
GST_DEBUG ("testing tags : %s", tag_str);
if (received_tags) {
gst_tag_list_free (received_tags);
received_tags = NULL;
}
launch_str = g_strdup_printf ("filesrc location=%s ! %s name=demux ! "
"fakesink", file, demuxer);
pipeline = gst_parse_launch (launch_str, NULL);
g_free (launch_str);
fail_unless (pipeline != NULL);
demux = gst_bin_get_by_name (GST_BIN (pipeline), "demux");
fail_unless (demux != NULL);
loop = g_main_loop_new (NULL, TRUE);
fail_unless (loop != NULL);
bus = gst_element_get_bus (pipeline);
fail_unless (bus != NULL);
bus_watch = gst_bus_add_watch (bus, bus_handler, loop);
gst_object_unref (bus);
sent_tags = gst_tag_list_new_from_string (tag_str);
fail_unless (sent_tags != NULL);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_main_loop_run (loop);
GST_DEBUG ("mainloop done : %p", received_tags);
/* verify tags */
fail_unless (received_tags != NULL);
n_recv = gst_tag_list_n_tags (received_tags);
n_sent = gst_tag_list_n_tags (sent_tags);
fail_unless (n_recv >= n_sent);
/* FIXME: compare taglits values */
for (i = 0; i < n_sent; i++) {
name_sent = gst_tag_list_nth_tag_name (sent_tags, i);
found = FALSE;
for (j = 0; j < n_recv; j++) {
name_recv = gst_tag_list_nth_tag_name (received_tags, j);
if (!strcmp (name_sent, name_recv)) {
guint sent_len, recv_len;
sent_len = gst_tag_list_get_tag_size (sent_tags, name_sent);
recv_len = gst_tag_list_get_tag_size (received_tags, name_recv);
fail_unless (sent_len == recv_len,
"tag item %s has been received with different size", name_sent);
for (k = 0; k < sent_len; k++) {
value_sent = gst_tag_list_get_value_index (sent_tags, name_sent, k);
value_recv =
gst_tag_list_get_value_index (received_tags, name_recv, k);
comparison = gst_value_compare (value_sent, value_recv);
if (comparison != GST_VALUE_EQUAL) {
gchar *vs = g_strdup_value_contents (value_sent);
gchar *vr = g_strdup_value_contents (value_recv);
GST_DEBUG ("sent = %s:'%s', recv = %s:'%s'",
G_VALUE_TYPE_NAME (value_sent), vs,
G_VALUE_TYPE_NAME (value_recv), vr);
g_free (vs);
g_free (vr);
}
fail_unless (comparison == GST_VALUE_EQUAL,
"tag item %s has been received with different type or value",
name_sent);
found = TRUE;
break;
}
}
}
fail_unless (found, "tag item %s is lost", name_sent);
}
gst_tag_list_free (received_tags);
received_tags = NULL;
gst_tag_list_free (sent_tags);
gst_element_set_state (pipeline, GST_STATE_NULL);
g_main_loop_unref (loop);
g_object_unref (demux);
g_object_unref (pipeline);
g_source_remove (bus_watch);
}
void test_simplify()
{
GstStructure *s1, *s2;
gboolean did_simplify;
GstCaps *caps;
caps = gst_caps_from_string (non_simple_caps_string);
fail_unless (caps != NULL,
"gst_caps_from_string (non_simple_caps_string) failed");
did_simplify = gst_caps_do_simplify (caps);
fail_unless (did_simplify == TRUE,
"gst_caps_do_simplify() should have worked");
/* check simplified caps, should be:
*
* video/x-raw-rgb, bpp=(int)8, depth=(int)8, endianness=(int)1234,
* framerate=(fraction)[ 1/100, 100 ], width=(int)[ 16, 4096 ],
* height=(int)[ 16, 4096 ];
* video/x-raw-yuv, format=(fourcc){ YV12, YUY2, I420 },
* width=(int)[ 16, 4096 ], height=(int)[ 16, 4096 ],
* framerate=(fraction)[ 1/100, 100 ]
*/
fail_unless (gst_caps_get_size (caps) == 2);
s1 = gst_caps_get_structure (caps, 0);
s2 = gst_caps_get_structure (caps, 1);
fail_unless (s1 != NULL);
fail_unless (s2 != NULL);
if (!gst_structure_has_name (s1, "video/x-raw-rgb")) {
GstStructure *tmp;
tmp = s1;
s1 = s2;
s2 = tmp;
}
fail_unless (gst_structure_has_name (s1, "video/x-raw-rgb"));
{
const GValue *framerate_value;
const GValue *width_value;
const GValue *height_value;
const GValue *val_fps;
GValue test_fps = { 0, };
gint bpp, depth, endianness;
gint min_width, max_width;
gint min_height, max_height;
fail_unless (gst_structure_get_int (s1, "bpp", &bpp));
fail_unless (bpp == 8);
fail_unless (gst_structure_get_int (s1, "depth", &depth));
fail_unless (depth == 8);
fail_unless (gst_structure_get_int (s1, "endianness", &endianness));
fail_unless (endianness == G_LITTLE_ENDIAN);
g_value_init (&test_fps, GST_TYPE_FRACTION);
framerate_value = gst_structure_get_value (s1, "framerate");
fail_unless (framerate_value != NULL);
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (framerate_value));
val_fps = gst_value_get_fraction_range_min (framerate_value);
gst_value_set_fraction (&test_fps, 1, 100);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
val_fps = gst_value_get_fraction_range_max (framerate_value);
gst_value_set_fraction (&test_fps, 100, 1);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
g_value_unset (&test_fps);
width_value = gst_structure_get_value (s1, "width");
fail_unless (width_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (width_value));
min_width = gst_value_get_int_range_min (width_value);
max_width = gst_value_get_int_range_max (width_value);
fail_unless (min_width == 16 && max_width == 4096);
height_value = gst_structure_get_value (s1, "height");
fail_unless (height_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (height_value));
min_height = gst_value_get_int_range_min (height_value);
max_height = gst_value_get_int_range_max (height_value);
fail_unless (min_height == 16 && max_height == 4096);
}
fail_unless (gst_structure_has_name (s2, "video/x-raw-yuv"));
{
const GValue *framerate_value;
const GValue *format_value;
const GValue *width_value;
const GValue *height_value;
const GValue *val_fps;
GValue test_fps = { 0, };
gint min_width, max_width;
gint min_height, max_height;
format_value = gst_structure_get_value (s2, "format");
fail_unless (format_value != NULL);
fail_unless (GST_VALUE_HOLDS_LIST (format_value));
fail_unless (gst_value_list_get_size (format_value) == 3);
fail_unless (check_fourcc_list (format_value) == TRUE);
g_value_init (&test_fps, GST_TYPE_FRACTION);
framerate_value = gst_structure_get_value (s2, "framerate");
fail_unless (framerate_value != NULL);
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (framerate_value));
val_fps = gst_value_get_fraction_range_min (framerate_value);
gst_value_set_fraction (&test_fps, 1, 100);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
val_fps = gst_value_get_fraction_range_max (framerate_value);
gst_value_set_fraction (&test_fps, 100, 1);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
g_value_unset (&test_fps);
width_value = gst_structure_get_value (s2, "width");
fail_unless (width_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (width_value));
min_width = gst_value_get_int_range_min (width_value);
max_width = gst_value_get_int_range_max (width_value);
fail_unless (min_width == 16 && max_width == 4096);
height_value = gst_structure_get_value (s2, "height");
fail_unless (height_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (height_value));
min_height = gst_value_get_int_range_min (height_value);
max_height = gst_value_get_int_range_max (height_value);
fail_unless (min_height == 16 && max_height == 4096);
}
gst_caps_unref (caps);
}
