bool GStreamerWrapper::seekFrame( gint64 iTargetTimeInNs )
{
GstFormat gstFormat = GST_FORMAT_TIME;
// The flags determine how the seek behaves, in this case we simply want to jump to certain part in stream
// while keeping the pre-set speed and play direction
GstSeekFlags gstSeekFlags = ( GstSeekFlags ) ( GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH );
bool bIsSeekSuccessful = false;
if ( m_PlayDirection == FORWARD )
{
bIsSeekSuccessful = gst_element_seek( GST_ELEMENT( m_GstPipeline ),
m_fSpeed,
gstFormat,
gstSeekFlags,
GST_SEEK_TYPE_SET,
iTargetTimeInNs,
GST_SEEK_TYPE_SET,
m_iDurationInNs );
}
else if ( m_PlayDirection == BACKWARD )
{
bIsSeekSuccessful = gst_element_seek( GST_ELEMENT( m_GstPipeline ),
-m_fSpeed,
gstFormat,
gstSeekFlags,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_SET,
iTargetTimeInNs );
}
return bIsSeekSuccessful;
}
bool GStreamerWrapper::changeSpeedAndDirection( float fSpeed, PlayDirection direction )
{
GstFormat gstFormat = GST_FORMAT_TIME;
// The flags determine how the seek behaves, in this case we stay at the current position in the stream but simply
// want to change either speed, play direction or both
GstSeekFlags gstSeekFlags = (GstSeekFlags)( GST_SEEK_FLAG_SKIP | GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH );
bool bIsSeekSuccessful = false;
if ( direction == FORWARD )
{
bIsSeekSuccessful = gst_element_seek( GST_ELEMENT( m_GstPipeline ),
fSpeed,
gstFormat,
gstSeekFlags,
GST_SEEK_TYPE_SET,
getCurrentTimeInNs(),
GST_SEEK_TYPE_SET,
m_iDurationInNs );
}
else if ( direction == BACKWARD )
{
bIsSeekSuccessful = gst_element_seek( GST_ELEMENT( m_GstPipeline ),
-fSpeed,
gstFormat,
gstSeekFlags,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_SET,
getCurrentTimeInNs() );
}
return bIsSeekSuccessful;
}
RESULT eServiceMP3::trickSeek(gdouble ratio)
{
m_currentTrickRatio = ratio;
if (!m_gst_playbin)
return -1;
if (ratio > -0.01 && ratio < 0.01)
{
gst_element_set_state(m_gst_playbin, GST_STATE_PAUSED);
return 0;
}
gint64 pos;
pts_t pts;
getPlayPosition(pts);
pos = pts * 11111LL;
gst_element_set_state(m_gst_playbin, GST_STATE_PLAYING);
if (ratio >= 0.0)
{
gst_element_seek(m_gst_playbin, ratio, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP), GST_SEEK_TYPE_SET, pos, GST_SEEK_TYPE_SET, -1);
}
else
{
/* note that most elements will not support negative speed */
gst_element_seek(m_gst_playbin, ratio, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP), GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_SET, pos);
}
m_subtitle_pages.clear();
m_prev_decoder_time = -1;
m_decoder_time_valid_state = 0;
return 0;
}
void ofGstUtils::setPosition(float pct){
//pct = CLAMP(pct, 0,1);// check between 0 and 1;
GstFormat format = GST_FORMAT_TIME;
GstSeekFlags flags = (GstSeekFlags) (GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE);
gint64 pos = (guint64)((double)pct*(double)durationNanos);
/*if(bPaused){
seek_lock();
gst_element_set_state (gstPipeline, GST_STATE_PLAYING);
posChangingPaused=true;
seek_unlock();
}*/
if(speed>0){
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
pos,
GST_SEEK_TYPE_SET,
-1)) {
ofLog(OF_LOG_WARNING,"GStreamer: unable to seek");
}
}else{
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_SET,
pos)) {
ofLog(OF_LOG_WARNING,"GStreamer: unable to seek");
}
}
}
void ofGstUtils::setSpeed(float _speed){
GstFormat format = GST_FORMAT_TIME;
GstSeekFlags flags = (GstSeekFlags) (GST_SEEK_FLAG_SKIP | GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH);
gint64 pos;
if(_speed==0){
gst_element_set_state (gstPipeline, GST_STATE_PAUSED);
return;
}
#if GST_VERSION_MAJOR==0
if(!gst_element_query_position(GST_ELEMENT(gstPipeline),&format,&pos) || pos<0){
//ofLog(OF_LOG_ERROR,"GStreamer: cannot query position");
return;
}
#else
if(!gst_element_query_position(GST_ELEMENT(gstPipeline),format,&pos) || pos<0){
//ofLog(OF_LOG_ERROR,"GStreamer: cannot query position");
return;
}
#endif
speed = _speed;
//pos = (float)gstData.lastFrame * (float)fps_d / (float)fps_n * GST_SECOND;
if(!bPaused)
gst_element_set_state (gstPipeline, GST_STATE_PLAYING);
if(speed>0){
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
pos,
GST_SEEK_TYPE_SET,
-1)) {
gLogManager.log("GStreamer: unable to change speed",ELL_WARNING);
}
}else{
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_SET,
pos)) {
gLogManager.log("GStreamer: unable to change speed",ELL_WARNING);
}
}
gLogManager.log("Gstreamer: speed change to "+core::StringConverter::toString(speed),ELL_INFO);
}
void ofGstUtils::setSpeed(float _speed){
GstFormat format = GST_FORMAT_TIME;
GstSeekFlags flags = (GstSeekFlags) (GST_SEEK_FLAG_SKIP | GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH);
gint64 pos;
if(_speed==0){
gst_element_set_state (gstPipeline, GST_STATE_PAUSED);
return;
}
#if GST_VERSION_MAJOR==0
if(!gst_element_query_position(GST_ELEMENT(gstPipeline),&format,&pos) || pos<0){
//ofLogError("ofGstUtils") << "setSpeed(): couldn't query position";
return;
}
#else
if(!gst_element_query_position(GST_ELEMENT(gstPipeline),format,&pos) || pos<0){
//ofLogError("ofGstUtils") << "setSpeed(): couldn't query position";
return;
}
#endif
speed = _speed;
//pos = (float)gstData.lastFrame * (float)fps_d / (float)fps_n * GST_SECOND;
if(!bPaused)
gst_element_set_state (gstPipeline, GST_STATE_PLAYING);
if(speed>0){
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
pos,
GST_SEEK_TYPE_SET,
-1)) {
ofLogWarning("ofGstUtils") << "setSpeed(): unable to change speed";
}
}else{
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_SET,
pos)) {
ofLogWarning("ofGstUtils") << "setSpeed(): unable to change speed";
}
}
ofLogVerbose("ofGstUtils") << "setSpeed(): speed changed to " << speed;
}
bool GstPipe::speed(gdouble speed) {
g_debug("GstPipeliner::speed %f", speed);
speed_ = speed;
GstQuery *query;
gboolean res;
// query position
query = gst_query_new_position(GST_FORMAT_TIME);
res = gst_element_query(pipeline_, query);
gint64 cur_pos = 0;
if (res) {
gst_query_parse_position(query, nullptr, &cur_pos);
g_debug("cur pos = %" GST_TIME_FORMAT "\n", GST_TIME_ARGS(cur_pos));
} else {
g_warning("position query failed...");
}
gst_query_unref(query);
gboolean ret;
ret = gst_element_seek(pipeline_,
speed,
GST_FORMAT_TIME,
(GstSeekFlags) (GST_SEEK_FLAG_FLUSH |
GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET,
cur_pos, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
if (!ret)
g_debug("speed not handled\n");
return true;
}
/* 'pos' parameter is in milliseconds. */
int video_seek(int pos, int flags)
{
gint64 len, cur;
GstFormat fmt = GST_FORMAT_TIME;
GstElement *sink = get_sink();
if (!sink) return VIDEO_ERROR;
if (!(gst_element_query(sink, GST_QUERY_POSITION, &fmt, &cur) &&
gst_element_query(sink, GST_QUERY_TOTAL, &fmt, &len)))
return VIDEO_ERROR;
if (flags & VIDEO_SEEK_RELATIVE)
cur += pos * GST_SECOND;
else
cur = pos * GST_SECOND;
if (cur >= len) return video_stop();
if (cur <= 0) cur = 0;
if (!gst_element_seek(
sink,
GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH | GST_FORMAT_TIME,
cur))
return VIDEO_ERROR;
return VIDEO_OK;
}
bool GstVideoPlayerBackend::setSpeed(double speed)
{
if (!m_pipeline)
return false;
if (speed == m_playbackSpeed)
return true;
if (speed == 0)
return false;
gboolean re = gst_element_seek(m_pipeline, speed, GST_FORMAT_TIME,
GstSeekFlags(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP),
GST_SEEK_TYPE_SET, position(), GST_SEEK_TYPE_SET, GST_CLOCK_TIME_NONE);
if (!re)
{
qDebug() << "gstreamer: Setting playback speed failed";
emit nonFatalError(tr("Playback speed failed"));
}
else
{
m_playbackSpeed = speed;
m_lastspeed = speed;
qDebug() << "gstreamer: set playback speed to" << m_playbackSpeed;
emit playbackSpeedChanged(m_playbackSpeed);
}
return re ? true : false;
}
gboolean
gbp_player_seek (GbpPlayer *player, GstClockTime position, gdouble rate)
{
GstFormat format;
GstSeekFlags seek_flags;
guint64 start, stop;
g_return_val_if_fail (player != NULL, FALSE);
if (!player->priv->have_pipeline)
return FALSE;
format = GST_FORMAT_TIME;
seek_flags = GST_SEEK_FLAG_FLUSH;
if (rate > 0) {
start = position;
stop = -1;
} else {
start = -1;
stop = position;
}
return gst_element_seek (GST_ELEMENT (player->priv->pipeline), rate,
format, seek_flags, GST_SEEK_TYPE_SET, start, GST_SEEK_TYPE_SET, stop);
}
bool VideoPlayerBackend::seek(qint64 position)
{
if (!m_pipeline)
return false;
if (state() != Playing && state() != Paused)
{
qDebug() << "gstreamer: Stream is not playing or paused, ignoring seek";
return false;
}
gboolean re = gst_element_seek(m_pipeline, m_playbackSpeed, GST_FORMAT_TIME,
(GstSeekFlags)(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP |
GST_SEEK_FLAG_KEY_UNIT /* removing this will seek between
* keyframes, but is much slower */
),
GST_SEEK_TYPE_SET, position, GST_SEEK_TYPE_SET, GST_CLOCK_TIME_NONE);
if (!re)
{
qDebug() << "gstreamer: seek to position" << position << "failed";
emit nonFatalError(tr("Seeking failed"));
}
return re ? true : false;
}
/* Map the passed segment to 'internal' time from 0 to length of this piece and seek. Lock cannot be held */
static gboolean
gst_splitmux_part_reader_seek_to_segment (GstSplitMuxPartReader * reader,
GstSegment * target_seg)
{
GstSeekFlags flags;
GstClockTime start = 0, stop = GST_CLOCK_TIME_NONE;
flags = target_seg->flags | GST_SEEK_FLAG_FLUSH;
SPLITMUX_PART_LOCK (reader);
if (target_seg->start >= reader->start_offset)
start = target_seg->start - reader->start_offset;
/* If the segment stop is within this part, don't play to the end */
if (target_seg->stop != -1 &&
target_seg->stop < reader->start_offset + reader->duration)
stop = target_seg->stop - reader->start_offset;
SPLITMUX_PART_UNLOCK (reader);
GST_DEBUG_OBJECT (reader,
"Seeking rate %f format %d flags 0x%x start %" GST_TIME_FORMAT " stop %"
GST_TIME_FORMAT, target_seg->rate, target_seg->format, flags,
GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
return gst_element_seek (GST_ELEMENT_CAST (reader), target_seg->rate,
target_seg->format, flags, GST_SEEK_TYPE_SET, start, GST_SEEK_TYPE_SET,
stop);
}
static void
rb_audiocd_plugin_reuse_stream_cb (RBPlayer *player,
const char *new_uri,
const char *stream_uri,
GstElement *element,
RBAudioCdPlugin *plugin)
{
GstFormat track_format = gst_format_get_by_nick ("track");
char *track_str;
char *new_device;
guint track;
guint cdda_len;
/* get the new track number */
cdda_len = strlen ("cdda://");
new_device = g_utf8_strrchr (new_uri, -1, '#');
track_str = g_strndup (new_uri + cdda_len, new_device - (new_uri + cdda_len));
track = atoi (track_str);
g_free (track_str);
rb_debug ("seeking to track %d on CD device %s", track, new_device+1);
gst_element_seek (element,
1.0, track_format, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, track-1,
GST_SEEK_TYPE_NONE, -1);
}
bool cPlayback::SetPosition(int position, bool absolute)
{
if(playing == false)
return false;
#if defined (ENABLE_LIBEPLAYER3)
float pos = (position/1000.0);
if(player && player->playback)
player->playback->Command(player, PLAYBACK_SEEK, (void*)&pos);
#endif
#if defined (ENABLE_GSTREAMER)
gint64 time_nanoseconds;
gint64 pos;
GstFormat fmt = GST_FORMAT_TIME;
if(m_gst_playbin)
{
gst_element_query_position(m_gst_playbin, &fmt, &pos);
time_nanoseconds = pos + (position * 1000000000);
if(time_nanoseconds < 0) time_nanoseconds = 0;
gst_element_seek(m_gst_playbin, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, time_nanoseconds, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
}
#endif
return true;
}
//-------------------------------------------------------------------------------
// Name: GSTFastRewind
// Arguments: value (speed)
// Description: fast Rewind
// usage: object->GSTFastRewind(2);
//FIXME: not working
//-------------------------------------------------------------------------------
void GSTVideoControl::GSTFastRewind(float value)
{
gint64 x;
if (__bin)
{
x = GSTQueryPosition();
GSTPause ();
gst_element_seek ( __pipeline,
-value,
GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, x,
GST_SEEK_TYPE_NONE,
GST_CLOCK_TIME_NONE
);
GSTPlay ();
}
else
{
printf ("\nError: no BIN created\n");
}
return;
}
//-------------------------------------------------------------------------------
// Name: GSTSeekAbsolute
// Arguments: value (position in time - miliseconds)
// Description: seek to a determined value
// usage: object->GSTSeekAbsolute(1000);
//-------------------------------------------------------------------------------
void GSTVideoControl::GSTSeekAbsolute(guint64 value)
{
guint64 nanoseconds;
nanoseconds = value * 1000 * 1000;
if (__pipeline)
{
GSTPause ();
gst_element_seek ( __pipeline,
1.0,
GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET,
nanoseconds,
GST_SEEK_TYPE_NONE,
GST_CLOCK_TIME_NONE
);
GSTPlay ();
}
else
{
printf ("\nError: no pipeline created\n");
}
return;
}
/**
* ly_aud_set_position:
* @percent: The desire position you want to seek, it should be between 0 and 1.
*
* Seek.
*
* Returns: TRUE for success, others FALSE.
*/
gboolean
ly_aud_set_position(gdouble percent)
{
LyMdhMetadata *md=ly_pqm_get_current_md();
if(!md)
return FALSE;
GstElement *play=ly_ppl_get_playbin();
if(!play)
return FALSE;
gint64 position=0;
gint64 start=0;
gint64 duration=0;
duration=ly_mdh_time_str2int(md->duration);
if(duration<10)
{
return FALSE;
}
start=ly_mdh_time_str2int(md->start);
position=(duration*percent)+start;
if(!gst_element_seek(play,1.0,GST_FORMAT_TIME,GST_SEEK_FLAG_FLUSH,GST_SEEK_TYPE_SET,position,GST_SEEK_TYPE_SET,start+duration))
{
g_critical(_("Cannot seek to desired position!"));
return FALSE;
}
return TRUE;
}
static void
position_value_changed_cb (GtkAdjustment *adjustment,
gpointer user_data)
{
GthMediaViewerPage *self = user_data;
gint64 current_value;
char *s;
if (self->priv->playbin == NULL)
return;
current_value = (gint64) (gtk_adjustment_get_value (adjustment) / 100.0 * self->priv->duration);
gst_element_seek (self->priv->playbin,
self->priv->rate,
GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
GST_SEEK_TYPE_SET,
current_value,
GST_SEEK_TYPE_NONE,
0.0);
s = _g_format_duration_for_display (GST_TIME_AS_MSECONDS (current_value));
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("label_position")), s);
g_free (s);
}
static void
update_player_rate (GthMediaViewerPage *self)
{
gint64 current_value;
self->priv->rate = CLAMP (self->priv->rate,
default_rates[0],
default_rates[G_N_ELEMENTS (default_rates) - 1]);
if (self->priv->playbin == NULL)
return;
update_playback_info (self);
if (! self->priv->playing)
return;
current_value = (gint64) (gtk_adjustment_get_value (GTK_ADJUSTMENT (GET_WIDGET ("position_adjustment"))) / 100.0 * self->priv->duration);
if (! gst_element_seek (self->priv->playbin,
self->priv->rate,
GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
GST_SEEK_TYPE_SET,
current_value,
GST_SEEK_TYPE_NONE,
0.0))
{
g_warning ("seek failed");
}
}
// set the position of the media file
void gst_binding_set_position (gstPlay *play, gint64 time_sec, float speed) {
if (!isValid (play)) return;
gst_element_seek (play->element, speed, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, time_sec * GST_MSECOND,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
}
// set the position of the media file
void gst_binding_set_track (gstPlay *play, gint64 track_number, float speed) {
if (!isValid (play)) return;
gst_element_seek (play->element, speed, gst_format_get_by_nick ("track"),
GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, track_number - 1,
GST_SEEK_TYPE_NONE, -1);
}
static void
test_reset_on_seek (BT_TEST_ARGS)
{
BT_TEST_START;
GST_INFO ("-- arrange --");
GstElement *p =
gst_parse_launch
("buzztrax-test-audio-synth name=\"src\" ! fakesink async=false", NULL);
BtTestAudioSynth *e =
(BtTestAudioSynth *) gst_bin_get_by_name (GST_BIN (p), "src");
GstBus *bus = gst_element_get_bus (p);
GST_INFO ("-- act --");
gst_element_set_state (p, GST_STATE_PAUSED);
gst_element_get_state (p, NULL, NULL, GST_CLOCK_TIME_NONE);
gst_element_seek (p, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, GST_MSECOND * 100,
GST_SEEK_TYPE_SET, GST_MSECOND * 200);
gst_element_set_state (p, GST_STATE_PLAYING);
gst_element_get_state (p, NULL, NULL, GST_CLOCK_TIME_NONE);
gst_bus_poll (bus, GST_MESSAGE_EOS | GST_MESSAGE_ERROR, GST_CLOCK_TIME_NONE);
GST_INFO ("-- assert --");
ck_assert_int_eq (e->num_disconts, 1);
GST_INFO ("-- cleanup --");
gst_element_set_state (p, GST_STATE_NULL);
gst_object_unref (e);
gst_object_unref (p);
BT_TEST_END;
}
void
gst_seek_absolute(guint64 value) {
gst_element_seek(pipeline, 1.0,
GST_FORMAT_TIME,
GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
GST_SEEK_TYPE_SET, value,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
}
bool CGstDecoder::Seek(GstElement *element)
{
if (!gst_element_seek (m_pipeline, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_NONE, 0,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) {
g_print ("Seek failed!\n");
}
}
void
gst_seek(gint value) {
gst_element_seek(pipeline, 1.0,
GST_FORMAT_TIME,
GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
GST_SEEK_TYPE_CUR, value * GST_SECOND,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
}
void ofGstUtils::setSpeed(float _speed){
GstFormat format = GST_FORMAT_TIME;
GstSeekFlags flags = (GstSeekFlags) (GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP | GST_SEEK_FLAG_ACCURATE);
gint64 pos;
if(_speed==0){
gst_element_set_state (gstPipeline, GST_STATE_PAUSED);
return;
}
if(!gst_element_query_position(GST_ELEMENT(gstPipeline),&format,&pos) || pos<0){
//ofLog(OF_LOG_ERROR,"GStreamer: cannot query position");
return;
}
speed = _speed;
//pos = (float)gstData.lastFrame * (float)fps_d / (float)fps_n * GST_SECOND;
if(!bPaused)
gst_element_set_state (gstPipeline, GST_STATE_PLAYING);
if(speed>0){
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
pos,
GST_SEEK_TYPE_SET,
-1)) {
ofLog(OF_LOG_WARNING,"GStreamer: unable to change speed");
}
}else{
if(!gst_element_seek(GST_ELEMENT(gstPipeline),speed, format,
flags,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_SET,
pos)) {
ofLog(OF_LOG_WARNING,"GStreamer: unable to change speed");
}
}
ofLog(OF_LOG_VERBOSE,"Gstreamer: speed change to %f", speed);
}
P_INVOKE void
bp_dvd_go_to_previous_chapter (BansheePlayer *player)
{
gint64 index;
GstFormat format = gst_format_get_by_nick ("chapter");
gst_element_query_position (player->playbin, format, &index);
gst_element_seek (player->playbin, 1.0, format, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, index - 1, GST_SEEK_TYPE_NONE, 0);
}
static GdkPixbuf *
gst_thumbnailer_capture_interesting_frame (GstElement *play,
gint64 duration,
gint width,
GCancellable *cancellable)
{
GdkPixbuf *pixbuf = NULL;
guint n;
const gdouble offsets[] = { 1.0 / 3.0, 2.0 / 3.0, 0.1, 0.9, 0.5 };
gint64 seek_time;
/* video has no duration, capture 1st frame */
if (duration == -1)
{
if (!g_cancellable_is_cancelled (cancellable))
return gst_thumbnailer_capture_frame (play, width);
else
return NULL;
}
for (n = 0; n < G_N_ELEMENTS (offsets); n++)
{
/* check if we should abort */
if (g_cancellable_is_cancelled (cancellable))
break;
/* seek to offset */
seek_time = offsets[n] * duration;
gst_element_seek (play, 1.0,
GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
GST_SEEK_TYPE_SET, seek_time * GST_MSECOND,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
/* wait for the seek to complete */
gst_element_get_state (play, NULL, NULL, GST_CLOCK_TIME_NONE);
/* check if we should abort */
if (g_cancellable_is_cancelled (cancellable))
break;
/* get the frame */
pixbuf = gst_thumbnailer_capture_frame (play, width);
if (pixbuf == NULL)
continue;
/* check if image is interesting or end of loop */
if (n + 1 == G_N_ELEMENTS (offsets)
|| gst_thumbnailer_pixbuf_interesting (pixbuf))
break;
/* continue looking for something better */
g_object_unref (pixbuf);
pixbuf = NULL;
}
return pixbuf;
}
void Player::setPosition(QTime position)
{
int time_milliseconds=QTime(0,0).msecsTo(position);
gint64 time_nanoseconds=( time_milliseconds * GST_MSECOND );
gst_element_seek (pipeline, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, time_nanoseconds,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
m_position=time_milliseconds;
emit positionChanged();
}
bool PlayerGst::play()
{
GstElement *p = pipeline;
if(usePlaybin) p = gst_bin_get_by_name(GST_BIN(pipeline), "playbin");
if(Glength) gst_element_seek(p, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, Gstart, GST_SEEK_TYPE_SET, Gstart + Glength);
//sync_set_state(player, GST_STATE_PLAYING);
gst_element_set_state (GST_ELEMENT (p), GST_STATE_PLAYING);
timer->start(TIME);
if(usePlaybin) gst_object_unref(p);
return true;
}
