gboolean gst_droidcamsrc_dev_start (GstDroidCamSrcDev * dev, gboolean apply_settings) { gboolean ret = FALSE; GstDroidCamSrc *src = GST_DROIDCAMSRC (GST_PAD_PARENT (dev->imgsrc->pad)); g_rec_mutex_lock (dev->lock); if (dev->running) { GST_WARNING_OBJECT (src, "preview is already running"); ret = TRUE; goto out; } GST_DEBUG_OBJECT (src, "dev start"); if (!gst_buffer_pool_set_active (dev->pool, TRUE)) { GST_ERROR_OBJECT (src, "Failed to activate buffer pool"); goto out; } if (apply_settings) { gst_droidcamsrc_apply_mode_settings (src, SET_ONLY); } /* now set params */ if (!gst_droidcamsrc_dev_set_params (dev)) { goto out; } if (dev->use_raw_data) { GST_INFO_OBJECT (src, "Using raw data mode"); droid_media_camera_set_preview_callback_flags (dev->cam, dev->c.CAMERA_FRAME_CALLBACK_FLAG_CAMERA); } else { GST_INFO_OBJECT (src, "Using native buffers mode"); droid_media_camera_set_preview_callback_flags (dev->cam, dev->c.CAMERA_FRAME_CALLBACK_FLAG_NOOP); } if (!droid_media_camera_start_preview (dev->cam)) { GST_ERROR_OBJECT (src, "error starting preview"); goto out; } dev->running = TRUE; ret = TRUE; out: if (ret != TRUE) { gst_buffer_pool_set_active (dev->pool, FALSE); } g_rec_mutex_unlock (dev->lock); return ret; }
static gboolean gst_gdk_pixbuf_dec_setup_pool (GstGdkPixbufDec * filter, GstVideoInfo * info) { GstCaps *target; GstQuery *query; GstBufferPool *pool; GstStructure *config; guint size, min, max; target = gst_pad_get_current_caps (filter->srcpad); /* try to get a bufferpool now */ /* find a pool for the negotiated caps now */ query = gst_query_new_allocation (target, TRUE); if (!gst_pad_peer_query (filter->srcpad, query)) { /* not a problem, we use the query defaults */ GST_DEBUG_OBJECT (filter, "ALLOCATION query failed"); } if (gst_query_get_n_allocation_pools (query) > 0) { /* we got configuration from our peer, parse them */ gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max); } else { pool = NULL; size = info->size; min = max = 0; } gst_query_unref (query); if (pool == NULL) { /* we did not get a pool, make one ourselves then */ pool = gst_buffer_pool_new (); } /* and configure */ config = gst_buffer_pool_get_config (pool); gst_buffer_pool_config_set_params (config, target, size, min, max); gst_buffer_pool_set_config (pool, config); if (filter->pool) { gst_buffer_pool_set_active (filter->pool, FALSE); gst_object_unref (filter->pool); } filter->pool = pool; /* and activate */ gst_buffer_pool_set_active (filter->pool, TRUE); gst_caps_unref (target); return TRUE; }
static void gst_dvdec_negotiate_pool (GstDVDec * dec, GstCaps * caps, GstVideoInfo * info) { GstQuery *query; GstBufferPool *pool; guint size, min, max; GstStructure *config; /* find a pool for the negotiated caps now */ query = gst_query_new_allocation (caps, TRUE); if (!gst_pad_peer_query (dec->srcpad, query)) { GST_DEBUG_OBJECT (dec, "didn't get downstream ALLOCATION hints"); } if (gst_query_get_n_allocation_pools (query) > 0) { /* we got configuration from our peer, parse them */ gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max); size = MAX (size, info->size); } else { pool = NULL; size = info->size; min = max = 0; } if (pool == NULL) { /* we did not get a pool, make one ourselves then */ pool = gst_video_buffer_pool_new (); } if (dec->pool) { gst_buffer_pool_set_active (dec->pool, FALSE); gst_object_unref (dec->pool); } dec->pool = pool; config = gst_buffer_pool_get_config (pool); gst_buffer_pool_config_set_params (config, caps, size, min, max); if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) { /* just set the option, if the pool can support it we will transparently use * it through the video info API. We could also see if the pool support this * option and only activate it then. */ gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META); } gst_buffer_pool_set_config (pool, config); /* and activate */ gst_buffer_pool_set_active (pool, TRUE); gst_query_unref (query); }
static MsdkSurface * get_surface_from_pool (GstMsdkVPP * thiz, GstBufferPool * pool, GstBufferPoolAcquireParams * params) { GstBuffer *new_buffer; mfxFrameSurface1 *new_surface; MsdkSurface *msdk_surface; if (!gst_buffer_pool_is_active (pool) && !gst_buffer_pool_set_active (pool, TRUE)) { GST_ERROR_OBJECT (pool, "failed to activate buffer pool"); return NULL; } if (gst_buffer_pool_acquire_buffer (pool, &new_buffer, params) != GST_FLOW_OK) { GST_ERROR_OBJECT (pool, "failed to acquire a buffer from pool"); return NULL; } if (gst_msdk_is_msdk_buffer (new_buffer)) new_surface = gst_msdk_get_surface_from_buffer (new_buffer); else { GST_ERROR_OBJECT (pool, "the acquired memory is not MSDK memory"); return NULL; } msdk_surface = g_slice_new0 (MsdkSurface); msdk_surface->surface = new_surface; msdk_surface->buf = new_buffer; return msdk_surface; }
static gboolean gst_v4l2_transform_decide_allocation (GstBaseTransform * trans, GstQuery * query) { GstV4l2Transform *self = GST_V4L2_TRANSFORM (trans); gboolean ret = FALSE; GST_DEBUG_OBJECT (self, "called"); if (gst_v4l2_object_decide_allocation (self->v4l2capture, query)) { GstBufferPool *pool = GST_BUFFER_POOL (self->v4l2capture->pool); ret = GST_BASE_TRANSFORM_CLASS (parent_class)->decide_allocation (trans, query); if (!gst_buffer_pool_set_active (pool, TRUE)) goto activate_failed; } return ret; activate_failed: GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, ("failed to activate bufferpool"), ("failed to activate bufferpool")); return TRUE; }
static GstBuffer * create_output_buffer (GstMfxPostproc * vpp) { GstBuffer *outbuf = NULL; GstFlowReturn ret; GstBufferPool *const pool = GST_MFX_PLUGIN_BASE (vpp)->srcpad_buffer_pool; g_return_val_if_fail (pool != NULL, NULL); if (!gst_buffer_pool_set_active (pool, TRUE)) goto error_activate_pool; ret = gst_buffer_pool_acquire_buffer (pool, &outbuf, NULL); if (GST_FLOW_OK != ret || !outbuf) goto error_create_buffer; return outbuf; /* Errors */ error_activate_pool: { GST_ERROR ("failed to activate output video buffer pool"); return NULL; } error_create_buffer: { GST_ERROR ("failed to create output video buffer"); return NULL; } }
/** * gst_vaapi_plugin_base_set_caps: * @plugin: a #GstVaapiPluginBase * @incaps: the sink pad (input) caps * @outcaps: the src pad (output) caps * * Notifies the base plugin object of the new input and output caps, * obtained from the subclass. * * Returns: %TRUE if the update of caps was successful, %FALSE otherwise. */ gboolean gst_vaapi_plugin_base_set_caps (GstVaapiPluginBase * plugin, GstCaps * incaps, GstCaps * outcaps) { if (incaps && incaps != plugin->sinkpad_caps) { if (!gst_video_info_from_caps (&plugin->sinkpad_info, incaps)) return FALSE; gst_caps_replace (&plugin->sinkpad_caps, incaps); plugin->sinkpad_caps_is_raw = !gst_caps_has_vaapi_surface (incaps); } if (outcaps && outcaps != plugin->srcpad_caps) { if (!gst_video_info_from_caps (&plugin->srcpad_info, outcaps)) return FALSE; if (plugin->srcpad_buffer_pool && !gst_vaapi_buffer_pool_caps_is_equal (plugin->srcpad_buffer_pool, outcaps)) { gst_buffer_pool_set_active (plugin->srcpad_buffer_pool, FALSE); g_clear_object (&plugin->srcpad_buffer_pool); g_clear_object (&plugin->srcpad_allocator); plugin_reset_texture_map (plugin); } gst_caps_replace (&plugin->srcpad_caps, outcaps); } if (!ensure_sinkpad_buffer_pool (plugin, plugin->sinkpad_caps)) return FALSE; return TRUE; }
static GstStateChangeReturn gst_monoscope_change_state (GstElement * element, GstStateChange transition) { GstMonoscope *monoscope = GST_MONOSCOPE (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: gst_monoscope_reset (monoscope); break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: if (monoscope->pool) { gst_buffer_pool_set_active (monoscope->pool, FALSE); gst_object_replace ((GstObject **) & monoscope->pool, NULL); } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static GstBuffer * create_output_buffer (GstMsdkVPP * thiz) { GstBuffer *outbuf; GstFlowReturn ret; GstBufferPool *pool = thiz->srcpad_buffer_pool; g_return_val_if_fail (pool != NULL, NULL); if (!gst_buffer_pool_is_active (pool) && !gst_buffer_pool_set_active (pool, TRUE)) goto error_activate_pool; outbuf = NULL; ret = gst_buffer_pool_acquire_buffer (pool, &outbuf, NULL); if (ret != GST_FLOW_OK || !outbuf) goto error_create_buffer; return outbuf; /* ERRORS */ error_activate_pool: { GST_ERROR_OBJECT (thiz, "failed to activate output video buffer pool"); return NULL; } error_create_buffer: { GST_ERROR_OBJECT (thiz, "failed to create output video buffer"); return NULL; } }
static GstStateChangeReturn gst_goom_change_state (GstElement * element, GstStateChange transition) { GstGoom *goom = GST_GOOM (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: gst_goom_reset (goom); break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: if (goom->pool) { gst_buffer_pool_set_active (goom->pool, FALSE); gst_object_replace ((GstObject **) & goom->pool, NULL); } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static GstFlowReturn gst_rtp_vraw_depay_negotiate_pool (GstRtpVRawDepay * depay, GstCaps * caps, GstVideoInfo * info) { GstQuery *query; GstBufferPool *pool = NULL; guint size, min, max; GstStructure *config; /* find a pool for the negotiated caps now */ query = gst_query_new_allocation (caps, TRUE); if (!gst_pad_peer_query (GST_RTP_BASE_DEPAYLOAD_SRCPAD (depay), query)) { /* not a problem, we use the defaults of query */ GST_DEBUG_OBJECT (depay, "could not get downstream ALLOCATION hints"); } if (gst_query_get_n_allocation_pools (query) > 0) { /* we got configuration from our peer, parse them */ gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max); } else { GST_DEBUG_OBJECT (depay, "didn't get downstream pool hints"); size = info->size; min = max = 0; } if (pool == NULL) { /* we did not get a pool, make one ourselves then */ pool = gst_video_buffer_pool_new (); } if (depay->pool) gst_object_unref (depay->pool); depay->pool = pool; config = gst_buffer_pool_get_config (pool); gst_buffer_pool_config_set_params (config, caps, size, min, max); if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) { /* just set the metadata, if the pool can support it we will transparently use * it through the video info API. We could also see if the pool support this * metadata and only activate it then. */ gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META); } gst_buffer_pool_set_config (pool, config); /* and activate */ gst_buffer_pool_set_active (pool, TRUE); gst_query_unref (query); return GST_FLOW_OK; }
static GstStateChangeReturn gst_dvdec_change_state (GstElement * element, GstStateChange transition) { GstDVDec *dvdec = GST_DVDEC (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: dvdec->decoder = dv_decoder_new (0, dvdec->clamp_luma, dvdec->clamp_chroma); dvdec->decoder->quality = qualities[dvdec->quality]; dv_set_error_log (dvdec->decoder, NULL); gst_video_info_init (&dvdec->vinfo); gst_segment_init (&dvdec->segment, GST_FORMAT_UNDEFINED); dvdec->src_negotiated = FALSE; dvdec->sink_negotiated = FALSE; dvdec->need_segment = FALSE; /* * Enable this function call when libdv2 0.100 or higher is more * common */ /* dv_set_quality (dvdec->decoder, qualities [dvdec->quality]); */ break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: dv_decoder_free (dvdec->decoder); dvdec->decoder = NULL; if (dvdec->pool) { gst_buffer_pool_set_active (dvdec->pool, FALSE); gst_object_unref (dvdec->pool); dvdec->pool = NULL; } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static GstFlowReturn gst_imx_compositor_get_output_buffer(GstImxBPVideoAggregator *videoaggregator, GstBuffer **outbuffer) { GstImxCompositor *compositor = GST_IMX_COMPOSITOR(videoaggregator); GstBufferPool *pool = compositor->dma_bufferpool; /* Return a DMA buffer from the pool. The output buffers produced by * the video aggregator base class will use this function to allocate. */ if (!gst_buffer_pool_is_active(pool)) gst_buffer_pool_set_active(pool, TRUE); return gst_buffer_pool_acquire_buffer(pool, outbuffer, NULL); }
static void gst_rtp_vraw_depay_reset (GstRtpVRawDepay * rtpvrawdepay) { if (rtpvrawdepay->outbuf) { gst_buffer_unref (rtpvrawdepay->outbuf); rtpvrawdepay->outbuf = NULL; } rtpvrawdepay->timestamp = -1; if (rtpvrawdepay->pool) { gst_buffer_pool_set_active (rtpvrawdepay->pool, FALSE); gst_object_unref (rtpvrawdepay->pool); rtpvrawdepay->pool = NULL; } }
static MsdkSurface * get_surface (GstMsdkDec * thiz, GstBuffer * buffer) { MsdkSurface *i; i = g_slice_new0 (MsdkSurface); if (gst_msdk_is_msdk_buffer (buffer)) { i->surface = gst_msdk_get_surface_from_buffer (buffer); i->buf = buffer; } else { /* Confirm to activate the side pool */ if (!gst_buffer_pool_is_active (thiz->pool) && !gst_buffer_pool_set_active (thiz->pool, TRUE)) { g_slice_free (MsdkSurface, i); return NULL; } if (!gst_video_frame_map (&i->copy, &thiz->non_msdk_pool_info, buffer, GST_MAP_WRITE)) goto failed_unref_buffer; if (gst_buffer_pool_acquire_buffer (thiz->pool, &buffer, NULL) != GST_FLOW_OK) goto failed_unmap_copy; i->surface = gst_msdk_get_surface_from_buffer (buffer); i->buf = buffer; if (!gst_video_frame_map (&i->data, &thiz->output_info, buffer, GST_MAP_READWRITE)) goto failed_unref_buffer2; } thiz->decoded_msdk_surfaces = g_list_append (thiz->decoded_msdk_surfaces, i); return i; failed_unref_buffer2: gst_buffer_unref (buffer); buffer = i->data.buffer; failed_unmap_copy: gst_video_frame_unmap (&i->copy); failed_unref_buffer: gst_buffer_unref (buffer); g_slice_free (MsdkSurface, i); GST_ERROR_OBJECT (thiz, "failed to handle buffer"); return NULL; }
static gboolean gst_mpeg2dec_flush (GstVideoDecoder * decoder) { GstMpeg2dec *mpeg2dec = GST_MPEG2DEC (decoder); /* reset the initial video state */ mpeg2dec->discont_state = MPEG2DEC_DISC_NEW_PICTURE; mpeg2_reset (mpeg2dec->decoder, 1); mpeg2_skip (mpeg2dec->decoder, 1); gst_mpeg2dec_clear_buffers (mpeg2dec); if (mpeg2dec->downstream_pool) gst_buffer_pool_set_active (mpeg2dec->downstream_pool, FALSE); return TRUE; }
static GstFlowReturn gst_gl_mixer_get_output_buffer (GstVideoAggregator * videoaggregator, GstBuffer ** outbuf) { GstGLMixer *mix = GST_GL_MIXER (videoaggregator); if (!mix->priv->pool_active) { if (!gst_buffer_pool_set_active (mix->priv->pool, TRUE)) { GST_ELEMENT_ERROR (mix, RESOURCE, SETTINGS, ("failed to activate bufferpool"), ("failed to activate bufferpool")); return GST_FLOW_ERROR; } mix->priv->pool_active = TRUE; } return gst_buffer_pool_acquire_buffer (mix->priv->pool, outbuf, NULL); }
static GstStateChangeReturn gst_gdk_pixbuf_dec_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstGdkPixbufDec *dec = GST_GDK_PIXBUF_DEC (element); switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: /* default to single image mode, setcaps function might not be called */ dec->in_fps_n = 0; dec->in_fps_d = 1; gst_video_info_init (&dec->info); break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: dec->in_fps_n = 0; dec->in_fps_d = 0; if (dec->pool) { gst_buffer_pool_set_active (dec->pool, FALSE); gst_object_replace ((GstObject **) & dec->pool, NULL); } g_list_free_full (dec->pending_events, (GDestroyNotify) gst_event_unref); dec->pending_events = NULL; if (dec->pixbuf_loader != NULL) { gdk_pixbuf_loader_close (dec->pixbuf_loader, NULL); g_object_unref (G_OBJECT (dec->pixbuf_loader)); dec->pixbuf_loader = NULL; } break; default: break; } return ret; }
void gst_droid_cam_src_stream_window_clear (GstDroidCamSrcStreamWindow * win) { GST_DEBUG ("stream window clear"); g_mutex_lock (&win->lock); if (win->pool) { if (!gst_buffer_pool_set_active (GST_BUFFER_POOL (win->pool), FALSE)) { GST_ERROR ("failed to deactivate buffer pool"); } gst_object_unref (win->pool); win->pool = NULL; } g_mutex_unlock (&win->lock); }
/* takes ownership of the pool, allocator and query */ static gboolean gst_gl_mixer_set_allocation (GstGLMixer * mix, GstBufferPool * pool, GstAllocator * allocator, GstAllocationParams * params, GstQuery * query) { GstAllocator *oldalloc; GstBufferPool *oldpool; GstQuery *oldquery; GstGLMixerPrivate *priv = mix->priv; GST_DEBUG ("storing allocation query"); GST_OBJECT_LOCK (mix); oldpool = priv->pool; priv->pool = pool; priv->pool_active = FALSE; oldalloc = priv->allocator; priv->allocator = allocator; oldquery = priv->query; priv->query = query; if (params) priv->params = *params; else gst_allocation_params_init (&priv->params); GST_OBJECT_UNLOCK (mix); if (oldpool) { GST_DEBUG_OBJECT (mix, "deactivating old pool %p", oldpool); gst_buffer_pool_set_active (oldpool, FALSE); gst_object_unref (oldpool); } if (oldalloc) { gst_object_unref (oldalloc); } if (oldquery) { gst_query_unref (oldquery); } return TRUE; }
void gst_droid_cam_src_stream_window_destroy (GstDroidCamSrcStreamWindow * win) { GST_DEBUG ("stream window destroy"); gst_object_unref (win->allocator); win->allocator = NULL; g_mutex_clear (&win->lock); if (win->pool) { if (!gst_buffer_pool_set_active (GST_BUFFER_POOL (win->pool), FALSE)) { GST_ERROR ("failed to deactivate buffer pool"); } gst_object_unref (win->pool); } g_slice_free (GstDroidCamSrcStreamWindow, win); }
static GstStateChangeReturn gst_y4m_dec_change_state (GstElement * element, GstStateChange transition) { GstY4mDec *y4mdec; GstStateChangeReturn ret; g_return_val_if_fail (GST_IS_Y4M_DEC (element), GST_STATE_CHANGE_FAILURE); y4mdec = GST_Y4M_DEC (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: if (y4mdec->pool) { gst_buffer_pool_set_active (y4mdec->pool, FALSE); gst_object_unref (y4mdec->pool); } y4mdec->pool = NULL; break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
static void gst_buffer_pool_finalize (GObject * object) { GstBufferPool *pool; GstBufferPoolPrivate *priv; pool = GST_BUFFER_POOL_CAST (object); priv = pool->priv; GST_DEBUG_OBJECT (pool, "finalize"); gst_buffer_pool_set_active (pool, FALSE); gst_atomic_queue_unref (priv->queue); gst_poll_free (priv->poll); gst_structure_free (priv->config); g_rec_mutex_clear (&priv->rec_lock); if (priv->allocator) gst_object_unref (priv->allocator); G_OBJECT_CLASS (gst_buffer_pool_parent_class)->finalize (object); }
static gboolean gst_mpeg2dec_stop (GstVideoDecoder * decoder) { GstMpeg2dec *mpeg2dec = GST_MPEG2DEC (decoder); mpeg2_reset (mpeg2dec->decoder, 0); mpeg2_skip (mpeg2dec->decoder, 1); gst_mpeg2dec_clear_buffers (mpeg2dec); if (mpeg2dec->input_state) gst_video_codec_state_unref (mpeg2dec->input_state); mpeg2dec->input_state = NULL; if (mpeg2dec->downstream_pool) { gst_buffer_pool_set_active (mpeg2dec->downstream_pool, FALSE); gst_object_unref (mpeg2dec->downstream_pool); } return TRUE; }
static GstFlowReturn gst_gl_stereo_mix_get_output_buffer (GstVideoAggregator * videoaggregator, GstBuffer ** outbuf) { GstGLStereoMix *mix = GST_GL_STEREO_MIX (videoaggregator); GstFlowReturn ret = GST_FLOW_OK; #if 0 if (!mix->priv->pool_active) { if (!gst_buffer_pool_set_active (mix->priv->pool, TRUE)) { GST_ELEMENT_ERROR (mix, RESOURCE, SETTINGS, ("failed to activate bufferpool"), ("failed to activate bufferpool")); return GST_FLOW_ERROR; } mix->priv->pool_active = TRUE; } return gst_buffer_pool_acquire_buffer (mix->priv->pool, outbuf, NULL); #endif if (!gst_gl_stereo_mix_make_output (mix)) { gst_buffer_replace (&mix->primary_out, NULL); gst_buffer_replace (&mix->auxilliary_out, NULL); GST_ELEMENT_ERROR (mix, RESOURCE, SETTINGS, ("Failed to generate output"), ("failed to generate output")); ret = GST_FLOW_ERROR; } if (mix->auxilliary_out) { *outbuf = mix->auxilliary_out; mix->auxilliary_out = NULL; } else { *outbuf = mix->primary_out; mix->primary_out = NULL; } return ret; }
void gst_droidcamsrc_dev_stop (GstDroidCamSrcDev * dev) { g_rec_mutex_lock (dev->lock); GST_DEBUG ("dev stop"); if (dev->running) { GST_DEBUG ("stopping preview"); gst_buffer_pool_set_active (dev->pool, FALSE); droid_media_camera_stop_preview (dev->cam); dev->running = FALSE; GST_DEBUG ("stopped preview"); } /* Now we need to empty the queue */ g_mutex_lock (&dev->vfsrc->lock); g_queue_foreach (dev->vfsrc->queue, (GFunc) gst_buffer_unref, NULL); g_queue_clear (dev->vfsrc->queue); g_mutex_unlock (&dev->vfsrc->lock); g_rec_mutex_unlock (dev->lock); }
static gboolean gst_v4l2src_decide_allocation (GstBaseSrc * bsrc, GstQuery * query) { GstV4l2Src *src = GST_V4L2SRC (bsrc); gboolean ret = TRUE; if (src->pending_set_fmt) { GstCaps *caps = gst_pad_get_current_caps (GST_BASE_SRC_PAD (bsrc)); if (!gst_v4l2_object_stop (src->v4l2object)) return FALSE; ret = gst_v4l2src_set_format (src, caps); gst_caps_unref (caps); src->pending_set_fmt = FALSE; } if (ret) { ret = gst_v4l2_object_decide_allocation (src->v4l2object, query); if (ret) ret = GST_BASE_SRC_CLASS (parent_class)->decide_allocation (bsrc, query); } if (ret) { if (!gst_buffer_pool_set_active (src->v4l2object->pool, TRUE)) goto activate_failed; } return ret; activate_failed: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (_("Failed to allocate required memory.")), ("Buffer pool activation failed")); return FALSE; } }
static gboolean gst_v4l2src_decide_allocation (GstBaseSrc * bsrc, GstQuery * query) { GstV4l2Src *src = GST_V4L2SRC (bsrc); gboolean ret = FALSE; if (gst_v4l2_object_decide_allocation (src->v4l2object, query)) ret = GST_BASE_SRC_CLASS (parent_class)->decide_allocation (bsrc, query); if (ret) { if (!gst_buffer_pool_set_active (src->v4l2object->pool, TRUE)) goto activate_failed; } return ret; activate_failed: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (_("Failed to allocate required memory.")), ("Buffer pool activation failed")); return FALSE; } }
static GstStateChangeReturn gst_gdk_pixbuf_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstGdkPixbuf *dec = GST_GDK_PIXBUF (element); switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: /* default to single image mode, setcaps function might not be called */ dec->in_fps_n = 0; dec->in_fps_d = 1; gst_video_info_init (&dec->info); break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: dec->in_fps_n = 0; dec->in_fps_d = 0; if (dec->pool) { gst_buffer_pool_set_active (dec->pool, FALSE); gst_object_replace ((GstObject **) & dec->pool, NULL); } break; default: break; } return ret; }
/** * ensure_sinkpad_buffer_pool: * @plugin: a #GstVaapiPluginBase * @caps: the initial #GstCaps for the resulting buffer pool * * Makes sure the sink pad video buffer pool is created with the * appropriate @caps. * * Returns: %TRUE if successful, %FALSE otherwise. */ static gboolean ensure_sinkpad_buffer_pool (GstVaapiPluginBase * plugin, GstCaps * caps) { GstBufferPool *pool; guint size; /* video decoders don't use a buffer pool in the sink pad */ if (GST_IS_VIDEO_DECODER (plugin)) return TRUE; if (!gst_vaapi_plugin_base_ensure_display (plugin)) return FALSE; if (plugin->sinkpad_buffer_pool) { if (gst_vaapi_buffer_pool_caps_is_equal (plugin->sinkpad_buffer_pool, caps)) return TRUE; gst_buffer_pool_set_active (plugin->sinkpad_buffer_pool, FALSE); g_clear_object (&plugin->sinkpad_buffer_pool); g_clear_object (&plugin->sinkpad_allocator); plugin->sinkpad_buffer_size = 0; } if (!ensure_sinkpad_allocator (plugin, caps, &size)) return FALSE; pool = gst_vaapi_plugin_base_create_pool (plugin, caps, size, BUFFER_POOL_SINK_MIN_BUFFERS, 0, GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META, plugin->sinkpad_allocator); if (!pool) return FALSE; plugin->sinkpad_buffer_pool = pool; plugin->sinkpad_buffer_size = size; return TRUE; }