void _hardware_event(int event) {
switch(event) {
case HE_FREQ_UP: tuner_tune_by(g_tuner, 10); tuner_debug(); break;
case HE_FREQ_DOWN: tuner_tune_by(g_tuner, -10); tuner_debug(); break;
case HE_CHANNEL1: tuner_goto(g_tuner, 0); tuner_debug(); break;
case HE_CHANNEL2: tuner_goto(g_tuner, 1); tuner_debug(); break;
case HE_CHANNEL3: tuner_goto(g_tuner, 2); tuner_debug(); break;
case HE_CHANNEL4: tuner_goto(g_tuner, 3); tuner_debug(); break;
case HE_CHANNEL5: tuner_goto(g_tuner, 4); tuner_debug(); break;
case HE_PLAY_PAUSE:
if (g_is_playing) {
printf("Pause playback\n");
sp_session_player_play(g_sess, 0);
g_is_playing = 0;
} else {
printf("Resume playback\n");
sp_session_player_play(g_sess, 1);
g_is_playing = 1;
}
notify_main_thread(g_sess);
break;
case HE_SKIP_NEXT:
hardware_banner("Skip", 100);
track_ended(1);
notify_main_thread(g_sess);
break;
}
}
void seek(list<int> int_params, list<string> string_params, sp_session *session, sp_track *track) {
int pos_ms = int_params.front();
if (s_is_playing)
sp_session_player_play(session, false);
sp_session_player_seek(session, pos_ms);
if (s_is_playing)
sp_session_player_play(session, true);
s_player_position = pos_ms;
}
void seek(list<int> int_params, list<string> string_params, sp_session *session, sp_track *track) {
float position = (float)int_params.front() / 100.0;
int pos_ms = (int) ((float) sp_track_duration(track) * position);
if (s_is_playing)
sp_session_player_play(session, false);
sp_session_player_seek(session, pos_ms);
if (s_is_playing)
sp_session_player_play(session, true);
s_player_position = pos_ms / 1000;
}
JNIEXPORT int JNICALL Java_jahspotify_impl_JahSpotifyImpl_resume (JNIEnv *env, jobject obj)
{
if (g_currenttrack)
{
sp_session_player_play(g_sess,1);
}
}
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 );
}
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;
}
// 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);
}
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) */
}
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;
}
static void on_end_of_track(sp_session *session)
{
debug("callback: on end of track");
audio_fifo_flush(&g_audiofifo);
sp_session_player_play(session, 0);
notify_main_thread(g_session);
queue_go_next(g_session);
}
void pause(list<int> int_params, list<string> string_params, sp_session *session, sp_track *track) {
if (s_is_playing) {
s_is_playing = false;
sp_session_player_play(session, false);
//mute(opensl);
on_player_pause(int_params, string_params, session, track);
}
}
void session_play(gboolean play) {
sp_session_player_play(g_session, play);
if (!play)
/* Force pause in the audio plugin */
g_audio_delivery_func(NULL, NULL, 0);
cb_notify_main_thread(NULL);
}
static void on_end_of_track(sp_session *session)
{
debug("callback: on_end_of_track");
audio_fifo_flush(&g_audiofifo);
sp_session_player_play(session, 0);
sp_session_player_unload(session);
printf("Done.\n\n");
g_playing = 0;
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::_pause( )
{
if ( !isTrackPaused() ) {
m_audio_out->setPaused( true );
sp_session_player_play( m_spotify_session, false );
m_track_timer.pause();
}
}
static PyObject *Session_play(Session *self, PyObject *args) {
int play;
sp_error err;
if(!PyArg_ParseTuple(args, "i", &play))
return NULL;
Py_BEGIN_ALLOW_THREADS
err = sp_session_player_play(self->_session, play);
Py_END_ALLOW_THREADS
return handle_error(err);
}
void QSpotifySession::beginPlayBack(bool notifyThread)
{
qDebug() << "QSpotifySession::beginPlayBack";
sp_session_player_play(m_sp_session, true);
m_isPlaying = true;
emit isPlayingChanged();
if(notifyThread)
QCoreApplication::postEvent(g_audioWorker, new QEvent(QEvent::Type(ResumeEventType)));
}
Spotify::Error Spotify::Session::pause()
{
Spotify::Error error;
// Is playing:
if( m_playing )
{
error = sp_session_player_play( m_session, false );
if( !error.isError() )
m_playing = false;
}
// Is paused:
else if( !m_playing && m_currentTrack->trackPointer() && sp_track_is_loaded( m_currentTrack->trackPointer() ) )
{
error = sp_session_player_play( m_session, true );
if( !error.isError() )
m_playing = true;
}
return error;
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::_resume( )
{
if ( isTrackPaused() ) {
sp_session_player_play( m_spotify_session, true );
if ( m_audio_out->isPaused() )
m_audio_out->setPaused( false );
m_track_timer.resume();
}
}
static PyObject *
Session_play(Session * self, PyObject *args)
{
int play;
if (!PyArg_ParseTuple(args, "i", &play))
return NULL;
Py_BEGIN_ALLOW_THREADS;
sp_session_player_play(self->_session, play);
Py_END_ALLOW_THREADS;
Py_RETURN_NONE;
}
void command_pause(sp_session *session, const struct command * const command)
{
sp_session_player_play(session, is_playing =! is_playing);
if(is_playing)
{
sock_send_str(command->sockfd, "Started playback.\n");
}
else
{
sock_send_str(command->sockfd, "Paused playback.\n");
}
}
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);
}
void QSpotifySession::pause(bool notifyThread)
{
qDebug() << "QSpotifySession::pause";
if (!m_isPlaying)
return;
sp_session_player_play(m_sp_session, false);
m_isPlaying = false;
emit isPlayingChanged();
if(notifyThread)
QCoreApplication::postEvent(g_audioWorker, new QEvent(QEvent::Type(SuspendEventType)));
}
/**
* 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);
}
Spotify::Error Spotify::Session::stop()
{
Spotify::Error error;
if( m_playing )
{
error = sp_session_player_play( m_session, false );
if( !error.isError() )
{
sp_session_player_unload( m_session );
m_playing = false;
}
}
return error;
}
static PyObject *
Session_play(PyObject *self, PyObject *args)
{
int play;
/* TODO: Expect bool or something that can be coerced into one? */
if (!PyArg_ParseTuple(args, "i", &play))
return NULL;
Py_BEGIN_ALLOW_THREADS;
sp_session_player_play(Session_SP_SESSION(self), play);
Py_END_ALLOW_THREADS;
Py_RETURN_NONE;
}
Spotify::Error Spotify::Session::play( Spotify::Track* track )
{
m_playing = false;
m_currentTrack = track;
Spotify::Error error;
// Clean up
audio_fifo_flush(&m_audiofifo);
sp_session_player_unload( m_session );
// Disregard tracks that are not available:
if( !track->isAvailable() )
{
qDebug() << "ERROR: Asked to play back a unavailable track..";
return Spotify::Error( SP_ERROR_TRACK_NOT_PLAYABLE );
}
// Load track:
error = load( track );
if( error.isError() )
{
qDebug() << "ERROR: Could not load track: " << error.toString();
return error;
}
// Disregard unloaded og unavailable tracks:
if( !track->isLoaded() )
{
qDebug() << "ERROR: Asked to play back a unloaded track..";
return Spotify::Error( SP_ERROR_RESOURCE_NOT_LOADED );
}
// Play track:
error = sp_session_player_play( m_session, true );
if( !error.isError() )
{
m_trackPos = 0;
m_playing = true;
}
else
{
qDebug() << "ERROR: Could not play track: " << error.toString();
return error;
}
return Spotify::Error( SP_ERROR_OK );
}
void session_unload() {
session_callback_data scbd;
g_debug("Unloading track.");
/* First call callbacks */
scbd.type = SPOP_SESSION_UNLOAD;
scbd.data = NULL;
g_list_foreach(g_session_callbacks, session_call_callback, &scbd);
/* Then really unload */
sp_session_player_play(g_session, FALSE);
g_audio_delivery_func(NULL, NULL, 0);
sp_session_player_unload(g_session);
cb_notify_main_thread(NULL);
g_audio_samples = 0;
g_audio_time = 0;
}
bool Codec::unloadPlayer() {
//make sure there is no music_delivery while we are removing the codec
while (!Session::getInstance()->lock()) {
}
if (m_isPlayerLoaded) {
sp_session_player_play(getSession(), false);
sp_session_player_unload(getSession());
if (m_currentTrack != NULL) {
sp_track_release(m_currentTrack);
}
}
m_currentTrack = NULL;
m_isPlayerLoaded = false;
m_endOfTrack = true;
Session::getInstance()->unlock();
return true;
}
void end_of_track( sp_session *session )
{
TRACE_2( PLAYERMANAGER , "end_of_track().");
TRACE_3( PLAYERMANAGER , "End of track...");
// LOCK_MUTEX( PLAYERMANAGER , &mutexSession );
TRACE_3( PLAYERMANAGER , "Removing the track which have been played.");
sp_track_release( currentTrack );
// UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession );
// if( hasNextTrack() == TRUE )
// {
// TRACE_1( PLAYERMANAGER , "Load next music !");
// playMusic( session , "" , currentStreamName );
// }
if( nextTrackInStream( currentStreamName ) == PC_SUCCESS )
{
TRACE_1( PLAYERMANAGER , "Load next music !");
}
else
{
TRACE_WARNING( PLAYERMANAGER , "No more music in the mainplaylist");
audio_fifo_flush( &g_audiofifo );
LOCK_MUTEX( PLAYERMANAGER , &mutexSession );
sp_session_player_play( session , 0 );
sp_session_player_unload( session );
UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession );
playing = FALSE;
}
}
