static JsonNode * snra_json_value_to_node (const GValue *value) { JsonNode *n = NULL; if (GST_VALUE_HOLDS_STRUCTURE (value)) { const GstStructure *s = gst_value_get_structure (value); n = snra_json_from_gst_structure (s); } else if (GST_VALUE_HOLDS_ARRAY (value)) { guint count = gst_value_array_get_size (value); guint i; JsonArray *arr = json_array_sized_new (count); for (i = 0; i < count; i++) { const GValue *sub_val = gst_value_array_get_value (value, i); JsonNode *tmp = snra_json_value_to_node (sub_val); if (tmp) json_array_add_element (arr, tmp); } n = json_node_new (JSON_NODE_ARRAY); json_node_take_array (n, arr); } else { n = json_node_new (JSON_NODE_VALUE); json_node_set_value (n, value); } return n; }
static gboolean gst_flac_dec_set_format (GstAudioDecoder * dec, GstCaps * caps) { const GValue *headers; GstFlacDec *flacdec; GstStructure *s; guint i, num; flacdec = GST_FLAC_DEC (dec); GST_LOG_OBJECT (dec, "sink caps: %" GST_PTR_FORMAT, caps); s = gst_caps_get_structure (caps, 0); headers = gst_structure_get_value (s, "streamheader"); if (headers == NULL || !GST_VALUE_HOLDS_ARRAY (headers)) { GST_WARNING_OBJECT (dec, "no 'streamheader' field in input caps, try " "adding a flacparse element upstream"); return FALSE; } if (gst_adapter_available (flacdec->adapter) > 0) { GST_WARNING_OBJECT (dec, "unexpected data left in adapter"); gst_adapter_clear (flacdec->adapter); } num = gst_value_array_get_size (headers); for (i = 0; i < num; ++i) { const GValue *header_val; GstBuffer *header_buf; header_val = gst_value_array_get_value (headers, i); if (header_val == NULL || !GST_VALUE_HOLDS_BUFFER (header_val)) return FALSE; header_buf = g_value_dup_boxed (header_val); GST_INFO_OBJECT (dec, "pushing header buffer of %" G_GSIZE_FORMAT " bytes " "into adapter", gst_buffer_get_size (header_buf)); gst_adapter_push (flacdec->adapter, header_buf); } GST_DEBUG_OBJECT (dec, "Processing headers and metadata"); if (!FLAC__stream_decoder_process_until_end_of_metadata (flacdec->decoder)) { GST_WARNING_OBJECT (dec, "process_until_end_of_metadata failed"); if (FLAC__stream_decoder_get_state (flacdec->decoder) == FLAC__STREAM_DECODER_ABORTED) { GST_WARNING_OBJECT (flacdec, "Read callback caused internal abort"); /* allow recovery */ gst_adapter_clear (flacdec->adapter); FLAC__stream_decoder_flush (flacdec->decoder); gst_flac_dec_handle_decoder_error (flacdec, TRUE); } } GST_INFO_OBJECT (dec, "headers and metadata are now processed"); return TRUE; }
Handle<Value> gstvaluearray_to_v8(const GValue *gv) { if(!GST_VALUE_HOLDS_ARRAY(gv)) { Nan::ThrowTypeError("not a GstValueArray"); return Nan::Undefined(); } int size = gst_value_array_get_size(gv); Handle<Array> array = Nan::New<Array>(gst_value_array_get_size(gv)); for(int i=0; i<size; i++) { array->Set(Nan::New<Number>(i), gvalue_to_v8(gst_value_array_get_value(gv,i))); } return array; }
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(); }
void test_channel_layout_value_intersect() { GValue layout = { 0, }; GValue list = { 0, }; GValue res = { 0, }; xmlfile = "test_channel_layout_value_intersect"; std_log(LOG_FILENAME_LINE, "Test Started test_channel_layout_value_intersect"); g_value_init (&list, GST_TYPE_LIST); init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT); gst_value_list_append_value (&list, &layout); g_value_unset (&layout); init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT); gst_value_list_append_value (&list, &layout); g_value_unset (&layout); init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT); /* we should get the second layout in the list, as it matches the input */ fail_unless (gst_value_intersect (&res, &layout, &list)); g_value_unset (&layout); fail_unless (GST_VALUE_HOLDS_ARRAY (&res)); fail_unless_equals_int (gst_value_array_get_size (&res), 2); fail_unless_equals_int (g_value_get_enum (gst_value_array_get_value (&res, 0)), GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT); fail_unless_equals_int (g_value_get_enum (gst_value_array_get_value (&res, 1)), GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT); g_value_unset (&res); /* this (with rear position) should not yield any results */ init_value_to_channel_layout (&layout, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT); fail_if (gst_value_intersect (&res, &layout, &list)); g_value_unset (&layout); g_value_unset (&list); std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); }
EXPORT_C #endif void gst_mixer_message_parse_volume_changed (GstMessage * message, GstMixerTrack ** track, gint ** volumes, gint * num_channels) { const GstStructure *s; g_return_if_fail (gst_mixer_message_is_mixer_message (message)); g_return_if_fail (GST_MIXER_MESSAGE_HAS_TYPE (message, VOLUME_CHANGED)); s = gst_message_get_structure (message); if (track) { const GValue *v = gst_structure_get_value (s, "track"); g_return_if_fail (v != NULL); *track = (GstMixerTrack *) g_value_get_object (v); g_return_if_fail (GST_IS_MIXER_TRACK (*track)); } if (volumes || num_channels) { gint n_chans, i; const GValue *v = gst_structure_get_value (s, "volumes"); g_return_if_fail (v != NULL); g_return_if_fail (GST_VALUE_HOLDS_ARRAY (v)); n_chans = gst_value_array_get_size (v); if (num_channels) *num_channels = n_chans; if (volumes) { *volumes = g_new (gint, n_chans); for (i = 0; i < n_chans; i++) { const GValue *e = gst_value_array_get_value (v, i); g_return_if_fail (e != NULL && G_VALUE_HOLDS_INT (e)); (*volumes)[i] = g_value_get_int (e); } } } }
static gboolean gst_multi_file_sink_set_caps (GstBaseSink * sink, GstCaps * caps) { GstMultiFileSink *multifilesink; GstStructure *structure; multifilesink = GST_MULTI_FILE_SINK (sink); structure = gst_caps_get_structure (caps, 0); if (structure) { const GValue *value; value = gst_structure_get_value (structure, "streamheader"); if (GST_VALUE_HOLDS_ARRAY (value)) { int i; if (multifilesink->streamheaders) { for (i = 0; i < multifilesink->n_streamheaders; i++) { gst_buffer_unref (multifilesink->streamheaders[i]); } g_free (multifilesink->streamheaders); } multifilesink->n_streamheaders = gst_value_array_get_size (value); multifilesink->streamheaders = g_malloc (sizeof (GstBuffer *) * multifilesink->n_streamheaders); for (i = 0; i < multifilesink->n_streamheaders; i++) { multifilesink->streamheaders[i] = gst_buffer_ref (gst_value_get_buffer (gst_value_array_get_value (value, i))); } } } return TRUE; }
/* * cheese_camera_device_get_highest_framerate: * @framerate: a #GValue holding a framerate cap * @numerator: destination to store the numerator of the highest rate * @denominator: destination to store the denominator of the highest rate * * Get the numerator and denominator for the highest framerate stored in * a framerate cap. * * Note this function does not handle framerate ranges, if @framerate * contains a range it will return 0/0 as framerate */ static void cheese_camera_device_get_highest_framerate (const GValue *framerate, gint *numerator, gint *denominator) { *numerator = 0; *denominator = 0; if (GST_VALUE_HOLDS_FRACTION (framerate)) { *numerator = gst_value_get_fraction_numerator (framerate); *denominator = gst_value_get_fraction_denominator (framerate); } else if (GST_VALUE_HOLDS_ARRAY (framerate)) { float curr, highest = 0; guint i, size = gst_value_array_get_size (framerate); for (i = 0; i < size; i++) { const GValue *val = gst_value_array_get_value (framerate, i); if (!GST_VALUE_HOLDS_FRACTION (val) || gst_value_get_fraction_denominator (val) == 0) { continue; } curr = (float)gst_value_get_fraction_numerator (val) / (float)gst_value_get_fraction_denominator (val); if (curr > highest && curr <= CHEESE_MAXIMUM_RATE) { highest = curr; *numerator = gst_value_get_fraction_numerator (val); *denominator = gst_value_get_fraction_denominator (val); } } } else if (GST_VALUE_HOLDS_LIST (framerate)) { float curr, highest = 0; guint i, size = gst_value_list_get_size (framerate); for (i = 0; i < size; i++) { const GValue *val = gst_value_list_get_value(framerate, i); if (!GST_VALUE_HOLDS_FRACTION (val) || gst_value_get_fraction_denominator (val) == 0) { continue; } curr = (float)gst_value_get_fraction_numerator (val) / (float)gst_value_get_fraction_denominator (val); if (curr > highest && curr <= CHEESE_MAXIMUM_RATE) { highest = curr; *numerator = gst_value_get_fraction_numerator (val); *denominator = gst_value_get_fraction_denominator (val); } } } }
static void handle_player_info (G_GNUC_UNUSED SoupSession *session, SoupMessage *msg, SnraClient *client) { SoupBuffer *buffer; if (msg->status_code < 200 || msg->status_code >= 300) return; buffer = soup_message_body_flatten (msg->response_body); if (json_parser_load_from_data (client->json, buffer->data, buffer->length, NULL)) { const GValue *v1; GArray *player_info = NULL; gsize i; JsonNode *root = json_parser_get_root (client->json); GstStructure *s1 = snra_json_to_gst_structure (root); if (s1 == NULL) return; /* Invalid chunk */ v1 = gst_structure_get_value (s1, "player-clients"); if (!GST_VALUE_HOLDS_ARRAY (v1)) goto failed; player_info = g_array_sized_new (TRUE, TRUE, sizeof (SnraPlayerInfo), gst_value_array_get_size (v1)); for (i = 0; i < gst_value_array_get_size (v1); i++) { SnraPlayerInfo info; const GValue *v2 = gst_value_array_get_value (v1, i); const GstStructure *s2; gint64 client_id; if (!GST_VALUE_HOLDS_STRUCTURE (v2)) goto failed; s2 = gst_value_get_structure (v2); if (!snra_json_structure_get_int64 (s2, "client-id", &client_id)) goto failed; info.id = client_id; if (!snra_json_structure_get_boolean (s2, "enabled", &info.enabled)) goto failed; if (!snra_json_structure_get_double (s2, "volume", &info.volume)) goto failed; if (!(info.host = g_strdup (gst_structure_get_string (s2, "host")))) goto failed; g_array_append_val (player_info, info); } free_player_info (client->player_info); client->player_info = player_info; player_info = NULL; g_signal_emit (client, signals[SIGNAL_PLAYER_INFO_CHANGED], 0); failed: if (player_info) free_player_info (player_info); gst_structure_free (s1); } }
static gboolean gst_interleave_sink_setcaps (GstPad * pad, GstCaps * caps) { GstInterleave *self; g_return_val_if_fail (GST_IS_INTERLEAVE_PAD (pad), FALSE); self = GST_INTERLEAVE (gst_pad_get_parent (pad)); /* First caps that are set on a sink pad are used as output caps */ /* TODO: handle caps changes */ if (self->sinkcaps && !gst_caps_is_subset (caps, self->sinkcaps)) { goto cannot_change_caps; } else { GstCaps *srccaps; GstStructure *s; gboolean res; s = gst_caps_get_structure (caps, 0); if (!gst_structure_get_int (s, "width", &self->width)) goto no_width; if (!gst_structure_get_int (s, "rate", &self->rate)) goto no_rate; gst_interleave_set_process_function (self); if (gst_structure_has_field (s, "channel-positions")) { const GValue *pos_array; pos_array = gst_structure_get_value (s, "channel-positions"); if (GST_VALUE_HOLDS_ARRAY (pos_array) && gst_value_array_get_size (pos_array) == 1) { const GValue *pos = gst_value_array_get_value (pos_array, 0); GValue *apos = g_value_array_get_nth (self->input_channel_positions, GST_INTERLEAVE_PAD_CAST (pad)->channel); g_value_set_enum (apos, g_value_get_enum (pos)); } } srccaps = gst_caps_copy (caps); s = gst_caps_get_structure (srccaps, 0); gst_structure_set (s, "channels", G_TYPE_INT, self->channels, NULL); gst_interleave_set_channel_positions (self, s); res = gst_pad_set_caps (self->src, srccaps); gst_caps_unref (srccaps); if (!res) goto src_did_not_accept; } if (!self->sinkcaps) { GstCaps *sinkcaps = gst_caps_copy (caps); GstStructure *s = gst_caps_get_structure (sinkcaps, 0); gst_structure_remove_field (s, "channel-positions"); gst_caps_replace (&self->sinkcaps, sinkcaps); gst_caps_unref (sinkcaps); } gst_object_unref (self); return TRUE; cannot_change_caps: { GST_DEBUG_OBJECT (self, "caps of %" GST_PTR_FORMAT " already set, can't " "change", self->sinkcaps); gst_object_unref (self); return FALSE; } src_did_not_accept: { GST_DEBUG_OBJECT (self, "src did not accept setcaps()"); gst_object_unref (self); return FALSE; } no_width: { GST_WARNING_OBJECT (self, "caps did not have width: %" GST_PTR_FORMAT, caps); gst_object_unref (self); return FALSE; } no_rate: { GST_WARNING_OBJECT (self, "caps did not have rate: %" GST_PTR_FORMAT, caps); gst_object_unref (self); return FALSE; } }