AudioFileReader::~AudioFileReader() { if (m_pipeline) { GRefPtr<GstBus> bus = webkitGstPipelineGetBus(GST_PIPELINE(m_pipeline)); ASSERT(bus); g_signal_handlers_disconnect_by_func(bus.get(), reinterpret_cast<gpointer>(messageCallback), this); gst_bus_remove_signal_watch(bus.get()); gst_element_set_state(m_pipeline, GST_STATE_NULL); gst_object_unref(GST_OBJECT(m_pipeline)); } if (m_decodebin) { g_signal_handlers_disconnect_by_func(m_decodebin.get(), reinterpret_cast<gpointer>(onGStreamerDecodebinPadAddedCallback), this); m_decodebin.clear(); } if (m_deInterleave) { g_signal_handlers_disconnect_by_func(m_deInterleave.get(), reinterpret_cast<gpointer>(onGStreamerDeinterleavePadAddedCallback), this); g_signal_handlers_disconnect_by_func(m_deInterleave.get(), reinterpret_cast<gpointer>(onGStreamerDeinterleaveReadyCallback), this); m_deInterleave.clear(); } #ifndef GST_API_VERSION_1 gst_buffer_list_iterator_free(m_frontLeftBuffersIterator); gst_buffer_list_iterator_free(m_frontRightBuffersIterator); #endif gst_buffer_list_unref(m_frontLeftBuffers); gst_buffer_list_unref(m_frontRightBuffers); }
AudioFileReader::~AudioFileReader() { if (m_pipeline) { GRefPtr<GstBus> bus = adoptGRef(gst_pipeline_get_bus(GST_PIPELINE(m_pipeline))); ASSERT(bus); g_signal_handlers_disconnect_by_func(bus.get(), reinterpret_cast<gpointer>(messageCallback), this); gst_element_set_state(m_pipeline, GST_STATE_NULL); gst_object_unref(GST_OBJECT(m_pipeline)); } if (m_decodebin) { g_signal_handlers_disconnect_by_func(m_decodebin.get(), reinterpret_cast<gpointer>(onGStreamerDecodebinPadAddedCallback), this); m_decodebin.clear(); } if (m_deInterleave) { g_signal_handlers_disconnect_by_func(m_deInterleave.get(), reinterpret_cast<gpointer>(onGStreamerDeinterleavePadAddedCallback), this); g_signal_handlers_disconnect_by_func(m_deInterleave.get(), reinterpret_cast<gpointer>(onGStreamerDeinterleaveReadyCallback), this); m_deInterleave.clear(); } gst_buffer_list_unref(m_frontLeftBuffers); gst_buffer_list_unref(m_frontRightBuffers); }
/* * 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 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, GstBufferList * list) { GstBufferListIterator *it; fail_if (!list); it = gst_buffer_list_iterate (list); /* * Count the size of the payload in the buffer list. */ /* Loop through all groups */ while (gst_buffer_list_iterator_next_group (it)) { GstBuffer *paybuf; /* Skip the first buffer in the group, its the RTP header */ fail_if (!gst_buffer_list_iterator_next (it)); /* Loop through all payload buffers in the current group */ while ((paybuf = gst_buffer_list_iterator_next (it))) { chain_list_bytes_received += GST_BUFFER_SIZE (paybuf); } } gst_buffer_list_iterator_free (it); gst_buffer_list_unref (list); return GST_FLOW_OK; }
static GstFlowReturn gst_rtp_mux_chain_list (GstPad * pad, GstObject * parent, GstBufferList * bufferlist) { GstRTPMux *rtp_mux; GstFlowReturn ret; GstRTPMuxPadPrivate *padpriv; struct BufferListData bd; rtp_mux = GST_RTP_MUX (parent); GST_OBJECT_LOCK (rtp_mux); padpriv = gst_pad_get_element_private (pad); if (!padpriv) { GST_OBJECT_UNLOCK (rtp_mux); ret = GST_FLOW_NOT_LINKED; gst_buffer_list_unref (bufferlist); goto out; } bd.rtp_mux = rtp_mux; bd.padpriv = padpriv; bd.drop = FALSE; bufferlist = gst_buffer_list_make_writable (bufferlist); gst_buffer_list_foreach (bufferlist, process_list_item, &bd); GST_OBJECT_UNLOCK (rtp_mux); if (bd.drop) { gst_buffer_list_unref (bufferlist); ret = GST_FLOW_OK; } else { ret = gst_pad_push_list (rtp_mux->srcpad, bufferlist); } out: return ret; }
/** * gst_rtp_base_payload_push_list: * @payload: a #GstRTPBasePayload * @list: a #GstBufferList * * Push @list to the peer element of the payloader. The SSRC, payload type, * seqnum and timestamp of the RTP buffer will be updated first. * * This function takes ownership of @list. * * Returns: a #GstFlowReturn. */ GstFlowReturn gst_rtp_base_payload_push_list (GstRTPBasePayload * payload, GstBufferList * list) { GstFlowReturn res; res = gst_rtp_base_payload_prepare_push (payload, list, TRUE); if (G_LIKELY (res == GST_FLOW_OK)) res = gst_pad_push_list (payload->srcpad, list); else gst_buffer_list_unref (list); return res; }
static GstFlowReturn sink_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list) { GstDtlsDec *self = GST_DTLS_DEC (parent); GstFlowReturn ret = GST_FLOW_OK; GstPad *other_pad; list = gst_buffer_list_make_writable (list); gst_buffer_list_foreach (list, process_buffer_from_list, self); if (gst_buffer_list_length (list) == 0) { GST_DEBUG_OBJECT (self, "Not produced any buffers"); gst_buffer_list_unref (list); return GST_FLOW_OK; } g_mutex_lock (&self->src_mutex); other_pad = self->src; if (other_pad) gst_object_ref (other_pad); g_mutex_unlock (&self->src_mutex); if (other_pad) { GST_LOG_OBJECT (self, "decoded buffer list with length %u, pushing", gst_buffer_list_length (list)); ret = gst_pad_push_list (other_pad, list); gst_object_unref (other_pad); } else { GST_LOG_OBJECT (self, "dropped buffer list with length %d, not linked", gst_buffer_list_length (list)); gst_buffer_list_unref (list); } return ret; }
/** * gst_rtp_base_depayload_push_list: * @filter: a #GstRTPBaseDepayload * @out_list: a #GstBufferList * * Push @out_list to the peer of @filter. This function takes ownership of * @out_list. * * Returns: a #GstFlowReturn. */ GstFlowReturn gst_rtp_base_depayload_push_list (GstRTPBaseDepayload * filter, GstBufferList * out_list) { GstFlowReturn res; res = gst_rtp_base_depayload_prepare_push (filter, TRUE, &out_list); if (G_LIKELY (res == GST_FLOW_OK)) res = gst_pad_push_list (filter->srcpad, out_list); else gst_buffer_list_unref (out_list); return res; }
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; }
void gst_fragment_dispose (GObject * object) { GstFragmentPrivate *priv = GST_FRAGMENT (object)->priv; if (priv->buffer_list != NULL) { gst_buffer_list_iterator_free (priv->buffer_iterator); gst_buffer_list_unref (priv->buffer_list); priv->buffer_list = NULL; priv->size = 0; } if (priv->caps != NULL) { gst_caps_unref (priv->caps); priv->caps = NULL; } G_OBJECT_CLASS (gst_fragment_parent_class)->dispose (object); }
static void mpegpsmux_finalize (GObject * object) { MpegPsMux *mux = GST_MPEG_PSMUX (object); if (mux->collect) { gst_object_unref (mux->collect); mux->collect = NULL; } if (mux->psmux) { psmux_free (mux->psmux); mux->psmux = NULL; } if (mux->gop_list != NULL) { gst_buffer_list_unref (mux->gop_list); mux->gop_list = NULL; } G_OBJECT_CLASS (mpegpsmux_parent_class)->finalize (object); }
static void mpegpsmux_dispose (GObject * object) { MpegPsMux *mux = GST_MPEG_PSMUX (object); if (mux->collect) { gst_object_unref (mux->collect); mux->collect = NULL; } if (mux->psmux) { psmux_free (mux->psmux); mux->psmux = NULL; } if (mux->gop_list != NULL) { gst_buffer_list_unref (mux->gop_list); mux->gop_list = NULL; } GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object)); }
static GstFlowReturn gst_rtp_mux_chain_list (GstPad * pad, GstObject * parent, GstBufferList * bufferlist) { GstRTPMux *rtp_mux; GstFlowReturn ret; GstRTPMuxPadPrivate *padpriv; gboolean changed = FALSE; struct BufferListData bd; rtp_mux = GST_RTP_MUX (parent); if (gst_pad_check_reconfigure (rtp_mux->srcpad)) { GstCaps *current_caps = gst_pad_get_current_caps (pad); if (!gst_rtp_mux_setcaps (pad, rtp_mux, current_caps)) { ret = GST_FLOW_NOT_NEGOTIATED; gst_buffer_list_unref (bufferlist); goto out; } gst_caps_unref (current_caps); } GST_OBJECT_LOCK (rtp_mux); padpriv = gst_pad_get_element_private (pad); if (!padpriv) { GST_OBJECT_UNLOCK (rtp_mux); ret = GST_FLOW_NOT_LINKED; gst_buffer_list_unref (bufferlist); goto out; } bd.rtp_mux = rtp_mux; bd.padpriv = padpriv; bd.drop = FALSE; bufferlist = gst_buffer_list_make_writable (bufferlist); gst_buffer_list_foreach (bufferlist, process_list_item, &bd); if (!bd.drop && pad != rtp_mux->last_pad) { changed = TRUE; g_clear_object (&rtp_mux->last_pad); rtp_mux->last_pad = g_object_ref (pad); } GST_OBJECT_UNLOCK (rtp_mux); if (changed) gst_pad_sticky_events_foreach (pad, resend_events, rtp_mux); if (bd.drop) { gst_buffer_list_unref (bufferlist); ret = GST_FLOW_OK; } else { ret = gst_pad_push_list (rtp_mux->srcpad, bufferlist); } out: return ret; }
static void cleanup (void) { gst_caps_unref (caps); gst_buffer_list_unref (list); }
static gboolean gst_rtp_ulpfec_dec_handle_packet_loss (GstRtpUlpFecDec * self, guint16 seqnum, GstClockTime timestamp, GstClockTime duration) { gint caps_pt = self->have_caps_pt ? self->caps_pt : -1; gboolean ret = TRUE; GstBufferList *buflist = rtp_storage_get_packets_for_recovery (self->storage, self->fec_pt, self->caps_ssrc, seqnum); if (buflist) { GstBuffer *recovered_buffer = NULL; guint16 recovered_seq = 0; guint8 recovered_pt = 0; gst_rtp_ulpfec_dec_start (self, buflist, self->fec_pt, seqnum); while (NULL != (recovered_buffer = gst_rtp_ulpfec_dec_recover (self, self->caps_ssrc, caps_pt, &recovered_pt, &recovered_seq))) { if (seqnum == recovered_seq) { GstBuffer *sent_buffer; GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; recovered_buffer = gst_buffer_make_writable (recovered_buffer); GST_BUFFER_PTS (recovered_buffer) = timestamp; /* GST_BUFFER_DURATION (recovered_buffer) = duration; * JB does not set the duration, so we will not too */ if (!self->lost_packet_from_storage) rtp_storage_put_recovered_packet (self->storage, recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq); GST_DEBUG_OBJECT (self, "Pushing recovered packet ssrc=0x%08x seq=%u %" GST_PTR_FORMAT, self->caps_ssrc, seqnum, recovered_buffer); sent_buffer = gst_buffer_copy_deep (recovered_buffer); gst_rtp_buffer_map (sent_buffer, GST_MAP_WRITE, &rtp); gst_rtp_buffer_set_seq (&rtp, self->next_seqnum++); gst_rtp_buffer_unmap (&rtp); ret = FALSE; self->unset_discont_flag = TRUE; self->chain_return_val = gst_pad_push (self->srcpad, sent_buffer); break; } rtp_storage_put_recovered_packet (self->storage, recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq); } gst_rtp_ulpfec_dec_stop (self); gst_buffer_list_unref (buflist); } GST_DEBUG_OBJECT (self, "Packet lost ssrc=0x%08x seq=%u", self->caps_ssrc, seqnum); return ret; }