static void
gst_opus_dec_reset (GstOpusDec * dec)
{
gst_segment_init (&dec->segment, GST_FORMAT_UNDEFINED);
dec->granulepos = -1;
dec->packetno = 0;
dec->frame_size = 0;
dec->frame_samples = 960;
dec->frame_duration = 0;
if (dec->state) {
opus_decoder_destroy (dec->state);
dec->state = NULL;
}
#if 0
if (dec->mode) {
opus_mode_destroy (dec->mode);
dec->mode = NULL;
}
#endif
gst_buffer_replace (&dec->streamheader, NULL);
gst_buffer_replace (&dec->vorbiscomment, NULL);
g_list_foreach (dec->extra_headers, (GFunc) gst_mini_object_unref, NULL);
g_list_free (dec->extra_headers);
dec->extra_headers = NULL;
#if 0
memset (&dec->header, 0, sizeof (dec->header));
#endif
}
static void
gst_speex_dec_reset (GstSpeexDec * dec)
{
dec->packetno = 0;
dec->frame_size = 0;
dec->frame_duration = 0;
dec->mode = NULL;
free (dec->header);
dec->header = NULL;
speex_bits_destroy (&dec->bits);
speex_bits_set_bit_buffer (&dec->bits, NULL, 0);
gst_buffer_replace (&dec->streamheader, NULL);
gst_buffer_replace (&dec->vorbiscomment, NULL);
if (dec->stereo) {
speex_stereo_state_destroy (dec->stereo);
dec->stereo = NULL;
}
if (dec->state) {
speex_decoder_destroy (dec->state);
dec->state = NULL;
}
}
static void
gst_hls_demux_clear_pending_data (GstHLSDemux * hlsdemux)
{
gst_hls_demux_decrypt_end (hlsdemux);
gst_adapter_clear (hlsdemux->pending_encrypted_data);
gst_buffer_replace (&hlsdemux->pending_decrypted_buffer, NULL);
gst_buffer_replace (&hlsdemux->pending_typefind_buffer, NULL);
hlsdemux->current_offset = -1;
}
static gboolean
opus_dec_sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstOpusDec *dec = GST_OPUS_DEC (gst_pad_get_parent (pad));
gboolean ret = TRUE;
GstStructure *s;
const GValue *streamheader;
s = gst_caps_get_structure (caps, 0);
if ((streamheader = gst_structure_get_value (s, "streamheader")) &&
G_VALUE_HOLDS (streamheader, GST_TYPE_ARRAY) &&
gst_value_array_get_size (streamheader) >= 2) {
const GValue *header;
GstBuffer *buf;
GstFlowReturn res = GST_FLOW_OK;
header = gst_value_array_get_value (streamheader, 0);
if (header && G_VALUE_HOLDS (header, GST_TYPE_BUFFER)) {
buf = gst_value_get_buffer (header);
res = opus_dec_chain_parse_header (dec, buf);
if (res != GST_FLOW_OK)
goto done;
gst_buffer_replace (&dec->streamheader, buf);
}
#if 0
vorbiscomment = gst_value_array_get_value (streamheader, 1);
if (vorbiscomment && G_VALUE_HOLDS (vorbiscomment, GST_TYPE_BUFFER)) {
buf = gst_value_get_buffer (vorbiscomment);
res = opus_dec_chain_parse_comments (dec, buf);
if (res != GST_FLOW_OK)
goto done;
gst_buffer_replace (&dec->vorbiscomment, buf);
}
#endif
g_list_foreach (dec->extra_headers, (GFunc) gst_mini_object_unref, NULL);
g_list_free (dec->extra_headers);
dec->extra_headers = NULL;
if (gst_value_array_get_size (streamheader) > 2) {
gint i, n;
n = gst_value_array_get_size (streamheader);
for (i = 2; i < n; i++) {
header = gst_value_array_get_value (streamheader, i);
buf = gst_value_get_buffer (header);
dec->extra_headers =
g_list_prepend (dec->extra_headers, gst_buffer_ref (buf));
}
}
}
done:
gst_object_unref (dec);
return ret;
}
void
gtk_gst_base_widget_finalize (GObject * object)
{
GtkGstBaseWidget *widget = GTK_GST_BASE_WIDGET (object);
gst_buffer_replace (&widget->pending_buffer, NULL);
gst_buffer_replace (&widget->buffer, NULL);
g_mutex_clear (&widget->lock);
g_weak_ref_clear (&widget->element);
if (widget->draw_id)
g_source_remove (widget->draw_id);
}
static gboolean
gst_audio_aggregator_mix_buffer (GstAudioAggregator * aagg,
GstAudioAggregatorPad * pad, GstBuffer * inbuf, GstBuffer * outbuf)
{
guint overlap;
guint out_start;
gboolean filled;
guint blocksize;
blocksize = gst_util_uint64_scale (aagg->priv->output_buffer_duration,
GST_AUDIO_INFO_RATE (&aagg->info), GST_SECOND);
blocksize = MAX (1, blocksize);
/* Overlap => mix */
if (aagg->priv->offset < pad->priv->output_offset)
out_start = pad->priv->output_offset - aagg->priv->offset;
else
out_start = 0;
overlap = pad->priv->size - pad->priv->position;
if (overlap > blocksize - out_start)
overlap = blocksize - out_start;
if (GST_BUFFER_FLAG_IS_SET (inbuf, GST_BUFFER_FLAG_GAP)) {
/* skip gap buffer */
GST_LOG_OBJECT (pad, "skipping GAP buffer");
pad->priv->output_offset += pad->priv->size - pad->priv->position;
pad->priv->position = pad->priv->size;
gst_buffer_replace (&pad->priv->buffer, NULL);
return FALSE;
}
filled = GST_AUDIO_AGGREGATOR_GET_CLASS (aagg)->aggregate_one_buffer (aagg,
pad, inbuf, pad->priv->position, outbuf, out_start, overlap);
if (filled)
GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_GAP);
pad->priv->position += overlap;
pad->priv->output_offset += overlap;
if (pad->priv->position == pad->priv->size) {
/* Buffer done, drop it */
gst_buffer_replace (&pad->priv->buffer, NULL);
GST_DEBUG_OBJECT (pad, "Finished mixing buffer, waiting for next");
return FALSE;
}
return TRUE;
}
static void
gst_v4l2_buffer_pool_dispose (GObject * object)
{
GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (object);
gint i;
for (i = 0; i < VIDEO_MAX_FRAME; i++) {
if (pool->buffers[i])
gst_buffer_replace (&(pool->buffers[i]), NULL);
}
if (pool->vallocator)
gst_object_unref (pool->vallocator);
pool->vallocator = NULL;
if (pool->allocator)
gst_object_unref (pool->allocator);
pool->allocator = NULL;
if (pool->other_pool)
gst_object_unref (pool->other_pool);
pool->other_pool = NULL;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
/* With LOCK */
static gboolean
gst_ffmpegauddec_close (GstFFMpegAudDec * ffmpegdec, gboolean reset)
{
GstFFMpegAudDecClass *oclass;
oclass = (GstFFMpegAudDecClass *) (G_OBJECT_GET_CLASS (ffmpegdec));
GST_LOG_OBJECT (ffmpegdec, "closing libav codec");
gst_caps_replace (&ffmpegdec->last_caps, NULL);
gst_buffer_replace (&ffmpegdec->outbuf, NULL);
gst_ffmpeg_avcodec_close (ffmpegdec->context);
ffmpegdec->opened = FALSE;
if (ffmpegdec->context->extradata) {
av_free (ffmpegdec->context->extradata);
ffmpegdec->context->extradata = NULL;
}
if (reset) {
if (avcodec_get_context_defaults3 (ffmpegdec->context,
oclass->in_plugin) < 0) {
GST_DEBUG_OBJECT (ffmpegdec, "Failed to set context defaults");
return FALSE;
}
ffmpegdec->context->opaque = ffmpegdec;
}
return TRUE;
}
static GstFlowReturn
allocate_output_buffer (GstMsdkDec * thiz, GstBuffer ** buffer)
{
GstFlowReturn flow;
GstVideoCodecFrame *frame;
GstVideoDecoder *decoder = GST_VIDEO_DECODER (thiz);
frame = gst_msdkdec_get_oldest_frame (decoder);
if (!frame) {
if (GST_PAD_IS_FLUSHING (decoder->srcpad))
return GST_FLOW_FLUSHING;
else
return GST_FLOW_ERROR;
}
if (!frame->output_buffer) {
flow = gst_video_decoder_allocate_output_frame (decoder, frame);
if (flow != GST_FLOW_OK) {
gst_video_codec_frame_unref (frame);
return flow;
}
}
*buffer = gst_buffer_ref (frame->output_buffer);
gst_buffer_replace (&frame->output_buffer, NULL);
gst_video_codec_frame_unref (frame);
return GST_FLOW_OK;
}
static gboolean webkitVideoSinkTimeoutCallback(gpointer data)
{
WebKitVideoSink* sink = reinterpret_cast<WebKitVideoSink*>(data);
WebKitVideoSinkPrivate* priv = sink->priv;
g_mutex_lock(priv->bufferMutex);
GstBuffer* buffer = priv->buffer;
priv->buffer = 0;
priv->timeoutId = 0;
if (!buffer || priv->unlocked || UNLIKELY(!GST_IS_BUFFER(buffer))) {
g_cond_signal(priv->dataCondition);
g_mutex_unlock(priv->bufferMutex);
return FALSE;
}
g_signal_emit(sink, webkitVideoSinkSignals[REPAINT_REQUESTED], 0, buffer);
#if USE(OPENGL_ES_2) && GST_CHECK_VERSION(1, 3, 0)
gst_buffer_replace (&priv->last_buffer, buffer);
#endif
gst_buffer_unref(buffer);
g_cond_signal(priv->dataCondition);
g_mutex_unlock(priv->bufferMutex);
return FALSE;
}
static gboolean
gst_droidadec_stop (GstAudioDecoder * decoder)
{
GstDroidADec *dec = GST_DROIDADEC (decoder);
GST_DEBUG_OBJECT (dec, "stop");
if (dec->codec) {
droid_media_codec_stop (dec->codec);
droid_media_codec_destroy (dec->codec);
dec->codec = NULL;
}
gst_adapter_flush (dec->adapter, gst_adapter_available (dec->adapter));
g_mutex_lock (&dec->eos_lock);
dec->eos = FALSE;
g_mutex_unlock (&dec->eos_lock);
gst_buffer_replace (&dec->codec_data, NULL);
if (dec->codec_type) {
gst_droid_codec_unref (dec->codec_type);
dec->codec_type = NULL;
}
return TRUE;
}
static gpointer
get_buffer_thread (gpointer data)
{
App *app = data;
GstVaapiEncoderStatus ret;
GstBuffer *obuf;
while (1) {
obuf = NULL;
ret = get_encoder_buffer (app->encoder, &obuf);
if (app->input_stopped && ret > GST_VAAPI_ENCODER_STATUS_SUCCESS) {
break; /* finished */
} else if (ret > GST_VAAPI_ENCODER_STATUS_SUCCESS) { /* another chance */
continue;
}
if (ret < GST_VAAPI_ENCODER_STATUS_SUCCESS) { /* fatal error */
app->encode_failed = TRUE;
break;
}
app->encoded_frames++;
g_debug ("encoded frame %d, buffer = %p", app->encoded_frames, obuf);
if (app->output_file && outputs_to_file (obuf, app->output_file))
app->saved_frames++;
gst_buffer_unref (obuf);
}
if (obuf)
gst_buffer_replace (&obuf, NULL);
return NULL;
}
static gboolean
gst_mfc_dec_stop (GstVideoDecoder * video_decoder)
{
GstMFCDec *self = GST_MFC_DEC (video_decoder);
GST_DEBUG_OBJECT (self, "Stopping");
gst_buffer_replace (&self->codec_data, NULL);
if (self->input_state) {
gst_video_codec_state_unref (self->input_state);
self->input_state = NULL;
}
if (self->context) {
mfc_dec_destroy (self->context);
self->context = NULL;
}
self->initialized = FALSE;
if (self->fimc) {
fimc_free (self->fimc);
self->fimc = NULL;
}
GST_DEBUG_OBJECT (self, "Stopped");
return TRUE;
}
static gboolean
set_caps (GstVaapiDecoder * decoder, const GstCaps * caps)
{
GstVideoCodecState *const codec_state = decoder->codec_state;
GstStructure *const structure = gst_caps_get_structure (caps, 0);
GstVaapiProfile profile;
const GValue *v_codec_data;
profile = gst_vaapi_profile_from_caps (caps);
if (!profile)
return FALSE;
decoder->codec = gst_vaapi_profile_get_codec (profile);
if (!decoder->codec)
return FALSE;
if (!gst_video_info_from_caps (&codec_state->info, caps))
return FALSE;
codec_state->caps = gst_caps_copy (caps);
v_codec_data = gst_structure_get_value (structure, "codec_data");
if (v_codec_data)
gst_buffer_replace (&codec_state->codec_data,
gst_value_get_buffer (v_codec_data));
return TRUE;
}
static gboolean
gst_shape_wipe_mask_sink_event (GstPad * pad, GstObject * parent,
GstEvent * event)
{
GstShapeWipe *self = GST_SHAPE_WIPE (parent);
GST_LOG_OBJECT (pad, "Got %s event", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
{
GstCaps *caps;
gst_event_parse_caps (event, &caps);
gst_shape_wipe_mask_sink_setcaps (self, caps);
break;
}
case GST_EVENT_FLUSH_STOP:
g_mutex_lock (&self->mask_mutex);
gst_buffer_replace (&self->mask, NULL);
g_mutex_unlock (&self->mask_mutex);
break;
default:
break;
}
/* Dropping all events here */
gst_event_unref (event);
return TRUE;
}
static GstFlowReturn
gst_h264_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
{
GstH264Parse *h264parse;
GstBuffer *buffer;
guint av;
h264parse = GST_H264_PARSE (parse);
buffer = frame->buffer;
gst_h264_parse_update_src_caps (h264parse);
gst_h264_params_get_timestamp (h264parse->params,
&GST_BUFFER_TIMESTAMP (buffer), &GST_BUFFER_DURATION (buffer),
h264parse->frame_start);
if (h264parse->keyframe)
GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
else
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
/* replace with transformed AVC output if applicable */
av = gst_adapter_available (h264parse->frame_out);
if (av) {
GstBuffer *buf;
buf = gst_adapter_take_buffer (h264parse->frame_out, av);
gst_buffer_copy_metadata (buf, buffer, GST_BUFFER_COPY_ALL);
gst_buffer_replace (&frame->buffer, buf);
}
return GST_FLOW_OK;
}
static gboolean webkitVideoSinkQuery(GstBaseSink* baseSink, GstQuery* query)
{
WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink);
WebKitVideoSinkPrivate* priv = sink->priv;
switch (GST_QUERY_TYPE(query)) {
case GST_QUERY_DRAIN:
{
#if USE(OPENGL_ES_2) && GST_CHECK_VERSION(1, 3, 0)
GST_OBJECT_LOCK (sink);
if (priv->last_buffer)
gst_buffer_replace (&priv->last_buffer, NULL);
g_signal_emit(sink, webkitVideoSinkSignals[DRAIN], 0);
GST_OBJECT_UNLOCK (sink);
#endif
return TRUE;
}
case GST_QUERY_CONTEXT:
{
return gst_gl_handle_context_query(GST_ELEMENT(sink), query, &priv->display);
break;
}
default:
return GST_CALL_PARENT_WITH_DEFAULT(GST_BASE_SINK_CLASS, query, (baseSink, query), TRUE);
break;
}
}
static void
handoff_buffer_cb (GstElement * fakesink, GstBuffer * buffer, GstPad * pad,
gpointer user_data)
{
GST_DEBUG ("got buffer %p", buffer);
gst_buffer_replace (&handoff_buffer, buffer);
}
static void
gst_dvd_spu_clear (GstDVDSpu * dvdspu)
{
gst_dvd_spu_flush_spu_info (dvdspu, FALSE);
gst_segment_init (&dvdspu->subp_seg, GST_FORMAT_UNDEFINED);
dvdspu->spu_input_type = SPU_INPUT_TYPE_NONE;
gst_buffer_replace (&dvdspu->ref_frame, NULL);
gst_buffer_replace (&dvdspu->pending_frame, NULL);
dvdspu->spu_state.info.fps_n = 25;
dvdspu->spu_state.info.fps_d = 1;
gst_segment_init (&dvdspu->video_seg, GST_FORMAT_UNDEFINED);
}
static void
gst_app_sink_dispose (GObject * obj)
{
GstAppSink *appsink = GST_APP_SINK_CAST (obj);
GstAppSinkPrivate *priv = appsink->priv;
GstMiniObject *queue_obj;
GST_OBJECT_LOCK (appsink);
if (priv->caps) {
gst_caps_unref (priv->caps);
priv->caps = NULL;
}
if (priv->notify) {
priv->notify (priv->user_data);
}
priv->user_data = NULL;
priv->notify = NULL;
GST_OBJECT_UNLOCK (appsink);
g_mutex_lock (&priv->mutex);
while ((queue_obj = g_queue_pop_head (priv->queue)))
gst_mini_object_unref (queue_obj);
gst_buffer_replace (&priv->preroll, NULL);
gst_caps_replace (&priv->preroll_caps, NULL);
gst_caps_replace (&priv->last_caps, NULL);
g_mutex_unlock (&priv->mutex);
G_OBJECT_CLASS (parent_class)->dispose (obj);
}
static void
gst_gl_buffer_pool_finalize (GObject * object)
{
GstGLBufferPool *pool = GST_GL_BUFFER_POOL_CAST (object);
GstGLBufferPoolPrivate *priv = pool->priv;
GST_LOG_OBJECT (pool, "finalize GL buffer pool %p", pool);
gst_buffer_replace (&pool->priv->last_buffer, NULL);
if (priv->caps)
gst_caps_unref (priv->caps);
if (pool->upload)
gst_object_unref (pool->upload);
G_OBJECT_CLASS (gst_gl_buffer_pool_parent_class)->finalize (object);
/* only release the context once all our memory have been deleted */
if (pool->context) {
gst_object_unref (pool->context);
pool->context = NULL;
}
if (priv->allocator) {
gst_object_unref (priv->allocator);
priv->allocator = NULL;
}
}
static GstFlowReturn
gst_app_sink_preroll (GstBaseSink * psink, GstBuffer * buffer)
{
GstFlowReturn res = GST_FLOW_OK;
GstAppSink *appsink = GST_APP_SINK (psink);
gboolean emit;
g_mutex_lock (appsink->priv->mutex);
if (appsink->priv->flushing)
goto flushing;
GST_DEBUG_OBJECT (appsink, "setting preroll buffer %p", buffer);
gst_buffer_replace (&appsink->priv->preroll, buffer);
g_cond_signal (appsink->priv->cond);
emit = appsink->priv->emit_signals;
g_mutex_unlock (appsink->priv->mutex);
if (appsink->priv->callbacks.new_preroll)
res =
appsink->priv->callbacks.new_preroll (appsink,
appsink->priv->user_data);
else if (emit)
g_signal_emit (appsink, gst_app_sink_signals[SIGNAL_NEW_PREROLL], 0);
return res;
flushing:
{
GST_DEBUG_OBJECT (appsink, "we are flushing");
g_mutex_unlock (appsink->priv->mutex);
return GST_FLOW_WRONG_STATE;
}
}
static gboolean
gst_omx_audio_dec_stop (GstAudioDecoder * decoder)
{
GstOMXAudioDec *self;
self = GST_OMX_AUDIO_DEC (decoder);
GST_DEBUG_OBJECT (self, "Stopping decoder");
gst_omx_port_set_flushing (self->dec_in_port, 5 * GST_SECOND, TRUE);
gst_omx_port_set_flushing (self->dec_out_port, 5 * GST_SECOND, TRUE);
gst_pad_stop_task (GST_AUDIO_DECODER_SRC_PAD (decoder));
if (gst_omx_component_get_state (self->dec, 0) > OMX_StateIdle)
gst_omx_component_set_state (self->dec, OMX_StateIdle);
self->downstream_flow_ret = GST_FLOW_FLUSHING;
self->started = FALSE;
g_mutex_lock (&self->drain_lock);
self->draining = FALSE;
g_cond_broadcast (&self->drain_cond);
g_mutex_unlock (&self->drain_lock);
gst_omx_component_get_state (self->dec, 5 * GST_SECOND);
gst_buffer_replace (&self->codec_data, NULL);
GST_DEBUG_OBJECT (self, "Stopped decoder");
return TRUE;
}
static GstFlowReturn
gst_mpeg2dec_alloc_sized_buf (GstMpeg2dec * mpeg2dec, guint size,
GstVideoCodecFrame * frame, GstBuffer ** buffer)
{
GstFlowReturn ret = GST_FLOW_OK;
GstVideoCodecState *state;
state = gst_video_decoder_get_output_state (GST_VIDEO_DECODER (mpeg2dec));
if (!mpeg2dec->need_cropping || mpeg2dec->has_cropping) {
/* need parsed input, but that might be slightly bogus,
* so avoid giving up altogether and mark it as error */
if (frame->output_buffer) {
gst_buffer_replace (&frame->output_buffer, NULL);
GST_VIDEO_DECODER_ERROR (mpeg2dec, 1, STREAM, DECODE,
("decoding error"), ("Input not correctly parsed"), ret);
}
ret =
gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER (mpeg2dec),
frame);
*buffer = frame->output_buffer;
} else {
GstAllocationParams params = { 0, 15, 0, 0 };
*buffer = gst_buffer_new_allocate (NULL, size, ¶ms);
gst_video_codec_frame_set_user_data (frame, *buffer,
(GDestroyNotify) frame_user_data_destroy_notify);
}
gst_video_codec_state_unref (state);
return ret;
}
static void
gst_opus_dec_reset (GstOpusDec * dec)
{
dec->packetno = 0;
if (dec->state) {
opus_multistream_decoder_destroy (dec->state);
dec->state = NULL;
}
gst_buffer_replace (&dec->streamheader, NULL);
gst_buffer_replace (&dec->vorbiscomment, NULL);
gst_buffer_replace (&dec->last_buffer, NULL);
dec->primed = FALSE;
dec->pre_skip = 0;
dec->r128_gain = 0;
}
/**
* gst_gl_buffer_pool_replace_last_buffer:
* @pool: a #GstGLBufferPool
* @buffer: a #GstBuffer
*
* Set @pool<-- -->s last buffer to @buffer for #GstGLPlatform<-- -->s that
* require it.
*/
void
gst_gl_buffer_pool_replace_last_buffer (GstGLBufferPool * pool,
GstBuffer * buffer)
{
g_return_if_fail (pool != NULL);
g_return_if_fail (buffer != NULL);
gst_buffer_replace (&pool->priv->last_buffer, buffer);
}
static void
reset(GstDspBase *base)
{
GstDspVEnc *self = GST_DSP_VENC(base);
pr_debug(self, "venc reset");
/* some cleanup */
if (base->alg == GSTDSP_H264ENC) {
self->priv.h264.codec_data_done = FALSE;
self->priv.h264.sps_received = FALSE;
self->priv.h264.pps_received = FALSE;
gst_buffer_replace(&self->priv.h264.sps, NULL);
gst_buffer_replace(&self->priv.h264.pps, NULL);
gst_buffer_replace(&self->priv.h264.codec_data, NULL);
} else
self->priv.mpeg4.codec_data_done = FALSE;
}
static void
gst_audio_aggregator_pad_finalize (GObject * object)
{
GstAudioAggregatorPad *pad = (GstAudioAggregatorPad *) object;
gst_buffer_replace (&pad->priv->buffer, NULL);
G_OBJECT_CLASS (gst_audio_aggregator_pad_parent_class)->finalize (object);
}
/* With SPU LOCK */
static void
gst_dvd_spu_redraw_still (GstDVDSpu * dvdspu, gboolean force)
{
/* If we have an active SPU command set and a reference frame, copy the
* frame, redraw the SPU and store it as the pending frame for output */
if (dvdspu->ref_frame) {
gboolean redraw = (dvdspu->spu_state.flags & SPU_STATE_FORCED_DSP);
redraw |= (dvdspu->spu_state.flags & SPU_STATE_FORCED_ONLY) == 0 &&
(dvdspu->spu_state.flags & SPU_STATE_DISPLAY);
if (redraw) {
GstBuffer *buf = gst_buffer_ref (dvdspu->ref_frame);
buf = gst_buffer_make_writable (buf);
GST_LOG_OBJECT (dvdspu, "Redraw due to Still Frame with ref %p",
dvdspu->ref_frame);
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
/* Render the SPU overlay onto the buffer */
gstspu_render (dvdspu, buf);
gst_buffer_replace (&dvdspu->pending_frame, buf);
gst_buffer_unref (buf);
} else if (force) {
/* Simply output the reference frame */
GstBuffer *buf = gst_buffer_ref (dvdspu->ref_frame);
buf = gst_buffer_make_writable (buf);
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
GST_DEBUG_OBJECT (dvdspu, "Pushing reference frame at start of still");
gst_buffer_replace (&dvdspu->pending_frame, buf);
gst_buffer_unref (buf);
} else {
GST_LOG_OBJECT (dvdspu, "Redraw due to Still Frame skipped");
}
} else {
GST_LOG_OBJECT (dvdspu, "Not redrawing still frame - no ref frame");
}
}
static void
gst_libde265_dec_release_frame_ref (struct GstLibde265FrameRef *ref)
{
if (ref->mapped) {
gst_video_frame_unmap (&ref->vframe);
}
gst_video_codec_frame_unref (ref->frame);
gst_buffer_replace (&ref->buffer, NULL);
g_free (ref);
}
