void play(sp_session *session, sp_track *track)
{
sp_error error = sp_session_player_load(session, track);
if (error != SP_ERROR_OK) {
fprintf(stderr, "Error: %s\n", sp_error_message(error));
exit(1);
}
sp_artist *artist = sp_track_artist(track, 0);
sp_album *album = sp_track_album(track);
int secs = sp_track_duration(track) / 1000;
int mins = 0;
while (secs >= 60) {
mins++;
secs -= 60;
}
printf("\n");
printf(" Track: %s\n", sp_track_name(track));
printf(" Artist: %s\n", sp_artist_name(artist));
printf(" Album: %s\n", sp_album_name(album));
printf(" Year: %d\n", sp_album_year(album));
printf(" Popularity: %d / 100\n", sp_track_popularity(track));
printf(" Duration: %02d:%02d\n", mins, secs);
printf("\n");
printf("Playing...\n");
sp_session_player_play(session, 1);
}
/**
* This callback is called when an attempt to login has succeeded or failed.
*
* @sa sp_session_callbacks#logged_in
*/
static void logged_in(sp_session *sess, sp_error error)
{
sp_link *link;
if (SP_ERROR_OK != error) {
fprintf(stderr, "Login failed: %s\n",
sp_error_message(error));
exit(2);
}
printf("Loading track\n");
link = sp_link_create_from_string("spotify:track:5W3cjX2J3tjhG8zb6u0qHn");
sp_track_add_ref(g_currenttrack = sp_link_as_track(link));
sp_link_release(link);
if (sp_track_error(g_currenttrack) == SP_ERROR_OK) {
printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack));
fflush(stdout);
sp_session_player_load(g_sess, g_currenttrack);
sp_session_player_play(g_sess, 1);
}
/* Track not loaded? Then we need to wait for the metadata to
load before we can start playback (see below) */
}
// Loads a track and assumes that the metadata is available
static void load_and_play_track(sp_session *session, sp_track *track) {
sp_session_player_load(session, track);
if (s_play_after_loaded)
play_track(session, track);
(sp_track_is_starred(session, track)) ? on_starred() : on_unstarred();
call_static_void_method("onPrepared");
}
// Start playback.
void sess_play(sp_track *t)
{
if (g_session.state != SESS_ONLINE) {
log_append("Not connected");
return;
}
if (!t || !sp_track_is_available(t) || !sp_track_is_loaded(t)) {
log_append("Track not available");
return;
}
sess_stop();
g_session.current_track = t;
log_append("Playing \"%s\"...", sp_track_name(t));
sp_error err = sp_session_player_load(g_session.spotify, t);
if (err != SP_ERROR_OK)
panic("sp_session_player_load() failed: %s", sp_error_message(err));
err = sp_session_player_play(g_session.spotify, true);
if (err != SP_ERROR_OK)
panic("sp_session_player_play() failed: %s", sp_error_message(err));
g_session.playing = true;
// Redraw track info and progress.
ui_dirty(UI_TRACKINFO);
ui_dirty(UI_TRACKPROGRESS);
ui_update_post(0);
}
bool Codec::loadPlayer() {
Logger::printOut("load player");
if (!m_isPlayerLoaded) {
//do we have a track at all?
if (m_currentTrack) {
CStdString name;
Logger::printOut("load player 2");
if (sp_track_is_loaded(m_currentTrack)) {
sp_error error = sp_session_player_load(getSession(), m_currentTrack);
CStdString message;
Logger::printOut("load player 3");
message.Format("%s", sp_error_message(error));
Logger::printOut(message);
Logger::printOut("load player 4");
if (SP_ERROR_OK == error) {
sp_session_player_play(getSession(), true);
m_isPlayerLoaded = true;
Logger::printOut("load player 5");
return true;
}
}
} else
return false;
}
return true;
}
static int try_play(sp_session *session, sp_track *t,int offset)
{
sp_error err;
fprintf(stderr,"try play\n");
err = sp_session_player_load(session,t);
if( err != SP_ERROR_OK) {
fprintf(stderr,"Load failed %d\n",err);
}
if(!sp_track_is_loaded(t)) {
if(g_track_to_be_played != t) {
if(g_track_to_be_played)
sp_track_release(g_track_to_be_played);
g_track_to_be_played = t; //FIXME: Do I need to addref?
sp_track_add_ref(g_track_to_be_played);
}
} else {
//FIXME: Seek!
// g_current_fifo_idx = (g_current_fifo_idx+1) % 2;
sp_session_player_seek(session,offset);
sp_session_player_play(session,true);
sp_album *album = sp_track_album(t);
if(album) {
const byte *id = sp_album_cover(album);
g_gazify.current_t = t;
if(id) {
sp_image *img = sp_image_create(session,id);
sp_image_add_load_callback(img,&image_loaded,&g_gazify);
}
}
g_track_to_be_played = NULL;
}
return err;
}
void AudioHTTPServer::startStreamingResponse( QxtWebRequestEvent* event, sp_track* track )
{
// yay we gots a track
// qDebug() << QThread::currentThreadId() << "We got a track!" << sp_track_name( track ) << sp_artist_name( sp_track_artist( track, 0 ) ) << sp_track_duration( track );
uint duration = sp_track_duration( track );
sp_error err = sp_session_player_load( SpotifySession::getInstance()->Session(), track );
if( err != SP_ERROR_OK ) {
qWarning() << QThread::currentThreadId() << "Failed to start track from spotify :(" << sp_error_message( err );
sendErrorResponse( event );
return;
}
// qDebug() << QThread::currentThreadId() << "Starting to play!";
sp_session_player_play( SpotifySession::getInstance()->Session(), true );
SpotifySession::getInstance()->Playback()->startPlaying();
qDebug() << "Getting iodevice...";
spotifyiodev_ptr iodev = SpotifySession::getInstance()->Playback()->getIODeviceForNewTrack( duration );
// qDebug() << QThread::currentThreadId() << "Got iodevice to send:" << iodev << iodev.isNull() << iodev->isSequential() << iodev->isReadable();
QxtWebPageEvent* wpe = new QxtWebPageEvent( event->sessionID, event->requestID, iodev );
wpe->streaming = true;
wpe->contentType = "audio/basic";
postEvent( wpe );
}
Spotify::Error Spotify::Session::load( Spotify::Track* track )
{
Spotify::Error error;
sp_track* sptrack = track->trackPointer();
if( sptrack )
{
error = sp_session_player_load( m_session, sptrack );
}
return error;
}
void SpotWorker::loadPlayer(sp_track *track, bool rip, SoundSaver::FileType type)
{
totalFrames_ = sp_track_duration(track)*44;
alsaWorker_->audioFifoFlush();
frameCounter_ = 0;
closeFile();
if(rip)
saveFile(track, type);
sp_session_player_load(currentSession, track);
}
void Spotify::tryLoadTrack()
{
sp_error err;
if (nextTrack == 0) {
return;
}
if (currentTrack == nextTrack) {
return;
}
err = sp_track_error(nextTrack);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Spotify: track error: %s\n",
sp_error_message(err));
return;
}
err = sp_session_player_unload(sp);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Failed to unload player: 0x%02X %s\n",
(unsigned)err, sp_error_message(err));
return;
}
if (audioThread.isRunning()) {
audioThread.quit();
}
err = sp_session_player_load(sp, nextTrack);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Failed to load URI (%s): 0x%02X %s\n",
currentURI.toLocal8Bit().constData(),
(unsigned)err, sp_error_message(err));
return;
}
err = sp_session_player_play(sp, true);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Failed to play URI (%s): %s\n",
currentURI.toLocal8Bit().constData(),
sp_error_message(err));
return;
}
if (currentTrack) {
sp_track_release(currentTrack);
}
currentTrack = nextTrack;
emit songLoaded(currentURI);
}
/**
* Callback called when libspotify has new metadata available
*
* @sa sp_session_callbacks#metadata_updated
*/
static void metadata_updated(sp_session *sess)
{
puts("Metadata updated, trying to start playback");
if (sp_track_error(g_currenttrack) != SP_ERROR_OK)
return;
printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack));
fflush(stdout);
sp_session_player_load(g_sess, g_currenttrack);
sp_session_player_play(g_sess, 1);
}
static PyObject *
Session_load(PyObject *self, PyObject *args)
{
PyObject *track;
sp_error error;
if (!PyArg_ParseTuple(args, "O!", &TrackType, &track))
return NULL;
Py_BEGIN_ALLOW_THREADS;
error = sp_session_player_load(Session_SP_SESSION(self), Track_SP_TRACK(track));
Py_END_ALLOW_THREADS;
return none_or_raise_error(error);
}
static PyObject *Session_load(Session *self, PyObject *args) {
Track *track;
sp_track *t;
sp_session *s;
sp_error err;
if(!PyArg_ParseTuple(args, "O!", &TrackType, &track)) {
return NULL;
}
Py_INCREF(track);
t = track->_track;
s = self->_session;
Py_BEGIN_ALLOW_THREADS
err = sp_session_player_load(s, t);
Py_END_ALLOW_THREADS
return handle_error(err);
}
void QSpotifySession::play(std::shared_ptr<QSpotifyTrack> track, bool restart)
{
qDebug() << "QSpotifySession::play";
if (track->error() != QSpotifyTrack::Ok || !track->isAvailable() || (m_currentTrack == track && !restart))
return;
if (m_currentTrack) {
if (m_trackChangedAutomatically) {
// We're done decoding the track, but we might not be done playing it
m_previousTrackRemaining = m_currentTrack->duration() - m_currentTrackPosition;
} else {
m_previousTrackRemaining = 0;
}
sp_session_player_unload(m_sp_session);
m_isPlaying = false;
m_currentTrack.reset();
m_currentTrackPosition = 0;
m_currentTrackPlayedDuration = 0;
// Only discard buffers if the track change was initialized manually
// since we will otherwise potentially discard the end of the just played track
if (!m_trackChangedAutomatically) {
QCoreApplication::postEvent(g_audioWorker, new QEvent(QEvent::Type(ResetBufferEventType)));
}
} else {
m_previousTrackRemaining = 0;
}
m_trackChangedAutomatically = false;
if (!track->seen())
track->setSeen(true);
sp_error error = sp_session_player_load(m_sp_session, track->m_sp_track);
if (error != SP_ERROR_OK) {
fprintf(stderr, "failed to load track: %s\n",
sp_error_message(error));
return;
}
m_currentTrack = track;
m_currentTrackPosition = 0;
m_currentTrackPlayedDuration = 0;
emit currentTrackChanged();
emit currentTrackPositionChanged();
beginPlayBack();
}
/**********************
* Session management *
**********************/
void session_load(sp_track* track) {
sp_error error;
session_callback_data scbd;
g_debug("Loading track.");
error = sp_session_player_load(g_session, track);
if (error != SP_ERROR_OK)
g_error("Failed to load track: %s", sp_error_message(error));
/* Queue some events management */
cb_notify_main_thread(NULL);
/* Then call callbacks */
scbd.type = SPOP_SESSION_LOAD;
scbd.data = track;
g_list_foreach(g_session_callbacks, session_call_callback, &scbd);
}
/**
* Called on various events to start playback if it hasn't been started already.
*
* The function simply starts playing the first track of the playlist.
*/
static void try_jukebox_start(void)
{
sp_track *t;
if (!g_jukeboxlist)
return;
if (!sp_playlist_num_tracks(g_jukeboxlist)) {
fprintf(stderr, "jukebox: No tracks in playlist. Waiting\n");
return;
}
if (sp_playlist_num_tracks(g_jukeboxlist) < g_track_index) {
fprintf(stderr, "jukebox: No more tracks in playlist. Waiting\n");
return;
}
t = sp_playlist_track(g_jukeboxlist, g_track_index);
if (g_currenttrack && t != g_currenttrack) {
/* Someone changed the current track */
audio_fifo_flush(&g_audiofifo);
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
if (!t)
return;
if (sp_track_error(t) != SP_ERROR_OK)
return;
if (g_currenttrack == t)
return;
g_currenttrack = t;
printf("jukebox: Now playing \"%s\"...\n", sp_track_name(t));
fflush(stdout);
sp_session_player_load(g_sess, t);
sp_session_player_play(g_sess, 1);
}
static void try_playback_start(void) {
sp_track *t;
if(amtSongs() == 0) {
fprintf(stderr, "Playlist: No tracks in playlist. Waiting\n");
return;
}
t = sp_link_as_track(firstSong->song);
if(g_currenttrack && t != g_currenttrack) {
audio_fifo_flush(&g_audiofifo);
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
if(!t) {
printf("Null Song\n");
fflush(stdout);
return;
}
int next_timeout = 0;
sp_session_process_events(g_sess, &next_timeout);
while(sp_track_error(t) != SP_ERROR_OK) {
sp_session_process_events(g_sess, &next_timeout);
printf("Loading Track...\n");
usleep(100000);
}
if(sp_track_error(t) != SP_ERROR_OK) {
printf("SP_ERRoR\n");
printf("%i\n", sp_track_error(t));
fflush(stdout);
return;
}
if(g_currenttrack == t) {
printf("Coninuting same track\n");
fflush(stdout);
return;
}
g_currenttrack = t;
printf("Partyfy: Now playing \"%s\"...\n", sp_track_name(t));
fflush(stdout);
sp_session_player_load(g_sess, t);
sp_session_player_play(g_sess, 1);
}
static int spfs_open(const char *path, struct fuse_file_info *fi)
{
file_t *file = find_file(path + 1);
if(!file)
return -ENOENT;
if(!track_ended)
sp_session_player_unload(session);
printf("Spotify: Loading %s by %s\n", sp_track_name(file->track), sp_artist_name(sp_track_artist(file->track, 0)));
sp_session_player_load(session, file->track);
sp_session_player_play(session, 1);
write_wav_header(frame_buf);
frame_buf_size = 44;
track_ended = 0;
return 0;
}
sp_error Session::Load( Track* pTrack )
{
if (pTrack != m_pTrack)
{
if (m_pTrack)
{
Unload( m_pTrack );
}
if (pTrack)
{
sp_error error = sp_session_player_load( m_pSession, pTrack->m_pTrack );
if (error == SP_ERROR_OK)
{
m_pTrack = pTrack;
}
return error;
}
}
return SP_ERROR_OK;
}
static int loadTrack( sp_session *session , sp_track *track )
{
TRACE_2( PLAYERMANAGER , "loadTrack().");
int status = PC_SUCCESS;
sp_error error;
error = sp_session_player_load( session , track );
if( error != SP_ERROR_OK )
{
TRACE_ERROR( PLAYERMANAGER , "Cannot load track, reason: %s" , sp_error_message( error ) );
status = PC_ERROR;
}
else
{
TRACE_1( PLAYERMANAGER , "Track loaded.");
}
return status;
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::_startTrack( )
{
if ( m_track_queue.size() ) {
CSingleLock lock( &m_mutex, TRUE );
TrackQueueEntry entry = m_track_queue.front();
m_track_queue.pop_front();
m_current_track = entry.m_track;
m_track_played_queue.push_back( entry );
sp_error result = sp_session_player_load( m_spotify_session, m_current_track );
if ( result != SP_ERROR_OK ) {
log( "Error %d from sp_session_player_load", (INT)result );
}
m_track_state = TRACK_STREAM_PENDING;
m_track_length_ms = sp_track_duration( m_current_track );
m_track_seek_ms = entry.m_seek_ms > m_track_length_ms ? 0 : entry.m_seek_ms;
getTrackLink( m_current_track, m_current_track_link );
if ( m_track_seek_ms != 0L )
sp_session_player_seek( m_spotify_session, m_track_seek_ms );
else if ( !haveTrackAnalysis(m_current_track_link) ) {
m_analyzer = new TrackAnalyzer( &m_waveFormat, m_track_length_ms, m_current_track_link );
}
if ( !isTrackPaused() ) {
result = sp_session_player_play( m_spotify_session, true );
if ( result != SP_ERROR_OK ) {
log( "Error %d from sp_session_player_play", (INT)result );
}
}
sendTrackQueueEvent();
}
}
/* only used to trigger sp_session_process_events when needed,
* looks like about once a second */
static void*
spotify_thread_func (void *data)
{
int timeout = -1;
GTimeVal t;
GstSpotSrc *spot = (GstSpotSrc *) data;
if (!spotify_create_session (spot)) {
GST_ERROR_OBJECT (spot, "Create_session error");
return FALSE;
}
while (spot->keep_spotify_thread) {
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
g_get_current_time (&t);
g_time_val_add (&t, timeout * 1000);
g_cond_timed_wait (spot->process_events_cond, spot->process_events_mutex, &t);
spot->spotify_thread_initiated = TRUE;
while (spot->spot_works) {
struct spot_work *spot_work;
sp_error ret = SP_ERROR_INVALID_INDATA;
spot_work = (struct spot_work *)spot->spot_works->data;
g_mutex_lock (spot_work->spot_mutex);
switch (spot_work->cmd) {
case SPOT_CMD_START:
GST_DEBUG_OBJECT (spot, "Uri = %s", GST_SPOT_SRC_URI_LOCATION (spot));
if (!spotify_login (spot)) {
/* error message from within function */
break;
}
sp_link *link = sp_link_create_from_string (GST_SPOT_SRC_URI_LOCATION (spot));
if (!link) {
GST_ERROR_OBJECT (spot, "Incorrect track ID:%s", GST_SPOT_SRC_URI_LOCATION (spot));
break;
}
GST_SPOT_SRC_CURRENT_TRACK (spot) = sp_link_as_track (link);
if (!GST_SPOT_SRC_CURRENT_TRACK (spot)) {
GST_ERROR_OBJECT (spot, "Could get track from uri=%s", GST_SPOT_SRC_URI_LOCATION (spot));
break;
}
#if 0
/* FIXME: why does not this work? */
if (!sp_track_is_available (GST_SPOT_SRC_CURRENT_TRACK (spot))) {
/* this probably happens for tracks avaiable in other countries or
something */
GST_ERROR_OBJECT (spot, "Track is not available, uri=%s", GST_SPOT_SRC_URI_LOCATION (spot));
break;
}
#endif
sp_track_add_ref (GST_SPOT_SRC_CURRENT_TRACK (spot));
sp_link_add_ref (link);
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
while (sp_track_is_loaded (GST_SPOT_SRC_CURRENT_TRACK (spot)) == 0) {
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
usleep (10000);
}
GST_DEBUG_OBJECT (spot, "Now playing \"%s\"", sp_track_name (GST_SPOT_SRC_CURRENT_TRACK (spot)));
ret = sp_session_player_load (GST_SPOT_SRC_SPOTIFY_SESSION (spot), GST_SPOT_SRC_CURRENT_TRACK (spot));
if (ret != SP_ERROR_OK) {
GST_ERROR_OBJECT (spot, "Failed to load track '%s' uri=%s", sp_track_name (GST_SPOT_SRC_CURRENT_TRACK (spot)),
(GST_SPOT_SRC_URI_LOCATION (spot)));
break;
}
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
ret = sp_session_player_play (GST_SPOT_SRC_SPOTIFY_SESSION (spot), TRUE);
if (ret != SP_ERROR_OK) {
GST_ERROR_OBJECT (spot, "Failed to play track '%s' uri=%s", sp_track_name (GST_SPOT_SRC_CURRENT_TRACK (spot)),
(GST_SPOT_SRC_URI_LOCATION (spot)));
break;
}
break;
case SPOT_CMD_PROCESS:
sp_session_process_events (GST_SPOT_SRC_SPOTIFY_SESSION (spot), &timeout);
break;
case SPOT_CMD_PLAY:
ret = sp_session_player_play (GST_SPOT_SRC_SPOTIFY_SESSION (spot), TRUE);
break;
case SPOT_CMD_DURATION:
if (GST_SPOT_SRC_CURRENT_TRACK (spot)) {
ret = sp_track_duration (GST_SPOT_SRC_CURRENT_TRACK (spot));
}
break;
case SPOT_CMD_STOP:
if (GST_SPOT_SRC_CURRENT_TRACK (spot)) {
ret = sp_session_player_play (GST_SPOT_SRC_SPOTIFY_SESSION (spot), FALSE);
if (ret != SP_ERROR_OK) {
break;
}
ret = SP_ERROR_OK;
sp_session_player_unload (GST_SPOT_SRC_SPOTIFY_SESSION (spot));
}
break;
case SPOT_CMD_SEEK:
if (GST_SPOT_SRC_CURRENT_TRACK (spot)) {
ret = sp_session_player_seek (GST_SPOT_SRC_SPOTIFY_SESSION (spot), spot_work->opt);
}
break;
default:
g_assert_not_reached ();
break;
}
/* print all errors caught and propagate to calling thread */
if (ret != SP_ERROR_OK) {
GST_ERROR_OBJECT (spot, "Failed with SPOT_CMD=%d, ret=%d, error=%s", spot_work->cmd, ret, sp_error_message (ret));
}
spot_work->ret = ret;
spot->spot_works = g_list_remove (spot->spot_works, spot->spot_works->data);
g_mutex_unlock (spot_work->spot_mutex);
g_cond_broadcast (spot_work->spot_cond);
}
}
return NULL;
}
static void try_jukebox_start(void)
{
sp_track *t;
printf("try_jukebox_start\n");
if (!g_jukeboxlist)
return;
int nt = sp_playlist_num_tracks(g_jukeboxlist);
if (!nt) {
fprintf(stderr, "jukebox: No tracks in playlist. Waiting\n");
return;
}
if (nt > 2) {
int tmp = g_track_index;
while (tmp == g_track_index)
tmp = rand() % nt;
g_track_index = tmp;
} else {
g_track_index = rand() % nt;
}
printf("play track %d of %d\n", g_track_index, nt);
t = sp_playlist_track(g_jukeboxlist, g_track_index);
printf("t=%X\n", t);
if (g_currenttrack && t != g_currenttrack) {
printf("stopping currently playing..\n");
/* Someone changed the current track */
// audio_fifo_flush(&g_musicfifo);
// sp_session_player_unload(g_sess);
// g_currenttrack = NULL;
}
if (!t)
return;
int err = sp_track_error(t);
if (err != SP_ERROR_OK /*&& err != SP_ERROR_IS_LOADING*/) {
printf("track error? %d\n", err);
return;
}
if (g_currenttrack == t) {
printf("not starting the same track.\n");
return;
}
g_currenttrack = t;
printf("jukebox: Now playing \"%s\"...\n", sp_track_name(t));
sp_artist *art = sp_track_artist(t, 0);
if (art != NULL) {
printf("jukebox: By \"%s\"...\n", sp_artist_name(art));
sprintf( g_last_track_name, "%s by %s", sp_track_name(t), sp_artist_name(art) );
} else {
sprintf( g_last_track_name, "%s", sp_track_name(t) );
}
fflush(stdout);
sp_session_player_load(g_sess, t);
usleep(100000);
sp_session_player_play(g_sess, 1);
usleep(100000);
g_is_playing = 1;
notify_main_thread(g_sess);
printf("after try_jukebox_start\n");
tuner_debug();
}
static GstFlowReturn
rbspotifysrc_create (GstPushSrc *psrc, GstBuffer **outbuf)
{
RBSpotifySrc *src;
size_t readsize = 1000;
GstBuffer *buf = NULL;
int err, offset = 0;
src = RBSPOTIFYSRC (psrc);
fprintf(stderr, "create\n");
while (!sp_track_is_loaded(src->track))
sleep(1);
fprintf(stderr, "loaded");
if (sp_track_is_loaded(src->track) && !src->tloaded)
{
readsize = 0;
fprintf(stderr, "Track name %s", sp_track_name(src->track));
err = sp_session_player_load(src->sess, src->track);
if (err != SP_ERROR_OK)
{
fprintf(stderr, "Couldn't load file %x", err);
return FALSE;
}
err = sp_session_player_play(src->sess, TRUE);
if (err != SP_ERROR_OK)
{
fprintf(stderr, "Couldn't play file %x", err);
return FALSE;
}
src->tloaded = TRUE;
}
audio_fifo_t *af = &g_audio_fifo;
struct timeval now;
struct timespec timeout;
// if (af->nsamples == 0 && src->curoffset < src->size)
// {
fprintf(stderr, "samples: %d curoffset: %lld size: %lld\n", af->nsamples,
(unsigned long long)src->curoffset, (unsigned long long)src->size);
pthread_mutex_lock(&af->cond_mutex);
gettimeofday(&now, NULL);
timeout.tv_sec = now.tv_sec + 5;
timeout.tv_nsec = now.tv_usec * 1000;
pthread_cond_timedwait(&af->cond, &af->cond_mutex, &timeout);
pthread_mutex_unlock(&af->cond_mutex);
if (af->nsamples == 0) {
return GST_FLOW_UNEXPECTED;
}
// }
src->caps = gst_caps_new_simple ("audio/x-raw-int",
"rate", G_TYPE_INT, af->rate,
"channels", G_TYPE_INT, af->channels,
"width", G_TYPE_INT, 16,
"depth", G_TYPE_INT, 16,
"endianness", G_TYPE_INT, G_LITTLE_ENDIAN,
"signed", G_TYPE_BOOLEAN, TRUE, NULL
);
pthread_mutex_lock(&af->mutex);
#ifdef TRACE_SRC
fprintf(stderr, "start: %d end: %d ", af->start, af->end);
fprintf(stderr, "rate: %d channels: %d samples: %d ts: %lld ", af->rate, af->channels, af->nsamples,
(unsigned long long)src->played);
fprintf(stderr, "seconds: %06f ", ((double)af->nsamples)/((double)af->rate));
#endif
buf = gst_buffer_new_and_alloc (af->nsamples *af->channels *sizeof(int16_t));
// GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_OFFSET (buf) = src->curoffset;
src->played += gst_util_uint64_scale_int(GST_SECOND, af->nsamples, af->rate);
GST_BUFFER_SIZE (buf) = af->nsamples*af->channels*sizeof(int16_t);
src->curoffset = src->curoffset + (af->nsamples*af->channels*sizeof(int16_t));
// GST_BUFFER_DURATION(buf) = gst_util_uint64_scale_int(GST_SECOND, af->nsamples, af->rate);
while (af->nsamples > 0)
{
int ncopy = MIN(RING_QUEUE_SIZE - af->start, af->nsamples * af->channels);
memcpy(buf->data+offset, &af->samples[af->start], ncopy*sizeof(int16_t));
offset += ncopy*sizeof(int16_t);
af->nsamples -= ncopy/af->channels;
af->start = (af->start + ncopy) % RING_QUEUE_SIZE;
}
gst_buffer_set_caps(buf, src->caps);
*outbuf = buf;
#ifdef TRACE_SRC
fprintf(stderr, "unconsumed: %d\n", af->nsamples);
#endif
pthread_cond_signal(&af->cond);
pthread_mutex_unlock(&af->mutex);
return GST_FLOW_OK;
}
// Loads a track and assumes that the metadata is available
static void load_and_play_track(sp_session *session, sp_track *track) {
sp_session_player_load(session, track);
if (s_play_after_loaded)
play_track(session, track);
(sp_track_is_starred(session, track)) ? on_starred() : on_unstarred();
}
JNIEXPORT int JNICALL Java_jahspotify_impl_JahSpotifyImpl_playTrack (JNIEnv *env, jobject obj, jstring uri)
{
uint8_t *nativeURI = NULL;
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Initiating play\n");
nativeURI = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: uri: %s\n", nativeURI);
if (!g_audio_initialized)
{
audio_init(&g_audiofifo);
g_audio_initialized = JNI_TRUE;
}
// For each track, read out the info and populate all of the info in the Track instance
sp_link *link = sp_link_create_from_string(nativeURI);
if (link)
{
sp_track *t = sp_link_as_track(link);
if (!t)
{
fprintf(stderr,"No track from link\n");
return;
}
while (!sp_track_is_available(g_sess,t))
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Waiting for track ...\n");
sleep(1);
}
if (sp_track_error(t) != SP_ERROR_OK)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Error with track: %s\n",sp_error_message(sp_track_error(t)));
return;
}
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: name: %s duration: %d\n",sp_track_name(t),sp_track_duration(t));
if (g_currenttrack == t)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Same track!\n");
return;
}
// If there is one playing, unload that now
if (g_currenttrack && t != g_currenttrack)
{
// audio_fifo_flush(&g_audiofifo);
// Unload the current track now
sp_session_player_unload(g_sess);
sp_link *currentTrackLink = sp_link_create_from_track(g_currenttrack,0);
char *currentTrackLinkStr = NULL;
if (currentTrackLink)
{
currentTrackLinkStr = malloc ( sizeof ( char ) * ( 100 ) );
sp_link_as_string(currentTrackLink,currentTrackLinkStr,100);
sp_link_release(currentTrackLink);
}
signalTrackEnded(currentTrackLinkStr, JNI_TRUE);
if (currentTrackLinkStr)
{
free(currentTrackLinkStr);
}
sp_track_release(g_currenttrack);
g_currenttrack = NULL;
}
else
{
// audio_fifo_flush(&g_audiofifo);
// audio_close();
// audio_init(&g_audiofifo);
}
sp_track_add_ref(t);
sp_error result = sp_session_player_load(g_sess, t);
if (sp_track_error(t) != SP_ERROR_OK)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Issue loading track: %s\n", sp_error_message((sp_track_error(t))));
}
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Track loaded: %s\n", (result == SP_ERROR_OK ? "yes" : "no"));
// Update the global reference
g_currenttrack = t;
// Start playing the next track
sp_session_player_play(g_sess, 1);
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Playing track\n");
sp_link_release(link);
signalTrackStarted(nativeURI);
return 0;
}
else
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Unable to load link at this point\n");
}
return 1;
}
