static GstFlowReturn gst_hls_sink_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list) { guint i, len; GstBuffer *buffer; GstFlowReturn ret; GstHlsSink *sink = GST_HLS_SINK_CAST (parent); if (sink->target_duration == 0 || sink->waiting_fku) return gst_proxy_pad_chain_list_default (pad, parent, list); GST_DEBUG_OBJECT (pad, "chaining each group in list as a merged buffer"); len = gst_buffer_list_length (list); ret = GST_FLOW_OK; for (i = 0; i < len; i++) { buffer = gst_buffer_list_get (list, i); if (!sink->waiting_fku) gst_hls_sink_check_schedule_next_key_unit (sink, buffer); ret = gst_pad_chain (pad, gst_buffer_ref (buffer)); if (ret != GST_FLOW_OK) break; } gst_buffer_list_unref (list); return ret; }
/* * Chain list function for testing buffer lists */ static GstFlowReturn rtp_pipeline_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list) { guint i, len; fail_if (!list); /* * Count the size of the payload in the buffer list. */ len = gst_buffer_list_length (list); /* Loop through all groups */ for (i = 0; i < len; i++) { GstBuffer *paybuf; GstMemory *mem; gint size; paybuf = gst_buffer_list_get (list, i); /* only count real data which is expected in last memory block */ fail_unless (gst_buffer_n_memory (paybuf) > 1); mem = gst_buffer_get_memory_range (paybuf, gst_buffer_n_memory (paybuf) - 1, 1); size = gst_memory_get_sizes (mem, NULL, NULL); gst_memory_unref (mem); chain_list_bytes_received += size; } gst_buffer_list_unref (list); return GST_FLOW_OK; }
static void copyGstreamerBuffersToAudioChannel(GstBufferList* buffers, AudioChannel* audioChannel) { #ifdef GST_API_VERSION_1 gsize offset = 0; for (unsigned i = 0; i < gst_buffer_list_length(buffers); i++) { GstBuffer* buffer = gst_buffer_list_get(buffers, i); if (!buffer) continue; GstMapInfo info; gst_buffer_map(buffer, &info, GST_MAP_READ); memcpy(audioChannel->mutableData() + offset, reinterpret_cast<float*>(info.data), info.size); offset += info.size / sizeof(float); gst_buffer_unmap(buffer, &info); } #else GstBufferListIterator* iter = gst_buffer_list_iterate(buffers); gst_buffer_list_iterator_next_group(iter); GstBuffer* buffer = gst_buffer_list_iterator_merge_group(iter); if (buffer) { memcpy(audioChannel->mutableData(), reinterpret_cast<float*>(GST_BUFFER_DATA(buffer)), GST_BUFFER_SIZE(buffer)); gst_buffer_unref(buffer); } gst_buffer_list_iterator_free(iter); #endif }
/** * gst_rtp_buffer_list_get_payload_type: * @list: the buffer list * * Get the payload type of the first RTP packet in @list. * All packets in @list should have the same payload type. * * Returns: The payload type. * * Since: 0.10.24 */ guint8 gst_rtp_buffer_list_get_payload_type (GstBufferList * list) { GstBuffer *buffer; buffer = gst_buffer_list_get (list, 0, 0); g_return_val_if_fail (buffer != NULL, 0); return GST_RTP_HEADER_PAYLOAD_TYPE (GST_BUFFER_DATA (buffer)); }
/** * gst_rtp_buffer_list_get_ssrc: * @list: the buffer list * * Get the SSRC of the first RTP packet in @list. * All RTP packets within @list have the same SSRC. * * Returns: the SSRC of @list in host order. * * Since: 0.10.24 */ guint32 gst_rtp_buffer_list_get_ssrc (GstBufferList * list) { GstBuffer *buffer; buffer = gst_buffer_list_get (list, 0, 0); g_return_val_if_fail (buffer != NULL, 0); return g_ntohl (GST_RTP_HEADER_SSRC (GST_BUFFER_DATA (buffer))); }
/** * gst_rtp_buffer_list_get_timestamp: * @list: the buffer list * * Get the timestamp of the first RTP packet in @list. * All packets within @list have the same timestamp. * * Returns: The timestamp in host order. * * Since: 0.10.24 */ guint32 gst_rtp_buffer_list_get_timestamp (GstBufferList * list) { GstBuffer *buffer; buffer = gst_buffer_list_get (list, 0, 0); g_return_val_if_fail (buffer != NULL, 0); return g_ntohl (GST_RTP_HEADER_TIMESTAMP (GST_BUFFER_DATA (buffer))); }
static void copyGstreamerBuffersToAudioChannel(GstBufferList* buffers, AudioChannel* audioChannel) { float* destination = audioChannel->mutableData(); unsigned bufferCount = gst_buffer_list_length(buffers); for (unsigned i = 0; i < bufferCount; ++i) { GstBuffer* buffer = gst_buffer_list_get(buffers, i); ASSERT(buffer); gsize bufferSize = gst_buffer_get_size(buffer); gst_buffer_extract(buffer, 0, destination, bufferSize); destination += bufferSize / sizeof(float); } }
EXPORT_C #endif guint16 gst_rtp_buffer_list_get_seq (GstBufferList * list) { GstBuffer *buffer; buffer = gst_buffer_list_get (list, 0, 0); g_return_val_if_fail (buffer != NULL, 0); return g_ntohl (GST_RTP_HEADER_SEQ (GST_BUFFER_DATA (buffer))); }
static void gst_rtp_ulpfec_dec_start (GstRtpUlpFecDec * self, GstBufferList * buflist, guint8 fec_pt, guint16 lost_seq) { guint fec_packets = 0; gsize i; g_assert (NULL == self->info_media); g_assert (0 == self->info_fec->len); g_assert (0 == self->info_arr->len); g_array_set_size (self->info_arr, gst_buffer_list_length (buflist)); for (i = 0; i < gst_buffer_list_length (buflist) && !self->lost_packet_from_storage; ++i) { GstBuffer *buffer = gst_buffer_list_get (buflist, i); RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, i); if (!rtp_ulpfec_map_info_map (gst_buffer_ref (buffer), info)) g_assert_not_reached (); if (fec_pt == gst_rtp_buffer_get_payload_type (&info->rtp)) { GST_DEBUG_RTP_PACKET (self, "rtp header (fec)", &info->rtp); ++fec_packets; if (rtp_ulpfec_buffer_is_valid (&info->rtp)) { GST_DEBUG_FEC_PACKET (self, &info->rtp); g_ptr_array_add (self->info_fec, GUINT_TO_POINTER (i)); } } else { GST_LOG_RTP_PACKET (self, "rtp header (incoming)", &info->rtp); if (lost_seq == gst_rtp_buffer_get_seq (&info->rtp)) { GST_DEBUG_OBJECT (self, "Received lost packet from from the storage"); g_list_free (self->info_media); self->info_media = NULL; self->lost_packet_from_storage = TRUE; } self->info_media = g_list_insert_sorted_with_data (self->info_media, GUINT_TO_POINTER (i), _compare_fec_map_info, self); } } if (!self->lost_packet_from_storage) { self->fec_packets_received += fec_packets; self->fec_packets_rejected += fec_packets - self->info_fec->len; } }
static GstFlowReturn gst_file_sink_render_list (GstBaseSink * bsink, GstBufferList * buffer_list) { GstFlowReturn flow; GstBuffer **buffers; GstFileSink *sink; guint8 *mem_nums; guint total_mems; guint i, num_buffers; gboolean sync_after = FALSE; sink = GST_FILE_SINK_CAST (bsink); num_buffers = gst_buffer_list_length (buffer_list); if (num_buffers == 0) goto no_data; /* extract buffers from list and count memories */ buffers = g_newa (GstBuffer *, num_buffers); mem_nums = g_newa (guint8, num_buffers); for (i = 0, total_mems = 0; i < num_buffers; ++i) { buffers[i] = gst_buffer_list_get (buffer_list, i); mem_nums[i] = gst_buffer_n_memory (buffers[i]); total_mems += mem_nums[i]; if (GST_BUFFER_FLAG_IS_SET (buffers[i], GST_BUFFER_FLAG_SYNC_AFTER)) sync_after = TRUE; } flow = gst_file_sink_render_buffers (sink, buffers, num_buffers, mem_nums, total_mems); if (flow == GST_FLOW_OK && sync_after) { if (fflush (sink->file) || fsync (fileno (sink->file))) { GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (_("Error while writing to file \"%s\"."), sink->filename), ("%s", g_strerror (errno))); flow = GST_FLOW_ERROR; } } return flow; no_data: { GST_LOG_OBJECT (sink, "empty buffer list"); return GST_FLOW_OK; } }
/* * Render function for testing udpsink with buffer lists */ static GstFlowReturn udpsink_render_list (GstBaseSink * sink, GstBufferList * list) { guint i, num; num = gst_buffer_list_length (list); for (i = 0; i < num; ++i) { GstBuffer *buf = gst_buffer_list_get (list, i); gsize size = gst_buffer_get_size (buf); GST_DEBUG ("rendered %" G_GSIZE_FORMAT " bytes", size); render_list_bytes_received += size; } return GST_FLOW_OK; }
/** * @brief Handle list of buffers. * * GstBaseSink method implementation. */ static GstFlowReturn gst_tensor_sink2_render_list (GstBaseSink * sink, GstBufferList * buffer_list) { GstTensorSink2 *self; GstBuffer *buffer; guint i; guint num_buffers; self = GST_TENSOR_SINK2 (sink); num_buffers = gst_buffer_list_length (buffer_list); for (i = 0; i < num_buffers; i++) { buffer = gst_buffer_list_get (buffer_list, i); gst_tensor_sink2_render_buffer (self, buffer); } return GST_FLOW_OK; }
GstCaps * gst_fragment_get_caps (GstFragment * fragment) { g_return_val_if_fail (fragment != NULL, NULL); if (!fragment->completed) return NULL; g_mutex_lock (&fragment->priv->lock); if (fragment->priv->caps == NULL) { GstBuffer *buf = gst_buffer_list_get (fragment->priv->buffer_list, 0, 0); fragment->priv->caps = gst_type_find_helper_for_buffer (NULL, buf, NULL); } gst_caps_ref (fragment->priv->caps); g_mutex_unlock (&fragment->priv->lock); return fragment->priv->caps; }
static GstFlowReturn gst_rtp_base_depayload_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list) { GstRTPBaseDepayloadClass *bclass; GstRTPBaseDepayload *basedepay; GstFlowReturn flow_ret; GstBuffer *buffer; guint i, len; basedepay = GST_RTP_BASE_DEPAYLOAD_CAST (parent); bclass = GST_RTP_BASE_DEPAYLOAD_GET_CLASS (basedepay); flow_ret = GST_FLOW_OK; /* chain each buffer in list individually */ len = gst_buffer_list_length (list); if (len == 0) goto done; for (i = 0; i < len; i++) { buffer = gst_buffer_list_get (list, i); /* handle_buffer takes ownership of input buffer */ /* FIXME: add a way to steal buffers from list as we will unref it anyway */ gst_buffer_ref (buffer); /* Should we fix up any missing timestamps for list buffers here * (e.g. set to first or previous timestamp in list) or just assume * the's a jitterbuffer that will have done that for us? */ flow_ret = gst_rtp_base_depayload_handle_buffer (basedepay, bclass, buffer); if (flow_ret != GST_FLOW_OK) break; } done: gst_buffer_list_unref (list); return flow_ret; }
static GstFlowReturn gst_fd_sink_render_list (GstBaseSink * bsink, GstBufferList * buffer_list) { GstFlowReturn flow; GstBuffer **buffers; GstFdSink *sink; guint8 *mem_nums; guint total_mems; guint i, num_buffers; sink = GST_FD_SINK_CAST (bsink); num_buffers = gst_buffer_list_length (buffer_list); if (num_buffers == 0) goto no_data; /* extract buffers from list and count memories */ buffers = g_newa (GstBuffer *, num_buffers); mem_nums = g_newa (guint8, num_buffers); for (i = 0, total_mems = 0; i < num_buffers; ++i) { buffers[i] = gst_buffer_list_get (buffer_list, i); mem_nums[i] = gst_buffer_n_memory (buffers[i]); total_mems += mem_nums[i]; } flow = gst_fd_sink_render_buffers (sink, buffers, num_buffers, mem_nums, total_mems); return flow; no_data: { GST_LOG_OBJECT (sink, "empty buffer list"); return GST_FLOW_OK; } }
BufferPtr BufferList::bufferAt(uint index) const { return BufferPtr::wrap(gst_buffer_list_get(object<GstBufferList>(), index)); }