int cmd_volume(int argc, char **argv, struct mpd_connection *conn) { struct int_value_change ch; if (argc == 1) { if (!parse_int_value_change(argv[0], &ch)) DIE("\"%s\" is not an integer\n", argv[0]); } else { struct mpd_status *status = getStatus(conn); if (mpd_status_get_volume(status) >= 0) printf("volume:%3i%c\n", mpd_status_get_volume(status), '%'); else printf("volume: n/a\n"); mpd_status_free(status); return 0; } if (ch.is_relative) { #if LIBMPDCLIENT_CHECK_VERSION(2,9,0) if (mpd_connection_cmp_server_version(conn, 0, 18, 0) >= 0) { /* MPD 0.18 knows the "volume" command for relative changes */ if (!mpd_run_change_volume(conn, ch.value)) printErrorAndExit(conn); return 1; } #endif struct mpd_status *status = getStatus(conn); int old_volume = mpd_status_get_volume(status); mpd_status_free(status); ch.value += old_volume; if (ch.value < 0) ch.value = 0; else if (ch.value > 100) ch.value = 100; if (ch.value == old_volume) return 1; } if (!mpd_run_set_volume(conn, ch.value)) printErrorAndExit(conn); return 1; }
int getVolume(Config* config, int status) { if(!config->mpd_status) { return -1; } int volume = mpd_status_get_volume(config->mpd_status); return volume; }
void mpd_put_state(void) { struct mpd_status *status; int len; unsigned queue_len; int song_pos, next_song_pos; status = mpd_run_status(mpd.conn); if (!status) { syslog(LOG_ERR, "%s mpd_run_status: %s\n", __func__, mpd_connection_get_error_message(mpd.conn)); mpd.conn_state = MPD_FAILURE; return; } mpd.song_pos = mpd_status_get_song_pos(status); mpd.next_song_pos = song_pos+1; //TODO: mpd_status_get_next_song_pos(status); mpd.queue_len = mpd_status_get_queue_length(status); mpd.volume = mpd_status_get_volume(status); mpd.state = mpd_status_get_state(status); mpd.repeat = mpd_status_get_repeat(status); mpd.single = mpd_status_get_single(status); mpd.consume = mpd_status_get_consume(status); mpd.random = mpd_status_get_random(status); mpd.elapsed_time = mpd_status_get_elapsed_time(status); mpd.total_time = mpd_status_get_total_time(status); mpd.song_id = mpd_status_get_song_id(status); // printf("%d\n", mpd.song_id); mpd_status_free(status); }
int mpd_put_state(char *buffer, int *current_song_id, unsigned *queue_version) { struct mpd_status *status; int len; status = mpd_run_status(mpd.conn); if (!status) { fprintf(stderr, "MPD mpd_run_status: %s\n", mpd_connection_get_error_message(mpd.conn)); mpd.conn_state = MPD_FAILURE; return 0; } len = snprintf(buffer, MAX_SIZE, "{\"type\":\"state\", \"data\":{" " \"state\":%d, \"volume\":%d, \"repeat\":%d," " \"single\":%d, \"consume\":%d, \"random\":%d, " " \"songpos\": %d, \"elapsedTime\": %d, \"totalTime\":%d, " " \"currentsongid\": %d" "}}", mpd_status_get_state(status), mpd_status_get_volume(status), mpd_status_get_repeat(status), mpd_status_get_single(status), mpd_status_get_consume(status), mpd_status_get_random(status), mpd_status_get_song_pos(status), mpd_status_get_elapsed_time(status), mpd_status_get_total_time(status), mpd_status_get_song_id(status)); *current_song_id = mpd_status_get_song_id(status); *queue_version = mpd_status_get_queue_version(status); mpd_status_free(status); return len; }
int mpd_status_set_volume(MpdObj *mi,int volume) { if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } /* making sure volume is between 0 and 100 */ volume = (volume < 0)? 0:(volume>100)? 100:volume; if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } /* send the command */ mpd_sendSetvolCommand(mi->connection , volume); mpd_finishCommand(mi->connection); /* check for errors */ mpd_unlock_conn(mi); /* update status, because we changed it */ mpd_status_queue_update(mi); /* return current volume */ return mpd_status_get_volume(mi); }
int gimmix_get_volume (MpdObj *mo) { int volume; volume = mpd_status_get_volume (mo); return volume; }
int cmd_volume ( int argc, char ** argv, struct mpd_connection *conn ) { struct int_value_change ch; struct mpd_status *status; if(argc==1) { if(!parse_int_value_change(argv[0], &ch)) DIE("\"%s\" is not an integer\n", argv[0]); } else { status = getStatus(conn); if (mpd_status_get_volume(status) >= 0) printf("volume:%3i%c\n", mpd_status_get_volume(status), '%'); else printf("volume: n/a\n"); mpd_status_free(status); return 0; } if (ch.is_relative) { int old_volume; status = getStatus(conn); old_volume = mpd_status_get_volume(status); mpd_status_free(status); ch.value += old_volume; if (ch.value < 0) ch.value = 0; else if (ch.value > 100) ch.value = 100; if (ch.value == old_volume) return 1; } if (!mpd_run_set_volume(conn, ch.value)) printErrorAndExit(conn); return 1; }
static void gimmix_update_volume () { gint volume; GtkAdjustment *volume_adj; volume_adj = gtk_range_get_adjustment (GTK_RANGE(volume_scale)); volume = mpd_status_get_volume (gmo); gtk_adjustment_set_value (GTK_ADJUSTMENT(volume_adj), volume); return; }
void status_changed(MpdObj *mi, ChangedStatusType what) { pthread_mutex_lock(&lockit); mpd_Song *song = mpd_playlist_get_current_song(mi); if(song) { if (song->artist!=NULL) { strncpy(track_info.artist,song->artist,99); } else { track_info.artist[0] = 0; } if (song->title!=NULL) { strncpy(track_info.title,song->title,99); } else { track_info.title[0] = 0; } } if(what&MPD_CST_CROSSFADE){ // printf(GREEN"X-Fade:"RESET" %i sec.\n",mpd_status_get_crossfade(mi)); } if(what&MPD_CST_PLAYLIST) { // printf(GREEN"Playlist changed"RESET"\n"); track_info.totalsongs_in_playlist = mpd_playlist_get_playlist_length(mi); } if(what&MPD_CST_ELAPSED_TIME && !voltimeout){ track_info.elapsed = mpd_status_get_elapsed_song_time(mi); track_info.total = mpd_status_get_total_song_time(mi); } if(what&MPD_CST_VOLUME){ voltimeout=100; track_info.volume = mpd_status_get_volume(mi); } if(what&MPD_CST_STATE) { track_info.playstate = mpd_player_get_state(mi); } track_info.repeat = mpd_player_get_repeat(obj); track_info.random = mpd_player_get_random(obj); pthread_mutex_unlock(&lockit); usleep(10*1000); }
static void volume_set(gpointer data, const char *param) { int cur_volume = mpd_status_get_volume(connection); /* if volume is disabled (current_volume < 0) ignore this command */ if (strlen(param) > 0 && current_volume >= 0) { int volume = 0; if (param[0] == '-' || param[0] == '+') { volume = cur_volume; } volume += atoi(param); mpd_status_set_volume(connection, volume); } }
/** * Mixer event function. * @param conn: mpd connection * @param status: mpd status * @return This function should return MPDCRON_RUN_SUCCESS on success. * This function should return MPDCRON_RUN_RECONNECT to schedule * a reconnection to mpd server. * This function should return MPDCRON_RUN_RECONNECT_NOW to * schedule a reconnection by cancelling to run any of the next * modules in the queue. * This function should return MPDCRON_RUN_UNLOAD when the * module needs to be unloaded. */ int run(G_GNUC_UNUSED const struct mpd_connection *conn, const struct mpd_status *status) { int volume; if (count-- <= 0) return MPDCRON_EVENT_UNLOAD; volume = mpd_status_get_volume(status); if (last_volume < 0) mpdcron_log(LOG_INFO, "Volume set to: %d%%", volume); else mpdcron_log(LOG_INFO, "Volume %s from: %d to: %d%%", (last_volume < volume) ? "increased" : "decreased", last_volume, volume); last_volume = volume; return MPDCRON_EVENT_SUCCESS; }
void Mpd_status::assign_status(struct mpd_status * status) { const struct mpd_audio_format *format; uint32_t ms; volume = mpd_status_get_volume(status); repeat = mpd_status_get_repeat(status); single = mpd_status_get_single(status); random = mpd_status_get_random(status); consume = mpd_status_get_consume(status); playlist_length = mpd_status_get_queue_length(status); playlist = mpd_status_get_queue_version(status); state = mpd_status_get_state(status); crossfade = mpd_status_get_crossfade(status); song = mpd_status_get_song_pos(status); songid = mpd_status_get_song_id(status); time_total = mpd_status_get_total_time(status); db_updating = mpd_status_get_update_id(status); /* Time elapsed */ #if LIBMPDCLIENT_CHECK_VERSION(2, 1, 0) ms = mpd_status_get_elapsed_ms(status); #else ms = mpd_status_get_elapsed(status) * 1000; #endif set_time_elapsed_ms(ms); /* Audio format */ bitrate = mpd_status_get_kbit_rate(status); format = mpd_status_get_audio_format(status); if (!format) { return; } samplerate = format->sample_rate; bits = format->bits; channels = format->channels; }
static int lmpdstatus_index(lua_State *L) { const char *key; const struct mpd_audio_format *audio_format; struct mpd_status **status; status = luaL_checkudata(L, 1, MPD_STATUS_T); key = luaL_checkstring(L, 2); assert(*status != NULL); if (strncmp(key, "volume", 7) == 0) { lua_pushinteger(L, mpd_status_get_volume(*status)); return 1; } else if (strncmp(key, "repeat", 7) == 0) { lua_pushinteger(L, mpd_status_get_repeat(*status)); return 1; } else if (strncmp(key, "random", 7) == 0) { lua_pushinteger(L, mpd_status_get_random(*status)); return 1; } else if (strncmp(key, "single", 7) == 0) { lua_pushinteger(L, mpd_status_get_single(*status)); return 1; } else if (strncmp(key, "consume", 8) == 0) { lua_pushinteger(L, mpd_status_get_consume(*status)); return 1; } else if (strncmp(key, "queue_length", 16) == 0) { lua_pushnumber(L, mpd_status_get_queue_length(*status)); return 1; } else if (strncmp(key, "queue_version", 17) == 0) { lua_pushnumber(L, mpd_status_get_queue_version(*status)); return 1; } else if (strncmp(key, "state", 6) == 0) { lua_pushinteger(L, mpd_status_get_state(*status)); return 1; } else if (strncmp(key, "crossfade", 10) == 0) { lua_pushinteger(L, mpd_status_get_crossfade(*status)); return 1; } else if (strncmp(key, "song_pos", 5) == 0) { lua_pushinteger(L, mpd_status_get_song_pos(*status)); return 1; } else if (strncmp(key, "song_id", 7) == 0) { lua_pushinteger(L, mpd_status_get_song_id(*status)); return 1; } else if (strncmp(key, "elapsed_time", 13) == 0) { lua_pushinteger(L, mpd_status_get_elapsed_time(*status)); return 1; } else if (strncmp(key, "total_time", 11) == 0) { lua_pushinteger(L, mpd_status_get_total_time(*status)); return 1; } else if (strncmp(key, "kbit_rate", 10) == 0) { lua_pushinteger(L, mpd_status_get_kbit_rate(*status)); return 1; } else if (strncmp(key, "audio_format", 13) == 0) { audio_format = mpd_status_get_audio_format(*status); lua_newtable(L); lua_pushinteger(L, audio_format->sample_rate); lua_setfield(L, -2, "sample_rate"); lua_pushinteger(L, audio_format->bits); lua_setfield(L, -2, "bits"); lua_pushinteger(L, audio_format->channels); lua_setfield(L, -2, "channels"); return 1; } else if (strncmp(key, "update_id", 11) == 0) { lua_pushinteger(L, mpd_status_get_update_id(*status)); return 1; } else if (strncmp(key, "error", 6) == 0) { lua_pushstring(L, mpd_status_get_error(*status)); return 1; } else return luaL_error(L, "Invalid key `%s'", key); }
void *Lkeys_thread() { int keystate = 0; int volume; struct pollfd fds; char ver[5]; strncpy(ver,G15DAEMON_VERSION,3); float g15v; sscanf(ver,"%f",&g15v); fds.fd = g15screen_fd; fds.events = POLLIN; while(!leaving){ int foo=0; current_fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo); static int last_fg_check = 0; if(playlist_mode && last_fg_check != current_fg_check){ if(own_keyboard){ if(current_fg_check==0){ own_keyboard=0; } }else if(current_fg_check && !own_keyboard) { own_keyboard=1; } last_fg_check = current_fg_check; } /* g15daemon series 1.2 need key request packets */ pthread_mutex_lock(&daemon_mutex); if((g15v*10)<=18) { keystate = g15_send_cmd (g15screen_fd, G15DAEMON_GET_KEYSTATE, foo); } else { if ((poll(&fds, 1, 5)) > 0) read (g15screen_fd, &keystate, sizeof (keystate)); } pthread_mutex_unlock(&daemon_mutex); if (keystate) { switch (keystate) { case G15_KEY_L1: exit(1); // FIXME quick hack to exit break; case G15_KEY_L2: menulevel++; if(menulevel>=MAX_MENU_MODES) menulevel=0; break; case G15_KEY_L3: if(!own_keyboard){ own_keyboard=playlist_mode=1; mpd_Song *song = mpd_playlist_get_current_song(obj); if(song) if(song->pos) track_info.currentsong=song->pos; }else{ //de-activate own_keyboard=playlist_mode=0; } break; case G15_KEY_L4: if(menulevel==MENU_MODE1){ mpd_player_set_random(obj,mpd_player_get_random(obj)^1); } if(menulevel==MENU_MODE2){ volume=mpd_status_get_volume(obj); if(volume>0) volume-=10; mpd_status_set_volume (obj,volume); } break; case G15_KEY_L5: if(menulevel==MENU_MODE1){ mpd_player_set_repeat(obj, mpd_player_get_repeat(obj)^1); } if(menulevel==MENU_MODE2){ volume=mpd_status_get_volume(obj); if(volume<100) volume+=10; mpd_status_set_volume (obj,volume); } break; default: break; } keystate = 0; } usleep(100*1000); } return NULL; }
int main(int argc, char **argv) { int fdstdin = 0; pthread_t Lkeys; pthread_t g15display; pthread_t EKeys; int volume; int volume_new; char devname[256] = "Unknown"; int iport = 6600; char *hostname = getenv("MPD_HOST"); char *port = getenv("MPD_PORT"); char *password = getenv("MPD_PASSWORD"); int eventdev; char evdev_name[128]; pthread_mutex_init(&lockit,NULL); pthread_mutex_init(&daemon_mutex,NULL); int i; for (i=0;i<argc;i++) { char argument[20]; memset(argument,0,20); strncpy(argument,argv[i],19); if (!strncmp(argument, "-q",2) || !strncmp(argument, "--quickscroll",13)) { quickscroll=1; } if (!strncmp(argument, "-h",2) || !strncmp(argument, "--help",6)) { printf(" %s version %s\n (c)2006-2007 Mike Lampard\n\n",argv[0],VERSION); printf("%s -q or --quickscroll Use volume control to scroll through the playlist\n",argv[0]); printf("%s -v or --version Show program version\n",argv[0]); printf("%s -h or --help This help text\n\n",argv[0]); exit(0); } if (!strncmp(argument, "-v",2) || !strncmp(argument, "--version",9)) { printf("%s version %s\n",argv[0],VERSION); exit(0); } } for(eventdev=0;eventdev<127;eventdev++) { snprintf(evdev_name,127,"/dev/input/event%i",eventdev); if ((mmedia_fd = open(evdev_name, O_NONBLOCK|O_RDONLY)) < 0) { // ignore errors when opening devices //printf("error opening interface %i\n",eventdev); } else { ioctl(mmedia_fd, EVIOCGNAME(sizeof(devname)), devname); printf("Device Name %s on %s\n", devname, evdev_name); if(0==strncmp(devname,"Logitech Logitech Gaming Keyboard",256)){ printf("Found device: \"%s\" on %s ", devname,evdev_name); break; } else if(0==strncmp(devname,"G15 Gaming Keyboard",256)){ printf("Found device: \"%s\" on %s ", devname,evdev_name); break; }else close(mmedia_fd); } } if (mmedia_fd) { // we assume that the next event device is the multimedia keys close(mmedia_fd); snprintf(evdev_name,127,"/dev/input/event%i",++eventdev); printf("and %s\n",evdev_name); if ((mmedia_fd = open(evdev_name, O_NONBLOCK|O_RDONLY)) < 0) { printf("error opening interface %i",eventdev); } }else { printf("Unable to find Keyboard via EVENT interface... is /dev/input/event[0-9] readable??\n"); } /* set correct hostname */ if(!hostname) { hostname = "localhost"; } if(port){ iport = atoi(port); } if((g15screen_fd = new_g15_screen(G15_G15RBUF))<0){ printf("Sorry, cant connect to the G15daemon\n"); return 1; } canvas = (g15canvas *) malloc (sizeof (g15canvas)); if (canvas != NULL) { memset(canvas->buffer, 0, G15_BUFFER_LEN); canvas->mode_cache = 0; canvas->mode_reverse = 0; canvas->mode_xor = 0; } /* Create mpd object */ obj = mpd_new(hostname, iport,password); /* Connect signals */ mpd_signal_connect_error(obj,(ErrorCallback)error_callback, NULL); mpd_signal_connect_status_changed(obj,(StatusChangedCallback)status_changed, NULL); /* Set timeout */ mpd_set_connection_timeout(obj, 10); if(0==mpd_connect(obj)) { char buffer[20]; pthread_attr_t attr; mpd_send_password(obj); memset(buffer, '\0', 20); pthread_attr_init(&attr); pthread_attr_setstacksize(&attr,32*1024); /* set stack to 64k - dont need 8Mb !! */ pthread_create(&Lkeys, &attr, Lkeys_thread, NULL); pthread_create(&EKeys, &attr,event_key_thread, NULL); pthread_create(&g15display, &attr, g15display_thread, NULL); do{ pthread_mutex_lock(&daemon_mutex); if(voltimeout) --voltimeout; if(mute){ volume_adjust = 0; mute = 0; if (muted_volume == 0) { //printf("mute\n"); muted_volume = mpd_status_get_volume(obj); mpd_status_set_volume (obj,0); } else { //printf("unmute\n"); if (mpd_status_get_volume(obj) == 0) { /* if no other client has set volume up */ mpd_status_set_volume (obj,muted_volume); } muted_volume = 0; } } if(volume_adjust != 0){ if (muted_volume != 0) { volume=muted_volume; } else { volume=mpd_status_get_volume(obj); } volume_new = volume + volume_adjust; volume_adjust = 0; if(volume_new < 0) volume_new = 0; if(volume_new > 100) volume_new = 100; if(volume != volume_new || muted_volume){ //printf("volume %d -> %d\n", volume, volume_new); mpd_status_set_volume (obj,volume_new); } voltimeout=100; muted_volume=0; } mpd_status_update(obj); pthread_mutex_unlock(&daemon_mutex); }while(!usleep(5000) && !leaving); leaving = 1; pthread_join(Lkeys,NULL); pthread_join(g15display,NULL); }else printf("Unable to connect to MPD server. Exiting\n"); if(obj) mpd_free(obj); close(fdstdin); if(canvas!=NULL) free(canvas); close(g15screen_fd); close(mmedia_fd); pthread_mutex_destroy(&lockit); return 1; }
void gimmix_init (void) { GtkWidget *widget; GtkWidget *progressbox; GtkAdjustment *vol_adj; GdkPixbuf *app_icon; gchar *path; /* Set the application icon */ main_window = glade_xml_get_widget (xml, "main_window"); g_signal_connect (G_OBJECT(main_window), "delete-event", G_CALLBACK(cb_gimmix_main_window_delete_event), NULL); gtk_window_set_default_size (GTK_WINDOW(main_window), -1, 80); gtk_window_resize (GTK_WINDOW(main_window), atoi(cfg_get_key_value(conf, "window_width")), atoi(cfg_get_key_value(conf, "window_height"))); gtk_window_move (GTK_WINDOW(main_window), atoi(cfg_get_key_value(conf, "window_xpos")), atoi(cfg_get_key_value(conf, "window_ypos"))); path = gimmix_get_full_image_path (GIMMIX_APP_ICON); app_icon = gdk_pixbuf_new_from_file_at_size (path, 48, 48, NULL); gtk_window_set_icon (GTK_WINDOW(main_window), app_icon); g_object_unref (app_icon); g_free (path); /* connect the key press signal */ g_signal_connect (G_OBJECT(main_window), "key-press-event", G_CALLBACK(cb_gimmix_key_press), NULL); g_signal_connect (G_OBJECT(main_window), "configure-event", G_CALLBACK(cb_gimmix_main_window_configure_event), (gpointer)glade_xml_get_widget(xml, "volume_window")); /* connect the destroy signal */ g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(gtk_main_quit), NULL); /* set icons for buttons */ gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_prev")), "gtk-media-previous", GTK_ICON_SIZE_BUTTON); gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_play")), "gtk-media-play", GTK_ICON_SIZE_BUTTON); gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_next")), "gtk-media-next", GTK_ICON_SIZE_BUTTON); gtk_image_set_from_stock (GTK_IMAGE(glade_xml_get_widget(xml, "image_stop")), "gtk-media-stop", GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "prev_button")), "clicked", G_CALLBACK(cb_prev_button_clicked), NULL); g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "play_button")), "clicked", G_CALLBACK(cb_play_button_clicked), NULL); g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "next_button")), "clicked", G_CALLBACK(cb_next_button_clicked), NULL); g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "stop_button")), "clicked", G_CALLBACK(cb_stop_button_clicked), NULL); g_signal_connect (G_OBJECT(glade_xml_get_widget (xml, "pref_button")), "clicked", G_CALLBACK(cb_pref_button_clicked), NULL); shuffle_toggle_button = glade_xml_get_widget (xml, "shuffle_toggle"); repeat_toggle_button = glade_xml_get_widget (xml, "repeat_toggle"); volume_window = glade_xml_get_widget (xml, "volume_window"); volume_scale = glade_xml_get_widget (xml, "volume_scale"); volume_button = glade_xml_get_widget (xml, "volume_button"); playlist_button = glade_xml_get_widget (xml, "playlist_button"); playlist_box = glade_xml_get_widget (xml, "playlistbox"); song_label = glade_xml_get_widget (xml, "song_label"); artist_label = glade_xml_get_widget (xml, "artist_label"); search_entry = glade_xml_get_widget (xml, "search_label"); play_button = glade_xml_get_widget (xml, "play_button"); image_play = glade_xml_get_widget (xml, "image_play"); g_signal_connect (G_OBJECT(playlist_button), "button-press-event", G_CALLBACK(cb_playlist_button_press), NULL); if (is_gimmix_repeat (gmo)) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(repeat_toggle_button), TRUE); g_signal_connect (G_OBJECT(repeat_toggle_button), "toggled", G_CALLBACK(cb_repeat_button_toggled), NULL); if (is_gimmix_shuffle (gmo)) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(shuffle_toggle_button), TRUE); g_signal_connect (G_OBJECT(shuffle_toggle_button), "toggled", G_CALLBACK(cb_shuffle_button_toggled), NULL); widget = glade_xml_get_widget (xml, "info_button"); g_signal_connect (G_OBJECT(widget), "button-release-event", G_CALLBACK(cb_info_button_press), NULL); g_signal_connect (G_OBJECT(volume_scale), "value_changed", G_CALLBACK(cb_volume_scale_changed), NULL); g_signal_connect (G_OBJECT(volume_scale), "scroll_event", G_CALLBACK(cb_volume_slider_scroll), NULL); vol_adj = gtk_range_get_adjustment (GTK_RANGE(volume_scale)); gtk_adjustment_set_value (GTK_ADJUSTMENT(vol_adj), mpd_status_get_volume (gmo)); g_signal_connect (G_OBJECT(volume_button), "clicked", G_CALLBACK(cb_volume_button_clicked), volume_window); g_signal_connect (G_OBJECT(volume_button), "scroll_event", G_CALLBACK(cb_volume_slider_scroll), NULL); progress = glade_xml_get_widget (xml,"progress"); progressbox = glade_xml_get_widget (xml,"progress_event_box"); g_signal_connect (G_OBJECT(progressbox), "button_press_event", G_CALLBACK(cb_gimmix_progress_seek), NULL); play_button_tooltip = gtk_tooltips_new (); if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0) { gimmix_create_systray_icon (); } if (strncasecmp(cfg_get_key_value(conf, "full_view_mode"), "true", 4) == 0) { gtk_widget_show (playlist_box); gtk_window_set_resizable (GTK_WINDOW(main_window), TRUE); } else { gtk_widget_hide (playlist_box); gtk_window_set_resizable (GTK_WINDOW(main_window), FALSE); } mpd_status_update (gmo); status = mpd_player_get_state (gmo); if (status == MPD_PLAYER_PLAY) { gimmix_set_song_info (); status = -1; gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-pause", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Pause <x or c>"), NULL); } else if (status == MPD_PLAYER_PAUSE) { gimmix_set_song_info (); } else if (status == MPD_PLAYER_STOP) { gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), _("Stopped")); if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0) gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), _("Stopped")); gimmix_show_ver_info (); } g_timeout_add (300, (GSourceFunc)gimmix_timer, NULL); /* connect the main mpd callbacks */ mpd_signal_connect_status_changed (gmo, (StatusChangedCallback)gimmix_status_changed, NULL); mpd_signal_connect_error (gmo, (ErrorCallback)gimmix_mpd_error, NULL); /* initialize playlist and tag editor */ gimmix_playlist_init (); gimmix_tag_editor_init (); gimmix_update_current_playlist (); /* initialize preferences dialog */ gimmix_prefs_init (); g_object_unref (xml); /* show the main window */ gtk_widget_show (main_window); /* check if library needs to be updated on startup */ if (strncasecmp(cfg_get_key_value(conf, "update_on_startup"), "true", 4) == 0) gimmix_library_update (); return; }
static void env_export_status(struct mpd_status *status) { char *envstr; const struct mpd_audio_format *fmt; envstr = g_strdup_printf("%d", mpd_status_get_volume(status)); g_setenv("MPD_STATUS_VOLUME", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_repeat(status)); g_setenv("MPD_STATUS_REPEAT", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_random(status)); g_setenv("MPD_STATUS_RANDOM", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_single(status)); g_setenv("MPD_STATUS_SINGLE", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_consume(status)); g_setenv("MPD_STATUS_CONSUME", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_queue_length(status)); g_setenv("MPD_STATUS_QUEUE_LENGTH", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_queue_version(status)); g_setenv("MPD_STATUS_QUEUE_VERSION", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_crossfade(status)); g_setenv("MPD_STATUS_CROSSFADE", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_song_pos(status)); g_setenv("MPD_STATUS_SONG_POS", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%d", mpd_status_get_song_id(status)); g_setenv("MPD_STATUS_SONG_ID", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", mpd_status_get_elapsed_time(status)); g_setenv("MPD_STATUS_ELAPSED_TIME", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", mpd_status_get_elapsed_ms(status)); g_setenv("MPD_STATUS_ELAPSED_MS", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", mpd_status_get_total_time(status)); g_setenv("MPD_STATUS_TOTAL_TIME", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", mpd_status_get_kbit_rate(status)); g_setenv("MPD_STATUS_KBIT_RATE", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", mpd_status_get_update_id(status)); g_setenv("MPD_STATUS_UPDATE_ID", envstr, 1); g_free(envstr); g_setenv("MPD_STATUS_STATE", env_strstate(mpd_status_get_state(status)), 1); if ((fmt = mpd_status_get_audio_format(status)) == NULL) g_setenv("MPD_STATUS_AUDIO_FORMAT", "0", 1); else { g_setenv("MPD_STATUS_AUDIO_FORMAT", "1", 1); envstr = g_strdup_printf("%u", fmt->sample_rate); g_setenv("MPD_STATUS_AUDIO_FORMAT_SAMPLE_RATE", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", fmt->bits); g_setenv("MPD_STATUS_AUDIO_FORMAT_BITS", envstr, 1); g_free(envstr); envstr = g_strdup_printf("%u", fmt->channels); g_setenv("MPD_STATUS_AUDIO_FORMAT_CHANNELS", envstr, 1); g_free(envstr); } }
void updatempdstatus(void) { char statustext[STEXTSIZE]; struct mpd_status *s = NULL; struct mpd_song *so = NULL; int s_volume, s_flagmask, s_queuelength, s_songpos, s_state, s_songlen, s_songtime; int s_time_r, s_time_min, s_time_sec; const char *artist, *title; if(mpdcmd_connect() != 0) return; s = mpd_run_status(mpdc); if(s == NULL) return; // retrieve status information if((s_state = mpd_status_get_state(s)) == MPD_STATE_STOP || (so = mpd_run_current_song(mpdc)) == NULL) goto EXIT; s_volume = mpd_status_get_volume(s); s_queuelength = mpd_status_get_queue_length(s); s_songpos = mpd_status_get_song_pos(s); s_songlen = mpd_status_get_total_time(s); s_songtime = mpd_status_get_elapsed_time(s); s_time_r = s_songlen - s_songtime; s_time_sec = s_time_r % 60; s_time_min = (s_time_r - s_time_sec) / 60; if(mpd_status_get_consume(s) == 1) s_flagmask |= MpdFlag_Consume; if(mpd_status_get_single(s) == 1) s_flagmask |= MpdFlag_Single; if(mpd_status_get_random(s) == 1) s_flagmask |= MpdFlag_Random; if(mpd_status_get_repeat(s) == 1) s_flagmask |= MpdFlag_Repeat; artist = mpd_song_get_tag(so, MPD_TAG_ARTIST, 0); title = mpd_song_get_tag(so, MPD_TAG_TITLE, 0); //%artist - %title (-%total-%elapsed) [$flags] [#%pos/%queuelength] snprintf(statustext, STEXTSIZE, "%s - %s (-%d:%02d)", artist != NULL ? artist : "名無し", title != NULL ? title : "曲名無し", s_time_min, s_time_sec); strncpy(stext, statustext, STEXTSIZE); EXIT:; mpd_song_free(so); mpd_status_free(s); return; }
int main(int argc, char ** argv) { struct mpd_connection *conn; conn = mpd_connection_new(NULL, 0, 30000); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) return handle_error(conn); { int i; for(i=0;i<3;i++) { printf("version[%i]: %i\n",i, mpd_connection_get_server_version(conn)[i]); } } if(argc==1) { struct mpd_status * status; struct mpd_song *song; const struct mpd_audio_format *audio_format; mpd_command_list_begin(conn, true); mpd_send_status(conn); mpd_send_current_song(conn); mpd_command_list_end(conn); status = mpd_recv_status(conn); if (status == NULL) return handle_error(conn); printf("volume: %i\n", mpd_status_get_volume(status)); printf("repeat: %i\n", mpd_status_get_repeat(status)); printf("queue version: %u\n", mpd_status_get_queue_version(status)); printf("queue length: %i\n", mpd_status_get_queue_length(status)); if (mpd_status_get_error(status) != NULL) printf("error: %s\n", mpd_status_get_error(status)); if (mpd_status_get_state(status) == MPD_STATE_PLAY || mpd_status_get_state(status) == MPD_STATE_PAUSE) { printf("song: %i\n", mpd_status_get_song_pos(status)); printf("elaspedTime: %i\n",mpd_status_get_elapsed_time(status)); printf("elasped_ms: %u\n", mpd_status_get_elapsed_ms(status)); printf("totalTime: %i\n", mpd_status_get_total_time(status)); printf("bitRate: %i\n", mpd_status_get_kbit_rate(status)); } audio_format = mpd_status_get_audio_format(status); if (audio_format != NULL) { printf("sampleRate: %i\n", audio_format->sample_rate); printf("bits: %i\n", audio_format->bits); printf("channels: %i\n", audio_format->channels); } mpd_status_free(status); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) return handle_error(conn); mpd_response_next(conn); while ((song = mpd_recv_song(conn)) != NULL) { printf("uri: %s\n", mpd_song_get_uri(song)); print_tag(song, MPD_TAG_ARTIST, "artist"); print_tag(song, MPD_TAG_ALBUM, "album"); print_tag(song, MPD_TAG_TITLE, "title"); print_tag(song, MPD_TAG_TRACK, "track"); print_tag(song, MPD_TAG_NAME, "name"); print_tag(song, MPD_TAG_DATE, "date"); if (mpd_song_get_duration(song) > 0) { printf("time: %u\n", mpd_song_get_duration(song)); } printf("pos: %u\n", mpd_song_get_pos(song)); mpd_song_free(song); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if(argc==3 && strcmp(argv[1],"lsinfo")==0) { struct mpd_entity * entity; if (!mpd_send_list_meta(conn, argv[2])) return handle_error(conn); while ((entity = mpd_recv_entity(conn)) != NULL) { const struct mpd_song *song; const struct mpd_directory *dir; const struct mpd_playlist *pl; switch (mpd_entity_get_type(entity)) { case MPD_ENTITY_TYPE_UNKNOWN: break; case MPD_ENTITY_TYPE_SONG: song = mpd_entity_get_song(entity); printf("uri: %s\n", mpd_song_get_uri(song)); print_tag(song, MPD_TAG_ARTIST, "artist"); print_tag(song, MPD_TAG_ALBUM, "album"); print_tag(song, MPD_TAG_TITLE, "title"); print_tag(song, MPD_TAG_TRACK, "track"); break; case MPD_ENTITY_TYPE_DIRECTORY: dir = mpd_entity_get_directory(entity); printf("directory: %s\n", mpd_directory_get_path(dir)); break; case MPD_ENTITY_TYPE_PLAYLIST: pl = mpd_entity_get_playlist(entity); printf("playlist: %s\n", mpd_playlist_get_path(pl)); break; } mpd_entity_free(entity); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if(argc==2 && strcmp(argv[1],"artists")==0) { struct mpd_pair *pair; if (!mpd_search_db_tags(conn, MPD_TAG_ARTIST) || !mpd_search_commit(conn)) return handle_error(conn); while ((pair = mpd_recv_pair_tag(conn, MPD_TAG_ARTIST)) != NULL) { printf("%s\n", pair->value); mpd_return_pair(conn, pair); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if (argc == 2 && strcmp(argv[1], "playlists") == 0) { if (!mpd_send_list_playlists(conn)) return handle_error(conn); struct mpd_playlist *playlist; while ((playlist = mpd_recv_playlist(conn)) != NULL) { printf("%s\n", mpd_playlist_get_path(playlist)); mpd_playlist_free(playlist); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if (argc == 2 && strcmp(argv[1], "idle") == 0) { enum mpd_idle idle = mpd_run_idle(conn); if (idle == 0 && mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) return handle_error(conn); for (unsigned j = 0;; ++j) { enum mpd_idle i = 1 << j; const char *name = mpd_idle_name(i); if (name == NULL) break; if (idle & i) printf("%s\n", name); } } else if (argc == 3 && strcmp(argv[1], "subscribe") == 0) { /* subscribe to a channel and print all messages */ if (!mpd_run_subscribe(conn, argv[2])) return handle_error(conn); while (mpd_run_idle_mask(conn, MPD_IDLE_MESSAGE) != 0) { if (!mpd_send_read_messages(conn)) return handle_error(conn); struct mpd_message *msg; while ((msg = mpd_recv_message(conn)) != NULL) { printf("%s\n", mpd_message_get_text(msg)); mpd_message_free(msg); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } return handle_error(conn); } else if (argc == 2 && strcmp(argv[1], "channels") == 0) { /* print a list of channels */ if (!mpd_send_channels(conn)) return handle_error(conn); struct mpd_pair *pair; while ((pair = mpd_recv_channel_pair(conn)) != NULL) { printf("%s\n", pair->value); mpd_return_pair(conn, pair); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if (argc == 4 && strcmp(argv[1], "message") == 0) { /* send a message to a channel */ if (!mpd_run_send_message(conn, argv[2], argv[3])) return handle_error(conn); } mpd_connection_free(conn); return 0; }
int main(int argc, char const *argv[]) { if (argc < 5) { printf("Usage: evmpd HOSTNAME PORT DEVICE HALT_COMMAND\n"); return EXIT_FAILURE; } struct mpd_connection *client = connect(argv[1], strtol(argv[2], NULL, 10)); struct libevdev *dev = NULL; int fd; int rc = 1; fd = open(argv[3], O_RDONLY | O_NONBLOCK); rc = libevdev_new_from_fd(fd, &dev); if (rc < 0) { fprintf(stderr, "Failed to init libevdev (%d)\n", strerror(-rc)); return EXIT_FAILURE; } printf("Input device name: \"%s\"\n", libevdev_get_name(dev)); printf("Input device ID: bus %#x vendor %#x product %#x\n", libevdev_get_id_bustype(dev), libevdev_get_id_vendor(dev), libevdev_get_id_product(dev)); do { struct input_event ev; rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev); if (rc == 0 && ev.value == 0) { if (libevdev_event_is_code(&ev, EV_KEY, KEY_F4)) { system(argv[4]); printf("shutdown\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PLAYPAUSE)) { struct mpd_status *status = mpd_run_status(client); enum mpd_state state = mpd_status_get_state(status); if (state != MPD_STATE_PLAY && state != MPD_STATE_PAUSE) { mpd_run_play(client); printf("play\n"); } else { mpd_run_toggle_pause(client); printf("toggle-pause\n"); } } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_STOPCD)) { mpd_run_stop(client); printf("stop\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PREVIOUSSONG)) { mpd_run_previous(client); printf("previous\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_NEXTSONG)) { mpd_run_next(client); printf("next\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEUP)) { struct mpd_status *status = mpd_run_status(client); int volume = mpd_status_get_volume(status); volume += 5; if (volume > 100) { volume = 100; } mpd_run_set_volume(client, volume); printf("set-volume %d\n", volume); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEDOWN)) { struct mpd_status *status = mpd_run_status(client); int volume = mpd_status_get_volume(status); volume -= 5; if (volume < 0) { volume = 0; } mpd_run_set_volume(client, volume); printf("set-volume %d\n", volume); } else { printf("Event: %s %s %d\n", libevdev_event_type_get_name(ev.type), libevdev_event_code_get_name(ev.type, ev.code), ev.value); } } } while (rc == LIBEVDEV_READ_STATUS_SUCCESS || rc == LIBEVDEV_READ_STATUS_SYNC || rc == -EAGAIN); printf("rc: %d\n", rc); if (client != NULL) { mpd_connection_free(client); } return EXIT_SUCCESS; }
void mpd_query_status(struct mpd_connection *conn) { struct mpd_status *status; struct mpd_song *song; const struct mpd_audio_format *audio; if (!conn) return; if (!mpd_command_list_begin(conn, true) || !mpd_send_status(conn) || !mpd_send_current_song(conn) || !mpd_command_list_end(conn)) { mpd_printerror("queue_commands"); return; } status = mpd_recv_status(conn); if (status == NULL) { mpd_printerror("recv_status"); return; } if (currentSong != NULL) { mpd_song_free(currentSong); currentSong = NULL; } if (!mpd_response_next(conn)) { mpd_printerror("response_next"); return; } song = mpd_recv_song(conn); if (song != NULL) { currentSong = mpd_song_dup(song); mpd_song_free(song); l_elapsedTimeSec = mpd_status_get_elapsed_time(status); l_totalTimeSec = mpd_status_get_total_time(status); l_bitRate = mpd_status_get_kbit_rate(status); } else { l_elapsedTimeSec = 0; l_totalTimeSec = 0; l_bitRate = 0; } l_state = mpd_status_get_state(status); l_repeatEnabled = mpd_status_get_repeat(status); l_randomEnabled = mpd_status_get_random(status); l_singleEnabled = mpd_status_get_single(status); l_consumeEnabled = mpd_status_get_consume(status); l_volume = mpd_status_get_volume(status); l_currentSongPos = mpd_status_get_song_pos(status) + 1; l_playlistLength = mpd_status_get_queue_length(status); audio = mpd_status_get_audio_format(status); if (audio) { l_sampleRate = audio->sample_rate; l_channels = audio->channels; } else { l_sampleRate = 0; l_channels = 0; } if (mpd_status_get_error(status) != NULL) error("[MPD] query status : %s", charset_from_utf8(mpd_status_get_error(status))); mpd_status_free(status); if (!mpd_response_finish(conn)) { mpd_printerror("response_finish"); return; } }
void control_window_status_update(MpdObj * mi, ChangedStatusType what, GtkWidget *base) { GtkWidget *volume_button, *progress, *play_image; /* Bail out of base == NULL */ if(base == NULL) return; /* Get the different subwidgets from the parent */ volume_button = g_object_get_data(G_OBJECT(base), "vol"); progress = g_object_get_data(G_OBJECT(base), "progress"); play_image = g_object_get_data(G_OBJECT(base), "play_image"); if (what & MPD_CST_STATE) { int state = mpd_player_get_state(mi); switch (state) { case MPD_PLAYER_PLAY: gtk_image_set_from_stock(GTK_IMAGE(play_image), "gtk-media-pause", GTK_ICON_SIZE_BUTTON); break; case MPD_PLAYER_PAUSE: gtk_image_set_from_stock(GTK_IMAGE(play_image), "gtk-media-play", GTK_ICON_SIZE_BUTTON); break; default: gtk_image_set_from_stock(GTK_IMAGE(play_image), "gtk-media-play", GTK_ICON_SIZE_BUTTON); /* Make sure it's reset correctly */ gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0); } } if (what & MPD_CST_ELAPSED_TIME) { if (mpd_check_connected(connection)) { int totalTime = mpd_status_get_total_song_time(connection); int elapsedTime = mpd_status_get_elapsed_song_time(connection); gmpc_progress_set_time(GMPC_PROGRESS(progress), totalTime, elapsedTime); } else { gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0); } } if (what & MPD_CST_VOLUME) { int volume = gtk_scale_button_get_value(GTK_SCALE_BUTTON(volume_button))*100; int new_volume = mpd_status_get_volume(connection); if (new_volume >= 0 && mpd_server_check_command_allowed(connection, "setvol") == MPD_SERVER_COMMAND_ALLOWED ) { gtk_widget_set_sensitive(volume_button, TRUE); /* don't do anything if nothing is changed */ if (new_volume != volume) { gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_button), new_volume/100.0); } } else { gtk_widget_set_sensitive(volume_button, FALSE); } } }
/* * Returns: 0 - error; 1 - ok */ int mgr_mpd_fetch_status( struct mpd_connection *conn, int dump_status ) { struct mpd_status *status; struct mpd_stats *stats; if (DEBUG > 1) fprintf(stderr, "DEBUG: [mgr-thread] mpd: -status fetching...\n"); if (conn == NULL) { fprintf(stderr, "ERROR: MPD: Unable to retrieve the MPD status: not connected\n"); return 0; } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { fprintf(stderr, "ERROR: MPD: Unable to retrieve MPD status: connection error\n"); return 0; } if (DEBUG > 1) fprintf(stderr, "DEBUG: [mgr-thread] mpd: run status\n"); status = mpd_run_status(conn); if (!status) { fprintf(stderr, "ERROR: MPD: Unable to retrieve MPD status\n"); return 0; } cur_mpd_player_status = mpd_status_get_state(status); if (DEBUG > 1) { fprintf(stderr, "DEBUG: [mgr-thread] mpd: +status received:\n"); } if (DEBUG && dump_status) { fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => mode : %s\n", (cur_mpd_player_status == MPD_STATE_PLAY ? "Play" : "Other")); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => random : %d\n", mpd_status_get_random(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => repeat : %d\n", mpd_status_get_random(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => volume : %d\n", mpd_status_get_volume(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => queue ver : %d\n", mpd_status_get_queue_version(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => queue len : %d\n", mpd_status_get_queue_length(status)); } cur_mpd_random = mpd_status_get_random(status) ? 1 : 0; cur_mpd_volume = mpd_status_get_volume(status); cur_mpd_status_queue_len = mpd_status_get_queue_length(status); if (DEBUG > 1) fprintf(stderr, "DEBUG: [mgr-thread] mpd: release status\n"); if (mpd_status_get_error(status) != NULL) { fprintf(stderr, "WARNING: MPD: Error Received from MPD: %s\n", mpd_status_get_error(status)); // TODO - clear error } mpd_status_free(status); mpd_response_finish(conn); stats = mpd_run_stats(conn); if (stats == NULL) { fprintf(stderr, "ERROR: MPD: Unable to retrieve MPD statistics\n"); return 0; } cur_mpd_stats_number_of_songs = mpd_stats_get_number_of_songs( stats ); if (DEBUG && dump_status) { fprintf(stderr, "DEBUG: [mgr-thread] mpd stats : => # of songs: %d\n", cur_mpd_stats_number_of_songs); } mpd_stats_free( stats ); return 1; }
/** * Constructor */ GtkWidget *create_control_window(GtkWidget *parent) { GtkWidget *pp_button, *next_button, *prev_button, *ff_button; GtkWidget *vol, *progress, *hbox, *play_image; int new_volume; /* Create window */ GtkWidget *base = gtk_event_box_new(); GtkWidget *ali = gtk_alignment_new(0.5,0,0.6,1); g_signal_connect(G_OBJECT(base), "enter-notify-event" , G_CALLBACK(control_window_enter_notify_event), NULL); g_signal_connect(G_OBJECT(base), "leave-notify-event" , G_CALLBACK(control_window_leave_notify_event), NULL); /* Overwrite background drawing */ gtk_widget_set_app_paintable(base, TRUE); g_signal_connect(G_OBJECT(base), "draw", G_CALLBACK(expose_window), NULL); hbox = gtk_hbox_new(FALSE, 6); g_object_set_data(G_OBJECT(base), "hbox" , hbox); gtk_container_add(GTK_CONTAINER(base), ali); gtk_container_add(GTK_CONTAINER(ali), hbox); gtk_container_set_border_width(GTK_CONTAINER(ali), 1); /* Previous button */ ff_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(ff_button), gtk_image_new_from_stock(GTK_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief(GTK_BUTTON(ff_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), ff_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(ff_button), "clicked", G_CALLBACK(control_window_leave_fullscreen), parent); /* Volume button */ vol = (GtkWidget *)gtk_volume_button_new(); gtk_box_pack_end(GTK_BOX(hbox), vol, FALSE, FALSE, 0); new_volume = mpd_status_get_volume(connection); gtk_scale_button_set_value(GTK_SCALE_BUTTON(vol), new_volume/100.0); g_object_set_data(G_OBJECT(base), "vol", vol); g_signal_connect(G_OBJECT(vol), "value_changed", G_CALLBACK(playlist_player_volume_changed), NULL); /* Progress */ progress = (GtkWidget *)gmpc_progress_new(); gmpc_progress_set_hide_text(GMPC_PROGRESS(progress), FALSE); gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE, TRUE, 0); g_object_set_data(G_OBJECT(base), "progress", progress); g_signal_connect(G_OBJECT(progress), "seek-event", G_CALLBACK(pl3_pb_seek_event), NULL); /* Previous button */ prev_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(prev_button), gtk_image_new_from_stock("gtk-media-previous", GTK_ICON_SIZE_BUTTON)); gtk_activatable_set_related_action(GTK_ACTIVATABLE(prev_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPrevious"))); gtk_button_set_relief(GTK_BUTTON(prev_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), prev_button, FALSE, FALSE, 0); /* Play button */ pp_button = gtk_button_new(); if(mpd_player_get_state(connection) == MPD_PLAYER_PLAY) { play_image = gtk_image_new_from_stock("gtk-media-pause", GTK_ICON_SIZE_BUTTON); } else { play_image = gtk_image_new_from_stock("gtk-media-play", GTK_ICON_SIZE_BUTTON); } gtk_container_add(GTK_CONTAINER(pp_button), play_image); g_object_set_data(G_OBJECT(base), "play_image", play_image); gtk_activatable_set_related_action(GTK_ACTIVATABLE(pp_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDPlayPause"))); gtk_button_set_relief(GTK_BUTTON(pp_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), pp_button, FALSE, FALSE, 0); /* Next */ next_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(next_button), gtk_image_new_from_stock("gtk-media-next", GTK_ICON_SIZE_BUTTON)); gtk_activatable_set_related_action(GTK_ACTIVATABLE(next_button), GTK_ACTION(gtk_builder_get_object(pl3_xml, "MPDNext"))); gtk_button_set_relief(GTK_BUTTON(next_button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), next_button, FALSE, FALSE, 0); /* Change colors */ control_window_modify_colors(base); gtk_widget_show_all(base); timeout = g_timeout_add_seconds(5, (GSourceFunc) gtk_widget_hide, hbox); return base; }
void status_changed(MpdObj *mi, ChangedStatusType what, thread_data *my_data) { if(what&MPD_CST_SONGID) { mpd_Song *song = mpd_playlist_get_current_song(mi); if(song) { printf( "Song:"" %s - %s\n", song->artist, song->title); } } if(what&MPD_CST_REPEAT){ printf("Repeat:"" %s\n", mpd_player_get_repeat(mi)? "On":"Off"); } if(what&MPD_CST_RANDOM){ printf("Random:"" %s\n", mpd_player_get_random(mi)? "On":"Off"); } if(what&MPD_CST_VOLUME){ printf("Volume:"" %03i%%\n", mpd_status_get_volume(mi)); my_data->mainLCD->printVolume(mpd_status_get_volume(mi)); try { my_data->ptr_MPD_info->volume= mpd_status_get_volume(mi); } catch (...) { log_file_mutex.mutex_lock(); log_file_cout << ERROR << "problem z wpisaniem volume "<< std::endl; log_file_mutex.mutex_unlock(); } } if(what&MPD_CST_CROSSFADE){ printf("X-Fade:"" %i sec.\n", mpd_status_get_crossfade(mi)); } if(what&MPD_CST_UPDATING) { if(mpd_status_db_is_updating(mi)) { printf("Started updating DB""\n"); } else { printf("Updating DB finished""\n"); } } if(what&MPD_CST_DATABASE) { printf("Databased changed""\n"); } if(what&MPD_CST_PLAYLIST) { printf("Playlist changed2""\n"); if (check_title_song_to==true) { mpd_Song *song = mpd_playlist_get_current_song(mi); // std::cout <<" SONG: " << song->artist<<" "<< song->title << std::endl; printf("aktualnie gramy:"" %s - %s\n", song->artist, song->title); try { my_data->ptr_MPD_info->title = std::string( song->title); } catch (...) { my_data->myEventHandler.run("mpd")->addEvent("wrong title"); my_data->ptr_MPD_info->title = "no data"; } try { my_data->ptr_MPD_info->artist = std::string( song->artist); } catch (...) { my_data->myEventHandler.run("mpd")->addEvent("wrong artist"); my_data->ptr_MPD_info->artist = "no data"; } if (song->name != NULL){ _msg = song->name; try { my_data->ptr_MPD_info->radio = _msg; } catch (...) { my_data->myEventHandler.run("mpd")->addEvent("wrong radio station name"); } my_data->mainLCD->printRadioName(true,0,0,_msg); my_data->mainLCD->set_lcd_STATE(5); std::string temp_str=""; temp_str = send_to_arduino(my_data,"temperature:2;"); temp_str.erase(temp_str.size()-2,temp_str.size()); my_data->mainLCD->printString(false,0,1,"temp:"+temp_str+" c"); updatePlayList(mi,my_data); } if (song->title != NULL ){ _msg = song->title; if (_msg.size() < 7 ) { _msg = song->name; _msg += " - brak nazwy "; } } else if (song->artist != NULL){ _msg = song->artist; } else { _msg += " - brak nazwy "; } // my_data->ptr_MPD_info->title = _msg; my_data->mainLCD->printSongName(_msg); } } if(what&MPD_CST_STATE) { printf("State:"); switch(mpd_player_get_state(mi)) { case MPD_PLAYER_PLAY: printf("Playing\n"); check_title_song_to=true; my_data->mainLCD->play_Y_N=true; my_data->ptr_MPD_info->isPlay=true; digitalWrite(GPIO_SPIK, LOW); my_data->mainLCD->set_lcd_STATE(1); my_data->mainLCD->song_printstr(); updatePlayList(mi,my_data); my_data->myEventHandler.run("mpd")->addEvent("MPD playing"); break; case MPD_PLAYER_PAUSE: printf("Paused\n"); my_data->mainLCD->set_lcd_STATE( -1); my_data->mainLCD->printString(true ,0,1," PAUSE"); my_data->myEventHandler.run("mpd")->addEvent("MPD pause"); break; case MPD_PLAYER_STOP: printf("Stopped\n"); if (my_data->ptr_MPD_info->isPlay ==true){ send_to_arduino(my_data,"LED_CLEAR:44;"); } check_title_song_to=false; my_data->mainLCD->play_Y_N=false; my_data->ptr_MPD_info->isPlay=false; my_data->ptr_MPD_info->title="* * * *"; digitalWrite(GPIO_SPIK,HIGH); my_data->mainLCD->noBacklight(); sleep(1); my_data->myEventHandler.run("mpd")->addEvent("MPD stopped"); break; default: break; } } /* not yet implemented signals */ if(what&MPD_CST_AUDIO){ printf("Audio Changed""\n"); } if(what&MPD_CST_TOTAL_TIME){ printf("Total song time changed:"" %02i:%02i\n", mpd_status_get_total_song_time(mi)/60, mpd_status_get_total_song_time(mi)%60); } if(what&MPD_CST_ELAPSED_TIME){ /* printf(GREEN"Time elapsed changed:"RESET" %02i:%02i\n", mpd_status_get_elapsed_song_time(mi)/60, mpd_status_get_elapsed_song_time(mi)%60); */ } if(what&MPD_CST_PERMISSION){ printf( "Permission:"" Changed\n"); } }
void basic_state_checking(void) { int rep, ran, sgl, len, crt, vol, ply, btr; struct mpd_status *status; status = getStatus(conn); rep = mpd_status_get_repeat(status); ran = mpd_status_get_random(status); sgl = mpd_status_get_single(status); len = mpd_status_get_queue_length(status); crt = mpd_status_get_song_id(status); vol = mpd_status_get_volume(status); ply = mpd_status_get_state(status); btr = mpd_status_get_kbit_rate(status); basic_info->crt_time = mpd_status_get_elapsed_time(status); basic_info->total_time = mpd_status_get_total_time(status); mpd_status_free(status); if(rep != basic_info->repeat || ran != basic_info->random || sgl != basic_info->single || len != basic_info->total || crt != basic_info->current || vol != basic_info->volume || ply != basic_info->state) { basic_info->repeat = rep; basic_info->random = ran; basic_info->single = sgl; basic_info->total = len; basic_info->current = crt; basic_info->volume = vol; basic_info->state = ply; signal_all_wins(); } /* as many songs's bit rate varies while playing we refresh the bit rate display only when the relevant change greater than 0.2 */ if(abs(basic_info->bit_rate - btr) / (float)(btr + 1) > 0.2) { basic_info->bit_rate = btr; signal_win(BASIC_INFO); } /* get current song's name */ status = init_mpd_status(conn); strncpy(basic_info->format, "null", 16); *basic_info->crt_name = '\0'; if (basic_info->state == MPD_STATE_PLAY || basic_info->state == MPD_STATE_PAUSE) { struct mpd_song *song; if (!mpd_response_next(conn)) printErrorAndExit(conn); song = mpd_recv_song(conn); if (song != NULL) { strncpy(basic_info->crt_name, get_song_tag(song, MPD_TAG_TITLE), 512); strncpy(basic_info->format, get_song_format(song), 16); } mpd_song_free(song); } mpd_status_free(status); my_finishCommand(conn); }
void MpdWidget::psMpdHB() { timerMpd->stop(); QString dataSender, dataVol, dataTitle; struct mpd_connection *conn; struct mpd_status * status; struct mpd_song *song; // const struct mpd_audio_format *audio_format; conn = mpd_connection_new(NULL, 0, 30000); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { timerMpd->start(); return; } if (aktPlay) { aktPlay = false; mpd_send_command(conn, "play", NULL); timerMpd->start(); return; } if (aktStop) { aktStop = false; mpd_send_command(conn, "stop", NULL); timerMpd->start(); return; } mpd_command_list_begin(conn, true); mpd_send_status(conn); mpd_send_current_song(conn); mpd_command_list_end(conn); // Status status = mpd_recv_status(conn); if (status == NULL) { timerMpd->start(); return ; } // Volume dataVol.number(mpd_status_get_volume(status)); if (labelVol->text().compare(dataVol) != 0) labelVol->setText(dataVol); if (mpd_status_get_error(status) != NULL) new QListWidgetItem(QString("status error: %1"). arg(mpd_status_get_error(status))); mpd_status_free(status); // Status mpd_response_next(conn); // Song song = mpd_recv_song(conn); if (song == NULL) { handle_error(conn); timerMpd->start(); return ; } // Title dataTitle = mpd_song_get_uri(song); if (labelTitle->text().compare(dataTitle) != 0) labelTitle->setText(dataTitle); unsigned int i = 0; QString value; while ((value = mpd_song_get_tag(song, MPD_TAG_TITLE, i++)) != NULL) { if (i > 0) dataSender.append(" "); dataSender.append(value); } if (labelSender->text().compare(dataSender) != 0) { labelSender->setText(dataSender); qDebug() << "refresh"; } mpd_song_free(song); // Song mpd_connection_free(conn); timerMpd->start(); }
void *main_mpd_cli(void *data ) { blockQueue char_queue; // kolejka polecen thread_data *my_data; my_data = (thread_data*)data; ////////////////////////////// LCD PART /////////////////////// my_data->mainLCD->set_print_song_state(0); /////////////////////////////////////////////////////////////////// int iport = 6600, button_counter =0; char *hostname = getenv("MPD_HOST"); char *port = getenv("MPD_PORT"); char *password = getenv("MPD_PASSWORD"); MpdObj *obj = NULL; std::cout << " adres hosta to " << hostname << std::endl; if(!hostname) { std::cout << " ip mpd to " << my_data->server_settings->MPD_IP << " ! \n"; hostname = (char*)my_data->server_settings->MPD_IP.c_str(); } if(port){ iport = std::stoi(port); } /* Create mpd object */ obj = mpd_new(hostname, iport,password); /* Connect signals */ mpd_signal_connect_error(obj,(ErrorCallback)error_callback, NULL); mpd_signal_connect_status_changed(obj,(StatusChangedCallback)status_changed , my_data ); /* Set timeout */ mpd_set_connection_timeout(obj, 10); int work; work = mpd_connect(obj); while (work){ log_file_mutex.mutex_lock(); log_file_cout << ERROR << "nie udalo sie polaczyc z MPD "<< std::endl; log_file_mutex.mutex_unlock(); system("service mpd stop"); sleep(1); system("service mpd start"); log_file_mutex.mutex_lock(); log_file_cout << INFO << "restart MPD "<< std::endl; log_file_cout << INFO << "nawiazuje nowe polaczenie z MPD "<< std::endl; log_file_mutex.mutex_unlock(); my_data->myEventHandler.run("mpd")->addEvent("restart MPD"); work = mpd_connect(obj); } std::cout << " stop "<<std::endl; if(!work) { char buffer; do{ if(char_queue._size() > 0) { //digitalWrite(LED7,1); buffer = char_queue._get(); switch(buffer) { case '\n': break; case 'D': mpd_player_next(obj); break; case 'U': mpd_player_prev(obj); break; case 't': mpd_player_play(obj); break; case 'A': mpd_player_pause(obj); break; case 'P': mpd_player_pause(obj); mpd_player_stop(obj); break; case 'q': printf("Quitting....\n"); break; case 'R': mpd_player_set_repeat(obj, !mpd_player_get_repeat(obj)); break; case 's': mpd_player_set_random(obj, !mpd_player_get_random(obj)); break; case 'p': /*if(char_queue._size() > 0) { buffer = char_queue._get(); int id = atoi(buffer); printf(GREEN"Playing:"RESET" %i\n", id); mpd_player_play_id(obj,id); } break;*/ case '+': mpd_status_set_volume(obj, mpd_status_get_volume(obj)+1); break; case '-': mpd_status_set_volume(obj, mpd_status_get_volume(obj)-1); break; case '%': mpd_status_set_volume(obj, my_data->ptr_MPD_info->volume); break; case '2': debug_level = (debug_level > 0)?0:3; printf( "Debug:"" %s\n", (debug_level >0)? "Enabled":"Disabled"); break; case 'I': mpd_player_play_id(obj,my_data->currentSongID); break; case 'h': printf("\th:\t\tHelp\n"\ "\td:\t\tToggle debug on/off\n"\ "\t+:\t\tIncrease volume\n"\ "\t-:\t\tDecrease volume\n"\ "\ta <pass>:\t Authentificate with pass\n"\ "\tp <id>:\t Play song with id\n"\ "\tl:\t\tList the playlist\n"\ "\ts:\t\tToggle shuffle mode\n"\ "\tr:\t\tToggle repeat\n"\ "\tq:\t\tQuit\n"\ "\tv:\t\tStop\n"\ "\tc:\t\tPause\n"\ "\tx:\t\tPlay\n"\ "\tz:\t\tPrevious\n"\ "\tb:\t\tNext\n"); break; default: printf("buffer: %c\n", buffer); } } if (!mpd_check_connected(obj)) { log_file_mutex.mutex_lock(); log_file_cout << WARNING << "utracono polacznie z MPD "<< std::endl; log_file_cout << INFO << "restart MPD" << std::endl; log_file_mutex.mutex_unlock(); system ("service mpd restart"); mpd_connect(obj); } mpd_status_update(obj); my_data->mainLCD->checkState(); if ( digitalRead(BUTTON_PIN) == HIGH ) { std::cout << " wcisnieta pin !" << std::endl; if (check_title_song_to == true && button_counter ==4) { char_queue._add('P'); std::cout << " \n\ngasze !" << std::endl; } else if (check_title_song_to == false && button_counter ==4) { char_queue._add('t'); std::cout << " \n\n\n zapalam !" << std::endl; } else if (check_title_song_to == false && button_counter ==10) { std::cout << " \n\n\n koniec programu z przyciska !" << std::endl; go_while = false; } std::cout << " \n\n\n licznik guzika wskazuje "<< button_counter << std::endl; ++button_counter; } else { button_counter =0; } } while(!usleep(500000) && go_while); mpd_player_stop(obj); sleep (3); } else{ std::cout << " NIE UDALO SIE POłączyć "<<std::endl; } mpd_free(obj); log_file_mutex.mutex_lock(); log_file_cout << INFO << " koniec watku klient MPD "<< std::endl; log_file_mutex.mutex_unlock(); return 0; }
/* * pgmpc_status * * Show current song and status. */ Datum pgmpc_status(PG_FUNCTION_ARGS) { #define PGMPC_STATUS_COLUMNS 7 Datum values[PGMPC_STATUS_COLUMNS]; bool nulls[PGMPC_STATUS_COLUMNS]; TupleDesc tupdesc; HeapTuple tuple; Datum result; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "return type must be a row type"); pgmpc_init(); /* Initialize the values of return tuple */ MemSet(values, 0, sizeof(values)); MemSet(nulls, true, sizeof(nulls)); /* * Send all necessary commands at once to avoid unnecessary round * trips. The following information is obtained in an aync way: * - current status of server * - current song run on server */ if (!mpd_command_list_begin(mpd_conn, true) || !mpd_send_status(mpd_conn) || !mpd_send_current_song(mpd_conn) || !mpd_command_list_end(mpd_conn)) pgmpc_print_error(); /* Obtain status from server and check it */ mpd_status = mpd_recv_status(mpd_conn); if (mpd_status == NULL) pgmpc_print_error(); /* Show current song if any */ if (mpd_status_get_state(mpd_status) == MPD_STATE_PLAY || mpd_status_get_state(mpd_status) == MPD_STATE_PAUSE) { struct mpd_song *song; /* There should be a next response, in this case a song */ if (!mpd_response_next(mpd_conn)) pgmpc_print_error(); /* And now get it */ song = mpd_recv_song(mpd_conn); if (song != NULL) { /* Get information about the current song */ const char *title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0); const char *artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0); const char *album = mpd_song_get_tag(song, MPD_TAG_ALBUM, 0); unsigned int elapsed_time = mpd_status_get_elapsed_time(mpd_status); unsigned int total_time = mpd_status_get_total_time(mpd_status); int song_pos = mpd_status_get_song_pos(mpd_status) + 1; int volume = mpd_status_get_volume(mpd_status); /* Build tuple using this information */ if (title) { nulls[0] = false; values[0] = CStringGetTextDatum(title); } else nulls[0] = true; if (artist) { nulls[1] = false; values[1] = CStringGetTextDatum(artist); } else nulls[1] = true; if (album) { nulls[2] = false; values[2] = CStringGetTextDatum(album); } else nulls[2] = true; nulls[3] = false; values[3] = UInt32GetDatum(elapsed_time); nulls[4] = false; values[4] = UInt32GetDatum(total_time); nulls[5] = false; values[5] = Int32GetDatum(song_pos); nulls[6] = false; values[6] = Int32GetDatum(volume); /* Song data is no more needed */ mpd_song_free(song); } if (!mpd_response_finish(mpd_conn)) pgmpc_print_error(); } /* Cleanup MPD status */ pgmpc_reset(); /* Form result and return it */ tuple = heap_form_tuple(tupdesc, values, nulls); result = HeapTupleGetDatum(tuple); PG_RETURN_DATUM(result); }
void print_status(struct mpd_connection *conn) { if (!mpd_command_list_begin(conn, true) || !mpd_send_status(conn) || !mpd_send_current_song(conn) || !mpd_command_list_end(conn)) printErrorAndExit(conn); struct mpd_status *status = mpd_recv_status(conn); if (status == NULL) printErrorAndExit(conn); if (mpd_status_get_state(status) == MPD_STATE_PLAY || mpd_status_get_state(status) == MPD_STATE_PAUSE) { if (!mpd_response_next(conn)) printErrorAndExit(conn); struct mpd_song *song = mpd_recv_song(conn); if (song != NULL) { pretty_print_song(song); printf("\n"); mpd_song_free(song); } if (mpd_status_get_state(status) == MPD_STATE_PLAY) printf("[playing]"); else printf("[paused] "); printf(" #%i/%u %3i:%02i/%i:%02i (%u%%)\n", mpd_status_get_song_pos(status) + 1, mpd_status_get_queue_length(status), mpd_status_get_elapsed_time(status) / 60, mpd_status_get_elapsed_time(status) % 60, mpd_status_get_total_time(status) / 60, mpd_status_get_total_time(status) % 60, elapsed_percent(status)); } if (mpd_status_get_update_id(status) > 0) printf("Updating DB (#%u) ...\n", mpd_status_get_update_id(status)); if (mpd_status_get_volume(status) >= 0) printf("volume:%3i%c ", mpd_status_get_volume(status), '%'); else { printf("volume: n/a "); } printf("repeat: "); if (mpd_status_get_repeat(status)) printf("on "); else printf("off "); printf("random: "); if (mpd_status_get_random(status)) printf("on "); else printf("off "); printf("single: "); if (mpd_status_get_single(status)) printf("on "); else printf("off "); printf("consume: "); if (mpd_status_get_consume(status)) printf("on \n"); else printf("off\n"); if (mpd_status_get_error(status) != NULL) printf("ERROR: %s\n", charset_from_utf8(mpd_status_get_error(status))); mpd_status_free(status); if (!mpd_response_finish(conn)) printErrorAndExit(conn); }