Handle<Value> gvalue_to_v8(const GValue *gv) {
switch(G_VALUE_TYPE(gv)) {
case G_TYPE_STRING:
return gchararray_to_v8(gv);
case G_TYPE_BOOLEAN:
return Nan::New<Boolean>(g_value_get_boolean(gv));
case G_TYPE_INT:
return Nan::New<Number>(g_value_get_int(gv));
case G_TYPE_UINT:
return Nan::New<Number>(g_value_get_uint(gv));
case G_TYPE_FLOAT:
return Nan::New<Number>(g_value_get_float(gv));
case G_TYPE_DOUBLE:
return Nan::New<Number>(g_value_get_double(gv));
}
if(GST_VALUE_HOLDS_ARRAY(gv)) {
return gstvaluearray_to_v8(gv);
} else if(GST_VALUE_HOLDS_BUFFER(gv)) {
GstBuffer *buf = gst_value_get_buffer(gv);
return gstbuffer_to_v8(buf);
} else if(GST_VALUE_HOLDS_SAMPLE(gv)) {
GstSample *sample = gst_value_get_sample(gv);
Local<Object> caps = Nan::New<Object>();
GstCaps *gcaps = gst_sample_get_caps(sample);
if (gcaps) {
const GstStructure *structure = gst_caps_get_structure(gcaps,0);
if (structure) gst_structure_to_v8(caps, structure);
}
Local<Object> result = Nan::New<Object>();
result->Set(Nan::New("buf").ToLocalChecked(), gstsample_to_v8(sample));
result->Set(Nan::New("caps").ToLocalChecked(), caps);
return result;
}
//printf("Value is of unhandled type %s\n", G_VALUE_TYPE_NAME(gv));
/* Attempt to transform it into a GValue of type STRING */
if(g_value_type_transformable (G_VALUE_TYPE(gv), G_TYPE_STRING)) {
GValue b = G_VALUE_INIT;
g_value_init(&b, G_TYPE_STRING);
g_value_transform(gv, &b);
return gchararray_to_v8(&b);
}
return Nan::Undefined();
}
static void
check_unsync_v24 (const GstTagList * tags, const gchar * file)
{
const GValue *val;
GstSample *sample;
GstBuffer *buf;
gchar *album = NULL;
gchar *title = NULL;
gchar *artist = NULL;
GstMapInfo map;
fail_unless (gst_tag_list_get_string (tags, GST_TAG_TITLE, &title));
fail_unless (title != NULL);
fail_unless_equals_string (title, "Starlight");
g_free (title);
fail_unless (gst_tag_list_get_string (tags, GST_TAG_ALBUM, &album));
fail_unless (album != NULL);
fail_unless_equals_string (album, "L'albumRockVol.4 CD1");
g_free (album);
fail_unless (gst_tag_list_get_string (tags, GST_TAG_ARTIST, &artist));
fail_unless (artist != NULL);
fail_unless_equals_string (artist, "Muse");
g_free (artist);
val = gst_tag_list_get_value_index (tags, GST_TAG_IMAGE, 0);
fail_unless (val != NULL);
fail_unless (GST_VALUE_HOLDS_SAMPLE (val));
sample = gst_value_get_sample (val);
fail_unless (sample != NULL);
fail_unless (gst_sample_get_caps (sample) != NULL);
buf = gst_sample_get_buffer (sample);
fail_unless (buf != NULL);
gst_buffer_map (buf, &map, GST_MAP_READ);
fail_unless_equals_int (map.size, 38022);
/* check for jpeg start/end markers */
fail_unless_equals_int (map.data[0], 0xff);
fail_unless_equals_int (map.data[1], 0xd8);
fail_unless_equals_int (map.data[38020], 0xff);
fail_unless_equals_int (map.data[38021], 0xd9);
gst_buffer_unmap (buf, &map);
}
static void
print_tag_foreach (const GstTagList * tags, const gchar * tag,
gpointer user_data)
{
GValue val = { 0, };
gchar *str;
guint depth = GPOINTER_TO_UINT (user_data);
if (!gst_tag_list_copy_value (&val, tags, tag))
return;
if (G_VALUE_HOLDS_STRING (&val)) {
str = g_value_dup_string (&val);
} else if (G_VALUE_TYPE (&val) == GST_TYPE_SAMPLE) {
GstSample *sample = gst_value_get_sample (&val);
GstBuffer *img = gst_sample_get_buffer (sample);
GstCaps *caps = gst_sample_get_caps (sample);
if (img) {
if (caps) {
gchar *caps_str;
caps_str = gst_caps_to_string (caps);
str = g_strdup_printf ("buffer of %" G_GSIZE_FORMAT " bytes, "
"type: %s", gst_buffer_get_size (img), caps_str);
g_free (caps_str);
} else {
str = g_strdup_printf ("buffer of %" G_GSIZE_FORMAT " bytes",
gst_buffer_get_size (img));
}
} else {
str = g_strdup ("NULL buffer");
}
} else {
str = gst_value_serialize (&val);
}
g_print ("%*s%s: %s\n", 2 * depth, " ", gst_tag_get_nick (tag), str);
g_free (str);
g_value_unset (&val);
}
static void
send_tag (const GstTagList * list, const gchar * tag, gpointer data)
{
InsanityGstPipelineTest *ptest = INSANITY_GST_PIPELINE_TEST (data);
gint i, count;
GValue string_value = { 0 };
char label[48];
count = gst_tag_list_get_tag_size (list, tag);
g_value_init (&string_value, G_TYPE_STRING);
ptest->priv->tag_count++;
for (i = 0; i < count; i++) {
gchar *str;
if (gst_tag_get_type (tag) == G_TYPE_STRING) {
if (!gst_tag_list_get_string_index (list, tag, i, &str))
g_assert_not_reached ();
} else if (gst_tag_get_type (tag) == GST_TYPE_SAMPLE) {
GstSample *img;
img = gst_value_get_sample (gst_tag_list_get_value_index (list, tag, i));
if (img) {
GstBuffer *buffer;
GstCaps *caps;
gchar *caps_str;
buffer = gst_sample_get_buffer (img);
caps = gst_sample_get_caps (img);
caps_str = caps ? gst_caps_to_string (caps) : g_strdup ("unknown");
str = g_strdup_printf ("sample of %" G_GSIZE_FORMAT " bytes, type: %s",
gst_buffer_get_size (buffer), caps_str);
g_free (caps_str);
} else {
str = g_strdup ("NULL sample");
}
} else if (gst_tag_get_type (tag) == GST_TYPE_DATE_TIME) {
GstDateTime *dt = NULL;
gst_tag_list_get_date_time_index (list, tag, i, &dt);
str = gst_date_time_to_iso8601_string (dt);
gst_date_time_unref (dt);
} else {
str =
g_strdup_value_contents (gst_tag_list_get_value_index (list, tag, i));
}
if (i == 0) {
g_value_set_string (&string_value, gst_tag_get_nick (tag));
snprintf (label, sizeof (label), "tags.%u.id", ptest->priv->tag_count);
insanity_test_set_extra_info (INSANITY_TEST (ptest), label,
&string_value);
g_value_reset (&string_value);
}
g_value_set_string (&string_value, str);
if (count > 1)
snprintf (label, sizeof (label), "tags.%u.value.%u",
ptest->priv->tag_count, i);
else
snprintf (label, sizeof (label), "tags.%u.value", ptest->priv->tag_count);
insanity_test_set_extra_info (INSANITY_TEST (ptest), label, &string_value);
g_value_reset (&string_value);
g_free (str);
}
}
