bool Control::pause(bool tryplay) { EXIT_IDLE; pms->log(MSG_DEBUG, 0, "Toggling pause, tryplay=%d\n", tryplay); switch(st->state) { case MPD_STATE_PLAY: return mpd_run_pause(conn->h(), true); case MPD_STATE_PAUSE: return mpd_run_pause(conn->h(), false); case MPD_STATE_STOP: case MPD_STATE_UNKNOWN: default: return (tryplay && play()); } }
/* * pgmpc_pause * Pause current song */ Datum pgmpc_pause(PG_FUNCTION_ARGS) { pgmpc_init(); /* * Enforce pause to be set in all cases. Subsequent calls * to this function result still in a pause state. */ if (!mpd_run_pause(mpd_conn, true)) pgmpc_print_error(); pgmpc_reset(); PG_RETURN_NULL(); }
/* * pgmpc_play * Play a song. */ Datum pgmpc_play(PG_FUNCTION_ARGS) { pgmpc_init(); /* * Enforce disabling of pause. We could here check for the server * status before doing anything but is it worth the round trip? */ if (!mpd_run_pause(mpd_conn, false)) pgmpc_print_error(); pgmpc_reset(); PG_RETURN_VOID(); }
void cmd_pause(irc_session_t* session, const char* cmd, const char* origin, char* args) { struct mpd_connection* conn; conn = mpd_connection_new(NULL, 0, 30000); if(mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { log_and_print("Impossible de se connecter à MPD"); mpd_connection_free(conn); return; } mpd_run_pause(conn, 1); mpd_connection_free(conn); }
/*my_mpd_run_pause*/ void my_mpd_run_pause(void) { struct mpd_status *status = NULL; pthread_mutex_lock(&mutex); status = mpd_run_status(conn); if (!status) { printf("nd my_mpd_run_pause mpd_run_status1 %s \n", mpd_connection_get_error_message(conn)); } else { if (mpd_status_get_state(status) == MPD_STATE_PLAY) { mpd_run_pause(conn, true); } mpd_status_free(status); } pthread_mutex_unlock(&mutex); }
bool handle_player_command(struct mpdclient *c, command_t cmd) { struct mpd_connection *connection; if (!mpdclient_is_connected(c) || c->status == NULL) return false; cancel_seek_timer(); switch(cmd) { /* case CMD_PLAY: mpdclient_cmd_play(c, MPD_PLAY_AT_BEGINNING); break; */ case CMD_PAUSE: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_pause(connection, mpd_status_get_state(c->status) != MPD_STATE_PAUSE)) mpdclient_handle_error(c); break; case CMD_STOP: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_stop(connection)) mpdclient_handle_error(c); break; case CMD_CROP: mpdclient_cmd_crop(c); break; case CMD_SEEK_FORWARD: if (!setup_seek(c)) break; seek_target_time += options.seek_time; if (seek_target_time > (int)mpd_status_get_total_time(c->status)) seek_target_time = mpd_status_get_total_time(c->status); break; case CMD_TRACK_NEXT: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_next(connection)) mpdclient_handle_error(c); break; case CMD_SEEK_BACKWARD: if (!setup_seek(c)) break; seek_target_time -= options.seek_time; if (seek_target_time < 0) seek_target_time = 0; break; case CMD_TRACK_PREVIOUS: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_previous(connection)) mpdclient_handle_error(c); break; case CMD_SHUFFLE: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (mpd_run_shuffle(connection)) screen_status_message(_("Shuffled playlist")); else mpdclient_handle_error(c); break; case CMD_CLEAR: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (mpdclient_cmd_clear(c)) screen_status_message(_("Cleared playlist")); break; case CMD_REPEAT: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_repeat(connection, !mpd_status_get_repeat(c->status))) mpdclient_handle_error(c); break; case CMD_RANDOM: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_random(connection, !mpd_status_get_random(c->status))) mpdclient_handle_error(c); break; case CMD_SINGLE: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_single(connection, !mpd_status_get_single(c->status))) mpdclient_handle_error(c); break; case CMD_CONSUME: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_consume(connection, !mpd_status_get_consume(c->status))) mpdclient_handle_error(c); break; case CMD_CROSSFADE: connection = mpdclient_get_connection(c); if (connection == NULL) break; if (!mpd_run_crossfade(connection, mpd_status_get_crossfade(c->status) > 0 ? 0 : options.crossfade_time)) mpdclient_handle_error(c); break; case CMD_DB_UPDATE: screen_database_update(c, NULL); break; case CMD_VOLUME_UP: mpdclient_cmd_volume_up(c); break; case CMD_VOLUME_DOWN: mpdclient_cmd_volume_down(c); break; default: return false; } return true; }
/*The thread of I2C*/ void * I2CThread(void *arg) { int res = 0; while (1) { res = 0; if (i2c_file > 0) { if (!bread_register) { res = i2c_smbus_read_word_data(i2c_file, REGISTER3); switch (res) { case SWITCH_BTN_SHUT_DWON: { printf("nd I2CThread SWITCH_BTN_SHUT_DWON: 0x%0*x\n", 2, res); break; } case SHUT_DWON: { printf("nd I2CThread BTN3 SHUT_DWON: 0x%0*x\n", 2, res); break; } case AUTO_SLEEP: { printf("nd I2CThread AUTO_SLEEP: 0x%0*x\n", 2, res); break; } } bread_register = true; } res = i2c_smbus_read_word_data(i2c_file, REGISTER2); //printf("md I2CThread i2c_file res: 0x%0*x\n", 2, res); switch (res) { case BTN1_SHORT_PRESS: { printf("nd I2CThread BTN1_SHORT_PRESS: 0x%0*x\n", 2, res); btn1_short_press(); break; } case BTN1_LONG_PRESS: { printf("nd I2CThread BTN1_LONG_PRESS: 0x%0*x\n", 2, res); btn1_long_press(); break; } case BTN1_AUDIO_SPPEK_ARECORD: { printf("nd BTN1_AUDIO_SPPEK_ARECORD :: 0x%0*x\n", 2, res); btn1_audio_sppek_arecord(res); break; } case BTN2_SHORT_PRESS: { printf("nd I2CThread BTN2_SHORT_PRESS: 0x%0*x\n", 2, res); btn2_short_press(); break; } case BTN2_LONG_PRESS: { printf("nd I2CThread BTN2_LONG_PRESS: 0x%0*x\n", 2, res); btn2_long_press(); break; } case BTN3_SHORT_PRESS: { printf("nd I2CThread BTN3_SHORT_PRESS: 0x%0*x\n", 2, res); btn3_short_press(); break; } case BTN3_LONG_PRESS: { printf("nd I2CThread BTN3_LONG_PRESS: 0x%0*x\n", 2, res); btn3_long_press(); break; } case BTN4_SHORT_PRESS: { printf("nd I2CThread BTN4_SHORT_PRESS: 0x%0*x\n", 2, res); btn4_short_press(); break; } case BTN4_LONG_PRESS: { printf("nd I2CThread BTN4_LONG_PRESS: 0x%0*x\n", 2, res); btn4_long_press(); break; } case BTN5_SHORT_PRESS: { printf("nd I2CThread BTN5_SHORT_PRESS: 0x%0*x\n", 2, res); btn5_short_press(); break; } case BTN5_LONG_PRESS: { printf("nd I2CThread BTN5_LONG_PRESS: 0x%0*x\n", 2, res); btn5_long_press(); break; } case BTN5_QUESTION_ANSWER_ARECORD: { btn5_question_answer_arecord(res); break; } case PEN_START: { #ifdef PEN_SUPPORT printf("nd I2CThread PEN_START: 0x%0*x\n", 2, res); int nValue = 0, nValue8 = 0, nValue9 = 0, nValue10 = 0, nValue89 = 0; nValue10 = i2c_smbus_read_word_data(i2c_file, REGISTER10); printf("nd I2CThread REGISTER10: 0x%0*x, %d\n", 2, nValue10, nValue10); nValue9 = i2c_smbus_read_word_data(i2c_file, REGISTER9); printf("nd I2CThread REGISTER9: 0x%0*x, %d\n", 2, nValue9, nValue9); nValue8 = i2c_smbus_read_word_data(i2c_file, REGISTER8); printf("nd I2CThread REGISTER8: 0x%0*x, %d\n", 2, nValue8, nValue8); nValue89 = nValue8 | ((nValue9 << 8) & 0xff00); printf("nd I2CThread nValue89: %x, nValue89: %d, \n", nValue89, nValue89); nValue = nValue8 | ((nValue9 << 8) & 0xff00) | ((nValue10 << 16) & 0xff0000); printf("nd I2CThread nValue: %x, \n", nValue, nValue); if (nValue == 0x60fff8) { pthread_mutex_lock(&mutex); mpd_run_pause(conn, true); mpd_run_clear(conn); mpd_run_load(conn, "ljyy.lst"); pthread_mutex_unlock(&mutex); } else if (nValue == 0x60fff7) { } else if (nValue89 > 52900) { int nPos = nValue89 - 52901; printf("nd I2CThread nPos: %d, \n", nPos); pthread_mutex_lock(&mutex); mpd_run_pause(conn, true); mpd_run_single(conn, true); mpd_run_play_pos(conn, nPos); pthread_mutex_unlock(&mutex); } res = i2c_smbus_read_word_data(i2c_file, REGISTER2); printf("nd I2CThread REGISTER2: 0x%0*x\n", 2, res); #endif break; } case NOT_BTN_EVENT: { break; } } } else { printf("nd I2CThread i2c_file: %d\n", i2c_file); InitI2CDev(); } usleep(50*1000); } }
/*btn3_short_press*/ void btn3_short_press(void) { int res = json_type_null; json_object * pjson_obj_read = NULL; struct mpd_status *status = NULL; ncurrt_time = 0; system("killall aplay"); system("killall xfchat"); pthread_rwlock_wrlock(&json_rwlock_voice); pjson_obj_read = json_object_from_file(PLAY_VOICE_JSON_PATH); pthread_rwlock_unlock(&json_rwlock_voice); res = json_object_get_type(pjson_obj_read); printf("json_type: %u \n", json_object_get_type(pjson_obj_read)); // printf("json_length: %u \n", json_object_array_length(pjson_obj_read)); json_object_put(pjson_obj_read); if ((json_type_array == res) && (0 < json_object_array_length(pjson_obj_read)) && (!bplay_audio)) { printf("nd btn3_short_press ret: %d, bplay_audio: %d\n", res, bplay_audio); my_mpd_run_pause(); bplay_audio = true; } else { int quere_len = 0; int online_size = 0; bplay_audio = false; online_size = get_file_size(ONLINE_LIST_PATH); if (online_size > 0) { quere_len = get_mpc_quere_len(conn); pthread_mutex_lock(&mutex); if (quere_len > 0) { mpd_run_stop(conn); mpd_run_clear(conn); } bool mpc_load = mpd_run_load(conn, "online.lst"); bool mpc_list_clear = mpd_run_playlist_clear(conn, "online.lst"); printf("nd btn3_short_press mpc_load: %d, mpc_list_clear: %d\n", mpc_load, mpc_list_clear); pthread_mutex_unlock(&mutex); res = i2c_smbus_write_byte_data(i2c_file, 0x00, BLUE_OFF); if (res < 0) { printf("nd btn3_short_press i2c_smbus_write_byte_data BLUE_OFF failed, ret: %d\n", res); } } quere_len = get_mpc_quere_len(conn); if (quere_len > 0) { printf("nd btn3_short_press get_mpc_quere_len quere_len: %d\n", quere_len); pthread_mutex_lock(&mutex); status = mpd_run_status(conn); if (!status) { printf("nd btn3_short_press mpd_run_status2 %s \n", mpd_connection_get_error_message(conn)); } else { if (mpd_status_get_state(status) == MPD_STATE_PLAY) { printf("nd btn3_short_press mpd_status_get_state MPD_STATE_PLAY\n"); mpd_run_pause(conn, true); } else { printf("nd btn3_short_press mpd_status_get_state other state\n"); mpd_run_play(conn); } mpd_status_free(status); } pthread_mutex_unlock(&mutex); } } }
void Connection::Pause(bool state) { prechecksNoCommandsList(); mpd_run_pause(m_connection.get(), state); checkErrors(); }
void* threadManager(void *thread_arg){ int i; conn = NULL; if (DEBUG) fprintf (stderr, "DEBUG: [mgr-thread] -starting\n"); alsaSetup(); if (ADC_init() < 0) { fprintf(stderr, "FATAL: ADC: Unable to setup ADC interface\n"); flag_exit++; return thread_arg; } for (i = 0; i < 10 && conn == NULL; i++) { if (!mgr_mpd_connect()) { fprintf(stderr, "ERROR: MPD: Unable to connect, reconnecting...\n"); delay(1000); } } if (conn == NULL) { fprintf(stderr, "FATAL: MPD: Unable to connect to MPD server, exiting...\n"); flag_exit++; return thread_arg; } if (!mgr_mpd_fetch_status( conn, 1 )) { fprintf(stderr, "ERROR: MPD: Unable to fetch MPD status\n"); mgr_handle_mpd_error(); } // Read ADC & Update MPD volume_update(); // Set volume to 0 if it does not play if (conn != NULL && cur_mpd_player_status != MPD_STATE_PLAY) { if (DEBUG) fprintf (stderr, "DEBUG: [mgr-thread] mpd: starting playing...\n"); // set value to 0 if (!mpd_run_set_volume(conn, 0)) { fprintf(stderr, "ERROR: MPD: Unable to set volume\n"); mgr_handle_mpd_error(); } // start player if (!mpd_run_play(conn)) { fprintf(stderr, "ERROR: MPD: Unable to start playing\n"); mgr_handle_mpd_error(); } } mgr_unsetWarmingUp(); if (DEBUG) fprintf (stderr, "DEBUG: [mgr-thread] +started\n"); while (!flag_exit) { ////////////////////////////////////////////////////////////////// // Open MPD Connection ////////////////////////////////////////////////////////////////// if (conn == NULL) { if (!mgr_mpd_connect()) { delay(5000); continue; } } ////////////////////////////////////////////////////////////////// // WARMING? ////////////////////////////////////////////////////////////////// if (mgr_isWarmingUp()) { delay(1000); continue; } ////////////////////////////////////////////////////////////////// // RECEIVE STATUS ////////////////////////////////////////////////////////////////// if (!mgr_mpd_fetch_status( conn, 0 )) { mgr_handle_mpd_error(); continue; } ////////////////////////////////////////////////////////////////// // update volume ////////////////////////////////////////////////////////////////// volume_update(); ////////////////////////////////////////////////////////////////// // update playlist if needed ////////////////////////////////////////////////////////////////// if (cur_mpd_stats_number_of_songs != cur_mpd_status_queue_len) { if (!mqr_update_playlist()) { fprintf(stderr, "ERROR: MPD: Unable to update playlist\n"); mgr_handle_mpd_error(); return 0; } } ////////////////////////////////////////////////////////////////// // check player timeout ////////////////////////////////////////////////////////////////// if (cur_mpd_player_status == MPD_STATE_PLAY) { if (ts_started == 0) ts_started = time(NULL); int timeout = 3600; if (ts_started + timeout < time(NULL)) { if (!flag_stop) { if (DEBUG) fprintf(stderr, "DEBUG: MGR: Timeout reached, stop playing\n"); } flag_stop++; } } else { ts_started = 0; } ////////////////////////////////////////////////////////////////// // START ////////////////////////////////////////////////////////////////// if (flag_start) { alsaPlaySound(PCM_SOUND_ID_CLICK); if (!mpd_run_play(conn)) { fprintf(stderr, "ERROR: [mgr-thread] mpd: start command failed\n"); mgr_handle_mpd_error(); continue; } if (DEBUG) fprintf(stderr, "DEBUG: [mgr-thread] player started\n"); cur_mpd_player_status = MPD_STATE_PLAY; // for volume control flag_start = 0; } ////////////////////////////////////////////////////////////////// // STOP if (flag_stop) { // alsaPlaySound(PCM_SOUND_ID_CLICK); if (cur_mpd_volume == 0) { if (DEBUG) fprintf(stderr, "DEBUG: [mgr-thread] player stopped\n"); if (!mpd_run_pause(conn, true)) { fprintf(stderr, "ERROR: [mgr-thread] mpd: stop command failed\n"); mgr_handle_mpd_error(); continue; } cur_mpd_player_status = MPD_STATE_PAUSE; // for volume control flag_stop = 0; } } ////////////////////////////////////////////////////////////////// // RANDOM SWTICH MODE (SKIP2) if (flag_skip2) { alsaPlaySound(PCM_SOUND_ID_CLICK); if (!mpd_run_random(conn, (cur_mpd_random > 0 ? false : true) )) { fprintf(stderr, "ERROR: [mgr-thread] mpd: random command failed\n"); mgr_handle_mpd_error(); continue; } cur_mpd_random = cur_mpd_random > 0 ? 0 : 1; } ////////////////////////////////////////////////////////////////// // SKIP1 (skip file) if (flag_skip1 || flag_skip2) { if (flag_skip1) { alsaPlaySound(PCM_SOUND_ID_CLICK); } if (!mpd_run_next(conn)) { fprintf(stderr, "ERROR: [mgr-thread] mpd: skip command failed\n"); mgr_handle_mpd_error(); continue; } } flag_skip1 = flag_skip2 = 0; delay(400); //delay 40 ms }//end while if (DEBUG) fprintf (stderr, "DEBUG: [mgr-thread] thread finished\n"); return thread_arg; }