void test_no_lock()
{
GstTask *t;
gboolean ret;
//xmlfile = "test_no_lock";
std_log(LOG_FILENAME_LINE, "Test Started test_no_lock");
t = gst_task_create (task_func, NULL);
fail_if (t == NULL);
TEST_ASSERT_FAIL
/* stop should be possible without lock */
gst_task_stop (t);
/* pause should give a warning */
ASSERT_WARNING (ret = gst_task_pause (t)); //b failing
fail_unless (ret == FALSE);
TEST_ASSERT_FAIL
/* start should give a warning */
ASSERT_WARNING (ret = gst_task_start (t));
fail_unless (ret == FALSE);
TEST_ASSERT_FAIL
/* stop should be possible without lock */
gst_task_stop (t);
gst_object_unref (t);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static void
gst_hls_demux_stop (GstHLSDemux * demux)
{
gst_uri_downloader_cancel (demux->downloader);
if (GST_TASK_STATE (demux->updates_task) != GST_TASK_STOPPED) {
demux->stop_stream_task = TRUE;
gst_task_stop (demux->updates_task);
GST_TASK_SIGNAL (demux->updates_task);
}
if (GST_TASK_STATE (demux->stream_task) != GST_TASK_STOPPED)
gst_task_stop (demux->stream_task);
}
static gboolean
gst_decklink_src_stop (GstElement * element)
{
GstDecklinkSrc *decklinksrc = GST_DECKLINK_SRC (element);
gst_task_stop (decklinksrc->task);
g_mutex_lock (&decklinksrc->mutex);
decklinksrc->stop = TRUE;
g_cond_signal (&decklinksrc->cond);
g_mutex_unlock (&decklinksrc->mutex);
gst_task_join (decklinksrc->task);
decklinksrc->input->StopStreams ();
decklinksrc->input->DisableVideoInput ();
decklinksrc->input->DisableAudioInput ();
g_list_free_full (decklinksrc->pending_events,
(GDestroyNotify) gst_mini_object_unref);
decklinksrc->pending_events = NULL;
decklinksrc->have_events = FALSE;
decklinksrc->pending_eos = FALSE;
return TRUE;
}
static gboolean
gst_decklink_src_stop (GstElement * element)
{
GstDecklinkSrc *decklinksrc = GST_DECKLINK_SRC (element);
gst_task_stop (decklinksrc->task);
g_mutex_lock (decklinksrc->mutex);
decklinksrc->stop = TRUE;
g_cond_signal (decklinksrc->cond);
g_mutex_unlock (decklinksrc->mutex);
gst_task_join (decklinksrc->task);
decklinksrc->input->StopStreams ();
decklinksrc->input->DisableVideoInput ();
decklinksrc->input->DisableAudioInput ();
decklinksrc->input->Release ();
decklinksrc->input = NULL;
decklinksrc->decklink->Release ();
decklinksrc->decklink = NULL;
return TRUE;
}
static void
dvb_base_bin_task (DvbBaseBin * basebin)
{
gint pollres;
GST_DEBUG_OBJECT (basebin, "In task");
/* If we haven't tried to open the cam, try now */
if (G_UNLIKELY (basebin->trycam))
dvb_base_bin_init_cam (basebin);
/* poll with timeout */
pollres = gst_poll_wait (basebin->poll, GST_SECOND / 4);
if (G_UNLIKELY (pollres == -1)) {
gst_task_stop (basebin->task);
return;
}
if (basebin->hwcam) {
cam_device_poll (basebin->hwcam);
if (basebin->pmtlist_changed) {
if (cam_device_ready (basebin->hwcam)) {
GST_DEBUG_OBJECT (basebin, "pmt list changed");
dvb_base_bin_reset_pmtlist (basebin);
} else {
GST_DEBUG_OBJECT (basebin, "pmt list changed but CAM not ready");
}
}
}
}
static void
gst_hls_demux_dispose (GObject * obj)
{
GstHLSDemux *demux = GST_HLS_DEMUX (obj);
g_cond_free (demux->fetcher_cond);
g_mutex_free (demux->fetcher_lock);
g_cond_free (demux->thread_cond);
g_mutex_free (demux->thread_lock);
if (GST_TASK_STATE (demux->task) != GST_TASK_STOPPED) {
gst_task_stop (demux->task);
gst_task_join (demux->task);
}
gst_object_unref (demux->task);
g_static_rec_mutex_free (&demux->task_lock);
gst_object_unref (demux->fetcher_bus);
gst_object_unref (demux->fetcherpad);
gst_hls_demux_reset (demux, TRUE);
gst_object_unref (demux->download);
G_OBJECT_CLASS (parent_class)->dispose (obj);
}
static void
gst_hls_demux_stop (GstHLSDemux * demux)
{
gst_hls_demux_stop_fetcher (demux, TRUE);
if (GST_TASK_STATE (demux->task) != GST_TASK_STOPPED)
gst_task_stop (demux->task);
g_cond_signal (demux->thread_cond);
}
static void
gst_hls_demux_stop (GstHLSDemux * demux)
{
g_mutex_lock (demux->fetcher_lock);
gst_hls_demux_stop_fetcher_locked (demux, TRUE);
g_mutex_unlock (demux->fetcher_lock);
gst_task_stop (demux->task);
gst_hls_demux_stop_update (demux);
}
void
sefctrler_finalize (GObject * object)
{
SndEventBasedController *this = SEFCTRLER (object);
g_hash_table_destroy (this->subflows);
gst_task_stop (this->thread);
gst_task_join (this->thread);
g_object_unref (this->sysclock);
}
static void
gst_hls_demux_dispose (GObject * obj)
{
GstHLSDemux *demux = GST_HLS_DEMUX (obj);
if (demux->stream_task) {
if (GST_TASK_STATE (demux->stream_task) != GST_TASK_STOPPED) {
GST_DEBUG_OBJECT (demux, "Leaving streaming task");
gst_task_stop (demux->stream_task);
gst_task_join (demux->stream_task);
}
gst_object_unref (demux->stream_task);
g_rec_mutex_clear (&demux->stream_lock);
demux->stream_task = NULL;
}
if (demux->updates_task) {
if (GST_TASK_STATE (demux->updates_task) != GST_TASK_STOPPED) {
GST_DEBUG_OBJECT (demux, "Leaving updates task");
gst_task_stop (demux->updates_task);
gst_task_join (demux->updates_task);
}
gst_object_unref (demux->updates_task);
g_mutex_clear (&demux->updates_timed_lock);
g_rec_mutex_clear (&demux->updates_lock);
demux->updates_task = NULL;
}
if (demux->downloader != NULL) {
g_object_unref (demux->downloader);
demux->downloader = NULL;
}
gst_hls_demux_reset (demux, TRUE);
g_queue_free (demux->queue);
G_OBJECT_CLASS (parent_class)->dispose (obj);
}
static void
stop_eos_task (GstAmlVdec *amlvdec)
{
if (! amlvdec->eos_task)
return;
gst_task_stop (amlvdec->eos_task);
g_rec_mutex_lock (&amlvdec->eos_lock);
g_rec_mutex_unlock (&amlvdec->eos_lock);
gst_task_join (amlvdec->eos_task);
gst_object_unref (amlvdec->eos_task);
amlvdec->eos_task = NULL;
}
static void
gst_swfdec_dispose (GObject * object)
{
GstSwfdec *swfdec = GST_SWFDEC (object);
gst_task_stop (swfdec->task);
gst_task_join (swfdec->task);
gst_object_unref (swfdec->task);
g_static_rec_mutex_free (&swfdec->mutex);
g_object_unref (swfdec->adapter);
swfdec_decoder_free (swfdec->decoder);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static GstStateChangeReturn
dvb_base_bin_change_state (GstElement * element, GstStateChange transition)
{
DvbBaseBin *dvbbasebin;
GstStateChangeReturn ret;
dvbbasebin = GST_DVB_BASE_BIN (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
if (dvbbasebin->tsparse == NULL) {
GST_ELEMENT_ERROR (dvbbasebin, CORE, MISSING_PLUGIN, (NULL),
("No 'tsparse' element, check your GStreamer installation."));
return GST_STATE_CHANGE_FAILURE;
}
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_poll_set_flushing (dvbbasebin->poll, FALSE);
g_rec_mutex_lock (&dvbbasebin->lock);
gst_task_start (dvbbasebin->task);
g_rec_mutex_unlock (&dvbbasebin->lock);
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_poll_set_flushing (dvbbasebin->poll, TRUE);
g_rec_mutex_lock (&dvbbasebin->lock);
gst_task_stop (dvbbasebin->task);
g_rec_mutex_unlock (&dvbbasebin->lock);
dvb_base_bin_reset (dvbbasebin);
break;
default:
break;
}
return ret;
}
static GstStateChangeReturn
gst_qt_moov_recover_change_state (GstElement * element,
GstStateChange transition)
{
GstStateChangeReturn ret;
GstQTMoovRecover *qtmr = GST_QT_MOOV_RECOVER_CAST (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
qtmr->task = gst_task_create (gst_qt_moov_recover_run, qtmr);
qtmr->task_mutex = g_new (GStaticRecMutex, 1);
g_static_rec_mutex_init (qtmr->task_mutex);
gst_task_set_lock (qtmr->task, qtmr->task_mutex);
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
gst_task_start (qtmr->task);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
gst_task_stop (qtmr->task);
gst_task_join (qtmr->task);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
g_assert (gst_task_get_state (qtmr->task) == GST_TASK_STOPPED);
gst_object_unref (qtmr->task);
qtmr->task = NULL;
g_static_rec_mutex_free (qtmr->task_mutex);
break;
default:
break;
}
return ret;
}
static GstStateChangeReturn
gst_hls_demux_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
GstHLSDemux *demux = GST_HLS_DEMUX (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_hls_demux_reset (demux, FALSE);
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
/* Start the streaming loop in paused only if we already received
the main playlist. It might have been stopped if we were in PAUSED
state and we filled our queue with enough cached fragments
*/
if (gst_m3u8_client_get_uri (demux->client)[0] != '\0')
gst_task_start (demux->updates_task);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
gst_task_stop (demux->updates_task);
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
demux->cancelled = TRUE;
gst_hls_demux_stop (demux);
gst_task_join (demux->stream_task);
gst_hls_demux_reset (demux, FALSE);
break;
default:
break;
}
return ret;
}
static void
gst_swfdec_render (GstSwfdec * swfdec, int ret)
{
if (ret == SWF_EOF) {
SwfdecBuffer *audio_buffer;
SwfdecBuffer *video_buffer;
GstBuffer *videobuf;
GstBuffer *audiobuf;
gboolean ret;
GstFlowReturn res;
const char *url;
GST_DEBUG_OBJECT (swfdec, "render:SWF_EOF");
swfdec_decoder_set_mouse (swfdec->decoder, swfdec->x, swfdec->y,
swfdec->button);
ret = swfdec_render_iterate (swfdec->decoder);
if (swfdec->decoder->using_experimental) {
GST_ELEMENT_ERROR (swfdec, LIBRARY, FAILED,
("SWF file contains features known to trigger bugs."),
("SWF file contains features known to trigger bugs."));
gst_task_stop (swfdec->task);
}
if (!ret) {
gst_task_stop (swfdec->task);
res = gst_pad_push_event (swfdec->videopad, gst_event_new_eos ());
res = gst_pad_push_event (swfdec->audiopad, gst_event_new_eos ());
return;
}
if (swfdec->send_discont) {
GstEvent *event;
swfdec->timestamp = swfdec_render_get_frame_index (swfdec->decoder) *
swfdec->interval;
GST_DEBUG ("sending discont %" G_GINT64_FORMAT, swfdec->timestamp);
event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME,
swfdec->timestamp, GST_CLOCK_TIME_NONE, 0);
gst_pad_push_event (swfdec->videopad, event);
event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME,
swfdec->timestamp, GST_CLOCK_TIME_NONE, 0);
gst_pad_push_event (swfdec->audiopad, event);
swfdec->send_discont = FALSE;
}
GST_DEBUG ("pushing image/sound %" G_GINT64_FORMAT, swfdec->timestamp);
if (swfdec->skip_index) {
video_buffer = NULL;
swfdec->skip_index--;
} else {
video_buffer = swfdec_render_get_image (swfdec->decoder);
if (!video_buffer) {
gst_task_stop (swfdec->task);
gst_pad_push_event (swfdec->videopad, gst_event_new_eos ());
gst_pad_push_event (swfdec->audiopad, gst_event_new_eos ());
return;
}
swfdec->skip_index = swfdec->skip_frames - 1;
videobuf = gst_swfdec_buffer_from_swf (video_buffer);
GST_BUFFER_TIMESTAMP (videobuf) = swfdec->timestamp;
gst_buffer_set_caps (videobuf, GST_PAD_CAPS (swfdec->videopad));
gst_pad_push (swfdec->videopad, videobuf);
}
audio_buffer = swfdec_render_get_audio (swfdec->decoder);
if (audio_buffer) {
audiobuf = gst_swfdec_buffer_from_swf (audio_buffer);
GST_BUFFER_TIMESTAMP (audiobuf) = swfdec->timestamp;
gst_buffer_set_caps (audiobuf, GST_PAD_CAPS (swfdec->audiopad));
gst_pad_push (swfdec->audiopad, audiobuf);
}
swfdec->timestamp += swfdec->interval;
url = swfdec_decoder_get_url (swfdec->decoder);
if (url) {
GstStructure *s;
GstMessage *msg;
s = gst_structure_new ("embedded-url", "url", G_TYPE_STRING, url,
"target", G_TYPE_STRING, "_self", NULL);
msg = gst_message_new_element (GST_OBJECT (swfdec), s);
gst_element_post_message (GST_ELEMENT (swfdec), msg);
}
}
}
static gboolean
gst_ss_demux_handle_src_event (GstPad * pad, GstEvent * event)
{
GstSSDemux *demux = GST_SS_DEMUX (gst_pad_get_parent (pad));
switch (event->type) {
case GST_EVENT_SEEK:
{
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
gint i = 0;
GstSSDemuxStream *stream = NULL;
GST_INFO_OBJECT (demux, "Received GST_EVENT_SEEK");
// TODO: should be able to seek in DVR window
if (GST_SSM_PARSE_IS_LIVE_PRESENTATION (demux->parser)) {
GST_WARNING_OBJECT (demux, "Received seek event for live stream");
return FALSE;
}
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
&stop_type, &stop);
if (format != GST_FORMAT_TIME) {
GST_WARNING_OBJECT (demux, "Only time format is supported in seek");
return FALSE;
}
GST_DEBUG_OBJECT (demux, "seek event, rate: %f start: %" GST_TIME_FORMAT
" stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start),
GST_TIME_ARGS (stop));
for( i = 0; i < SS_STREAM_NUM; i++) {
if (stream = demux->streams[i]) {
g_cond_signal (stream->cond);
gst_task_stop (stream->stream_task);
}
}
if (flags & GST_SEEK_FLAG_FLUSH) {
GST_INFO_OBJECT (demux, "sending flush start");
for( i = 0; i < SS_STREAM_NUM; i++) {
if (stream = demux->streams[i]) {
gst_pad_push_event (stream->pad, gst_event_new_flush_start ());
}
}
}
gst_ssm_parse_seek_manifest (demux->parser, start);
if (flags & GST_SEEK_FLAG_FLUSH) {
GST_INFO_OBJECT (demux, "sending flush stop");
for( i = 0; i < SS_STREAM_NUM; i++) {
if (stream = demux->streams[i]) {
gst_pad_push_event (stream->pad, gst_event_new_flush_stop ());
GST_LOG_OBJECT (stream->pad, "Starting pad TASK again...\n");
stream->sent_ns = FALSE;
stream->frag_cnt = 0; /*resetting to start buffering on SEEK */
gst_task_start (stream->stream_task);
}
}
}
return TRUE;
}
default:
break;
}
return gst_pad_event_default (pad, event);
}
static void
gst_qt_moov_recover_run (void *data)
{
FILE *moovrec = NULL;
FILE *mdatinput = NULL;
FILE *output = NULL;
MdatRecovFile *mdat_recov = NULL;
MoovRecovFile *moov_recov = NULL;
GstQTMoovRecover *qtmr = GST_QT_MOOV_RECOVER_CAST (data);
GError *err = NULL;
GST_LOG_OBJECT (qtmr, "Starting task");
GST_DEBUG_OBJECT (qtmr, "Validating properties");
GST_OBJECT_LOCK (qtmr);
/* validate properties */
if (qtmr->broken_input == NULL) {
GST_OBJECT_UNLOCK (qtmr);
GST_ELEMENT_ERROR (qtmr, RESOURCE, SETTINGS,
("Please set broken-input property"), (NULL));
goto end;
}
if (qtmr->recovery_input == NULL) {
GST_OBJECT_UNLOCK (qtmr);
GST_ELEMENT_ERROR (qtmr, RESOURCE, SETTINGS,
("Please set recovery-input property"), (NULL));
goto end;
}
if (qtmr->fixed_output == NULL) {
GST_OBJECT_UNLOCK (qtmr);
GST_ELEMENT_ERROR (qtmr, RESOURCE, SETTINGS,
("Please set fixed-output property"), (NULL));
goto end;
}
GST_DEBUG_OBJECT (qtmr, "Opening input/output files");
/* open files */
moovrec = g_fopen (qtmr->recovery_input, "rb");
if (moovrec == NULL) {
GST_OBJECT_UNLOCK (qtmr);
GST_ELEMENT_ERROR (qtmr, RESOURCE, OPEN_READ,
("Failed to open recovery-input file"), (NULL));
goto end;
}
mdatinput = g_fopen (qtmr->broken_input, "rb");
if (mdatinput == NULL) {
GST_OBJECT_UNLOCK (qtmr);
GST_ELEMENT_ERROR (qtmr, RESOURCE, OPEN_READ,
("Failed to open broken-input file"), (NULL));
goto end;
}
output = g_fopen (qtmr->fixed_output, "wb+");
if (output == NULL) {
GST_OBJECT_UNLOCK (qtmr);
GST_ELEMENT_ERROR (qtmr, RESOURCE, OPEN_READ_WRITE,
("Failed to open fixed-output file"), (NULL));
goto end;
}
GST_OBJECT_UNLOCK (qtmr);
GST_DEBUG_OBJECT (qtmr, "Parsing input files");
/* now create our structures */
mdat_recov = mdat_recov_file_create (mdatinput, qtmr->faststart_mode, &err);
mdatinput = NULL;
if (mdat_recov == NULL) {
GST_ELEMENT_ERROR (qtmr, RESOURCE, FAILED,
("Broken file could not be parsed correctly"), (NULL));
goto end;
}
moov_recov = moov_recov_file_create (moovrec, &err);
moovrec = NULL;
if (moov_recov == NULL) {
GST_ELEMENT_ERROR (qtmr, RESOURCE, FAILED,
("Recovery file could not be parsed correctly"), (NULL));
goto end;
}
/* now parse the buffers data from moovrec */
if (!moov_recov_parse_buffers (moov_recov, mdat_recov, &err)) {
goto end;
}
GST_DEBUG_OBJECT (qtmr, "Writing fixed file to output");
if (!moov_recov_write_file (moov_recov, mdat_recov, output, &err)) {
goto end;
}
/* here means success */
GST_DEBUG_OBJECT (qtmr, "Finished successfully, posting EOS");
gst_element_post_message (GST_ELEMENT_CAST (qtmr),
gst_message_new_eos (GST_OBJECT_CAST (qtmr)));
end:
GST_LOG_OBJECT (qtmr, "Finalizing task");
if (err) {
GST_ELEMENT_ERROR (qtmr, RESOURCE, FAILED, ("%s", err->message), (NULL));
g_error_free (err);
}
if (moov_recov)
moov_recov_file_free (moov_recov);
if (moovrec)
fclose (moovrec);
if (mdat_recov)
mdat_recov_file_free (mdat_recov);
if (mdatinput)
fclose (mdatinput);
if (output)
fclose (output);
GST_LOG_OBJECT (qtmr, "Leaving task");
gst_task_stop (qtmr->task);
}
static GstStateChangeReturn
gst_merger_change_state (GstElement * element, GstStateChange transition)
{
GstMerger *merger = GST_MERGER (element);
GstStateChangeReturn ret;
GST_INFO_OBJECT (merger, "Transition %d", transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
{
bool res;
GST_INFO_OBJECT (merger, "Stoping Task");
merger->stop = 1;
g_cond_signal (&merger->task_cond);
GST_INFO_OBJECT (merger, "Stoping Task.");
res = gst_task_stop (merger->task);
GST_INFO_OBJECT (merger, "Stoping Task.. %d", res);
GST_INFO_OBJECT (merger, "Task state %d", merger->task->state);
res = gst_task_join (merger->task);
GST_INFO_OBJECT (merger, "Stoping Task... %d", res);
}
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
{
bool res;
GST_INFO_OBJECT (merger, "Starting Task");
merger->stop = 0;
res = gst_task_start (merger->task);
GST_INFO_OBJECT (merger, "Starting Task. %d", res);
}
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_segment_init (&merger->s_segment, GST_FORMAT_UNDEFINED);
g_queue_init (&merger->bufs_l);
g_queue_init (&merger->bufs_r);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:{
GstBuffer *buf;
while ((buf = g_queue_pop_head (&merger->bufs_l)))
gst_buffer_unref (buf);
while ((buf = g_queue_pop_head (&merger->bufs_r)))
gst_buffer_unref (buf);
break;
}
default:
break;
}
return ret;
}
static GstStateChangeReturn
gst_swfdec_change_state (GstElement * element, GstStateChange transition)
{
GstSwfdec *swfdec = GST_SWFDEC (element);
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
{
gst_adapter_clear (swfdec->adapter);
/*
gst_swfdec_vo_open (swfdec);
swfdec_decoder_new (swfdec->decoder, swfdec->accel, swfdec->vo);
swfdec->decoder->is_sequence_needed = 1;
swfdec->decoder->frame_rate_code = 0;
*/
swfdec->timestamp = 0;
swfdec->closed = FALSE;
/* reset the initial video state */
swfdec->have_format = FALSE;
swfdec->format = -1;
swfdec->width = -1;
swfdec->height = -1;
swfdec->first = TRUE;
break;
}
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
gst_task_start (swfdec->task);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
gst_task_pause (swfdec->task);
gst_task_join (swfdec->task);
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
/* if we are not closed by an EOS event do so now, this cen send a few frames but
* we are prepared to not really send them (see above) */
if (!swfdec->closed) {
/*swf_close (swfdec->decoder); */
swfdec->closed = TRUE;
}
/* gst_swfdec_vo_destroy (swfdec); */
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_task_stop (swfdec->task);
gst_task_join (swfdec->task);
break;
default:
break;
}
return ret;
}
static void
gst_ss_demux_stop (GstSSDemux * demux, GstSSDemuxStream *stream)
{
if (GST_TASK_STATE (stream->stream_task) != GST_TASK_STOPPED)
gst_task_stop (stream->stream_task);
}
static gboolean
gst_hls_demux_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstHLSDemux *demux;
demux = GST_HLS_DEMUX (parent);
switch (event->type) {
case GST_EVENT_SEEK:
{
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
GList *walk;
GstClockTime position, current_pos, target_pos;
gint current_sequence;
GstM3U8MediaFile *file;
GST_INFO_OBJECT (demux, "Received GST_EVENT_SEEK");
if (gst_m3u8_client_is_live (demux->client)) {
GST_WARNING_OBJECT (demux, "Received seek event for live stream");
return FALSE;
}
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
&stop_type, &stop);
if (format != GST_FORMAT_TIME)
return FALSE;
GST_DEBUG_OBJECT (demux, "seek event, rate: %f start: %" GST_TIME_FORMAT
" stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start),
GST_TIME_ARGS (stop));
GST_M3U8_CLIENT_LOCK (demux->client);
file = GST_M3U8_MEDIA_FILE (demux->client->current->files->data);
current_sequence = file->sequence;
current_pos = 0;
target_pos = (GstClockTime) start;
for (walk = demux->client->current->files; walk; walk = walk->next) {
file = walk->data;
current_sequence = file->sequence;
if (current_pos <= target_pos
&& target_pos < current_pos + file->duration) {
break;
}
current_pos += file->duration;
}
GST_M3U8_CLIENT_UNLOCK (demux->client);
if (walk == NULL) {
GST_WARNING_OBJECT (demux, "Could not find seeked fragment");
return FALSE;
}
if (flags & GST_SEEK_FLAG_FLUSH) {
GST_DEBUG_OBJECT (demux, "sending flush start");
gst_pad_push_event (demux->srcpad, gst_event_new_flush_start ());
}
demux->cancelled = TRUE;
gst_task_pause (demux->stream_task);
gst_uri_downloader_cancel (demux->downloader);
gst_task_stop (demux->updates_task);
gst_task_pause (demux->stream_task);
/* wait for streaming to finish */
g_rec_mutex_lock (&demux->stream_lock);
demux->need_cache = TRUE;
while (!g_queue_is_empty (demux->queue)) {
GstFragment *fragment = g_queue_pop_head (demux->queue);
g_object_unref (fragment);
}
g_queue_clear (demux->queue);
GST_M3U8_CLIENT_LOCK (demux->client);
GST_DEBUG_OBJECT (demux, "seeking to sequence %d", current_sequence);
demux->client->sequence = current_sequence;
gst_m3u8_client_get_current_position (demux->client, &position);
demux->position_shift = start - position;
demux->need_segment = TRUE;
GST_M3U8_CLIENT_UNLOCK (demux->client);
if (flags & GST_SEEK_FLAG_FLUSH) {
GST_DEBUG_OBJECT (demux, "sending flush stop");
gst_pad_push_event (demux->srcpad, gst_event_new_flush_stop (TRUE));
}
demux->cancelled = FALSE;
gst_task_start (demux->stream_task);
g_rec_mutex_unlock (&demux->stream_lock);
return TRUE;
}
default:
break;
}
return gst_pad_event_default (pad, parent, event);
}
