static void new_playlist_cb(GtkMenuItem *menuitem, gpointer ptr)
{
UNUSED(menuitem);
UNUSED(ptr);
struct playlist *playlist = new_playlist();
add_playlist_page(playlist, "Extra playlist");
}
static struct variant *new_variant(HLSContext *c, int bandwidth,
const char *url, const char *base)
{
struct variant *var;
struct playlist *pls;
pls = new_playlist(c, url, base);
if (!pls)
return NULL;
var = av_mallocz(sizeof(struct variant));
if (!var)
return NULL;
var->bandwidth = bandwidth;
dynarray_add(&c->variants, &c->n_variants, var);
dynarray_add(&var->playlists, &var->n_playlists, pls);
return var;
}
int main(int argc, char *argv[])
{
int fd = 0;
char *currentfile, old_dir[PATH_MAX];
playlist *pl = NULL;
struct id3_file *id3struct = NULL;
struct id3_tag *id3tag = NULL;
int retval;
buffer playbuf;
struct mad_decoder decoder;
pthread_t keyb_thread;
key_t sem_key;
key_t mem_key;
key_t frames_key;
union semun sem_ops;
int shm_id;
int frames_id;
mad_decoder_position = 0;
output_buffer_position = 0;
old_dir[0] = '\0';
playbuf.pl = pl = new_playlist();
if (!pl)
{
fprintf(stderr, "malloc failed at startup!\n");
exit(1);
}
loop_remaining = 1;
options.volume = MAD_F_ONE;
status = MPG321_PLAYING;
/* Get the command line options */
parse_options(argc, argv, pl);
if(options.opt & MPG321_PRINT_FFT)
if(!(options.opt & MPG321_REMOTE_PLAY))
{
/* printf("FFT analysis can only be used in Remote mode play.\n\n"); */
usage(argv[0]);
exit(0);
}
/* If there were no files and no playlist specified just print the usage */
if (!playlist_file && optind == argc)
{
usage(argv[0]);
exit(0);
}
if (playlist_file)
load_playlist(pl, playlist_file);
if(options.opt & MPG321_RECURSIVE_DIR)
add_cmdline_files_recursive_dir(pl, argv);
else
add_cmdline_files(pl, argv);
if (shuffle_play)
shuffle_files(pl);
if(options.opt & MPG321_ENABLE_BUFFER)
{
/* Initialize semaphore and shared memeory */
if(access(argv[0],X_OK) == 0)
sem_key = ftok(argv[0],0);
else
sem_key = ftok(MPG321_PATH,0);
if(sem_key == -1)
{
perror("Cannot obtain resources for semaphores");
exit(EXIT_FAILURE);
}
semarray = semget(sem_key,3,IPC_CREAT | IPC_EXCL | S_IRWXU);
if(semarray == -1)
{
perror("Cannot initialize semaphores");
exit(EXIT_FAILURE);
}
sem_ops.val = buffer_size-1;
if(semctl(semarray,0,SETVAL,sem_ops) == -1)
{
perror("Error while initializing mad_decoder semaphore");
if(semctl(semarray,0,IPC_RMID) == -1)
perror("Error while destroying semaphores");
goto out;
//exit(EXIT_FAILURE);
}
sem_ops.val = 0;
if(semctl(semarray,1,SETVAL,sem_ops) == -1)
{
perror("Error while initializing mad_decoder semaphore");
if(semctl(semarray,0,IPC_RMID) == -1)
perror("Error while destroying semaphores");
goto out;
//exit(EXIT_FAILURE);
}
sem_ops.val = 0;
if(semctl(semarray,2,SETVAL,sem_ops) == -1)
{
perror("Error while initializing mad_decoder semaphore");
if(semctl(semarray,0,IPC_RMID) == -1)
perror("Error while destroying semaphores");
goto out;
//exit(EXIT_FAILURE);
}
/* Shared Memory */
mem_key = ftok(argv[0],1);
shm_id = shmget(mem_key,buffer_size * sizeof(output_frame), IPC_CREAT | S_IREAD | S_IWRITE);
if(shm_id == -1)
{
perror("Cannot initialize shared buffer");
goto out;
//exit(EXIT_FAILURE);
}
Output_Queue = shmat(shm_id,NULL,0);
if(*(int *)Output_Queue == -1)
{
perror("Error while attaching shared buffer to mad_decoder");
if(shmctl(shm_id,IPC_RMID,NULL))
perror("Cannot destroy shared buffer");
goto out;
//exit(EXIT_FAILURE);
}
static int n;
for(n=0;n<buffer_size;n++)
{
memset((Output_Queue+n)->data,'\0',4608);
memset((Output_Queue+n)->time,'\0',80);
(Output_Queue+n)->length = 0;
(Output_Queue+n)->seconds = 0;
(Output_Queue+n)->num_frames = 0;
}
frames_key = ftok(argv[0],2);
frames_id = shmget(frames_key,buffer_size * sizeof(decoded_frames), IPC_CREAT | S_IREAD | S_IWRITE);
if(frames_id == -1)
{
perror("Cannot initialize shared frames counter");
goto out;
//exit(EXIT_FAILURE);
}
Decoded_Frames = shmat(frames_id,NULL,0);
if(*(int *)Decoded_Frames == -1)
{
perror("Error while attaching shared frames counter to mad_decoder");
if(shmctl(frames_id,IPC_RMID,NULL))
perror("Cannot destroy shared frames counter");
goto out;
//exit(EXIT_FAILURE);
}
Decoded_Frames->is_http = 0;
Decoded_Frames->is_file = 0;
}
else {
ao_initialize();
check_default_play_device();
}
if (!(options.opt & MPG321_REMOTE_PLAY))
{
handle_signals(-1); /* initialize signal handler */
remote_input_buf[0] = '\0';
}
if (!(options.opt & MPG321_QUIET_PLAY))
mpg123_boilerplate();
if (options.opt & MPG321_REMOTE_PLAY)
{
printf ("@R MPG123\n");
if(options.opt & MPG321_ENABLE_BUFFER)
{
#ifdef HAVE_ALSA
init_alsa_volume_control("default"); /* For the moment use "default", it works on most of the systems. Tested in Debian,Fedora,Ubuntu,RedHat,CentOS,Gentoo */
if(options.volume != MAD_F_ONE)
mpg321_alsa_set_volume((long)options.volume*volume_max/100);
#endif
}
}
/* Fork here. */
if(options.opt & MPG321_ENABLE_BUFFER)
{
output_pid = fork();
if(output_pid == -1)
{
perror("Error while forking output process");
goto out; /* Release shared memeory and semaphores */
// exit(EXIT_FAILURE);
}
if(output_pid == 0)
{
frame_buffer_p();
exit(EXIT_SUCCESS);
}
signal(SIGUSR1,handle_signals);
if(!(options.opt & MPG321_REMOTE_PLAY))
{
#ifdef HAVE_ALSA
init_alsa_volume_control("default");
if(options.volume != MAD_F_ONE)
mpg321_alsa_set_volume((long)options.volume*volume_max/100);
#endif
}
}
if( (options.volume != MAD_F_ONE) && !(options.opt & MPG321_ENABLE_BUFFER))
{
options.volume = mad_f_tofixed((long)options.volume/100.0);
}
else{
options.volume = MAD_F_ONE; /* When using the buffer options.volume when decoding each frame should be equal to MAD_F_ONE */
// options.volume = mad_f_tofixed((long)100.0/100.0);
}
if (!(options.opt & MPG321_REMOTE_PLAY))
{
if(options.opt & MPG321_ENABLE_BASIC)
{
/* Now create and detach the basic controls thread */
sem_init(&main_lock,0,0);
pthread_create(&keyb_thread,NULL,read_keyb,NULL);
pthread_detach(keyb_thread);
}
}
if(set_xterm)
{
tty_control();
get_term_title(title);
}else
{
if (!(options.opt & MPG321_REMOTE_PLAY))
{
if (tcgetattr(0, &terminal_settings) < 0)
perror("tcgetattr()");
memcpy(&old_terminal_settings, &terminal_settings, sizeof(struct termios));
/* Early thread start */
sem_post(&main_lock);
}
}
/* Play the mpeg files or zip it! */
while((currentfile = get_next_file(pl, &playbuf)))
{
//printf("Current File: %s\n",currentfile);
if (quit_now)
break;
signal(SIGINT, SIG_DFL);
playbuf.buf = NULL;
playbuf.fd = -1;
playbuf.length = 0;
playbuf.done = 0;
playbuf.num_frames = 0;
current_frame = 0;
playbuf.max_frames = -1;
strncpy(playbuf.filename,currentfile, PATH_MAX);
playbuf.filename[PATH_MAX-1] = '\0';
if (status == MPG321_PLAYING || status == MPG321_STOPPED)
file_change = 1;
mad_timer_reset(&playbuf.duration);
mad_timer_reset(¤t_time);
id3struct = NULL;
if (!(options.opt & MPG321_QUIET_PLAY) && file_change)
{
/* id3struct = id3_file_open (currentfile, ID3_FILE_MODE_READONLY);*/
if (id3struct == NULL)
get_id3_info(currentfile, &id3struct, &id3tag);
if(id3tag)
show_id3(id3tag);
}
scrobbler_time = -1;
if(options.opt & MPG321_USE_SCROBBLER)
{
if(id3struct == NULL)
get_id3_info(currentfile,&id3struct,&id3tag);
if (id3tag)
{
char emptystring[31], emptyyear[5] = " ";
int i;
if(parse_id3(scrobbler_args, id3tag))
{
memset(emptystring, ' ', 30);
emptystring[30] = '\0';
if((options.opt & MPG321_VERBOSE_PLAY) && (options.opt & MPG321_USE_SCROBBLER))
{
fprintf(stderr, "\nPreparing for the AudioScrobbler:\n");
for(i = 0; i < 6; i++)
{
if(scrobbler_args[i] == NULL)
scrobbler_args[i] =
( i == 3 ? emptyyear: emptystring);
fprintf(stderr, "- %s\n", scrobbler_args[i]);
}
}
}
}
}
if (options.opt & MPG321_REMOTE_PLAY && file_change)
{
if(id3struct == NULL)
get_id3_info(currentfile, &id3struct, &id3tag);
if(id3tag)
{
if (!show_id3(id3tag))
{
/* This shouldn't be necessary, but it appears that
libid3tag doesn't necessarily know if there are no
id3 tags on a given mp3 */
char * basec = strdup(currentfile);
char * basen = basename(basec);
char * dot = strrchr(basen, '.');
if (dot)
*dot = '\0';
printf("@I %s\n", basen);
free(basec);
}
}
else
{
char * basec = strdup(currentfile);
char * basen = basename(basec);
char * dot = strrchr(basen, '.');
if (dot)
*dot = '\0';
printf("@I %s\n", basen);
free(basec);
}
}
if(id3struct != NULL)
id3_file_close(id3struct);
/* Create the MPEG stream */
/* Check if source is on the network */
if((fd = raw_open(currentfile)) != 0 || (fd = http_open(currentfile)) != 0
|| (fd = ftp_open(currentfile)) != 0)
{
playbuf.fd = fd;
playbuf.buf = malloc(BUF_SIZE);
playbuf.length = BUF_SIZE;
if(options.opt & MPG321_ENABLE_BUFFER)
{
Decoded_Frames->is_http = 1;
Decoded_Frames->is_file = 0;
}
calc_http_length(&playbuf);
mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
output, handle_error, /* message */ 0);
}
/* Check if we are to use stdin for input */
else if(strcmp(currentfile, "-") == 0)
{
playbuf.fd = fileno(stdin);
playbuf.buf = malloc(BUF_SIZE);
playbuf.length = BUF_SIZE;
mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
output, handle_error, /* message */ 0);
}
/* currentfile is a local file (presumably.) mmap() it */
else
{
struct stat stat;
if((fd = open(currentfile, O_RDONLY)) == -1)
{
mpg321_error(currentfile);
/* Restore TTY from keyboard reader thread */
if(options.opt & MPG321_ENABLE_BASIC)
if (tcsetattr(0, TCSANOW, &old_terminal_settings) < 0)
perror("tcsetattr ICANON");
if(set_xterm)
{
set_tty_restore();
osc_print(0,0,title);
if (ctty)
fclose(ctty);
}
if( options.opt & MPG321_REMOTE_PLAY)
if(remote_restart)
{
clear_remote_file(pl); /* If restart is enabled, restart remote shell when file doesn't exist*/
continue;
}
if(options.opt & MPG321_ENABLE_BUFFER)
goto out;
else
exit(1);
/* mpg123 stops immediately if it can't open a file */
/* If sth goes wrong break!!!*/
break;
}
if(options.opt & MPG321_ENABLE_BUFFER)
{
Decoded_Frames->is_http = 0;
Decoded_Frames->is_file = 1;
}
if(fstat(fd, &stat) == -1)
{
mpg321_error(currentfile);
close(fd);
continue;
}
if (!S_ISREG(stat.st_mode))
{
if(S_ISFIFO(stat.st_mode))
{
fallback = 1;
goto fall_back_to_read_from_fd;
}
close(fd);
continue;
}
retval = calc_length(currentfile, &playbuf); //FIXME Check also if it is an mp3 file. If not break and go to the next file possible
if(retval < 0)
{
if(options.opt & MPG321_REMOTE_PLAY)
{
fprintf(stderr,"@E Corrupted file: %s\n",currentfile);
close(fd);
if(remote_restart)
{
clear_remote_file(pl); /* If restart is enabled, restart remote shell when file is corrupted */
continue;
}
break;
}
mpg321_error(currentfile);
close(fd);
// break; //FIXME Break and stop OR continue the playlist ????
continue;
}
if((options.opt & MPG321_VERBOSE_PLAY) && (options.opt & MPG321_USE_SCROBBLER))
fprintf(stderr, "Track duration: %ld seconds\n",playbuf.duration.seconds);
if(options.opt & MPG321_USE_SCROBBLER)
scrobbler_set_time(playbuf.duration.seconds);
if ((options.maxframes != -1) && (options.maxframes <= playbuf.num_frames))
{
playbuf.max_frames = options.maxframes;
}
playbuf.frames = malloc((playbuf.num_frames + 1) * sizeof(void*));
playbuf.times = malloc((playbuf.num_frames + 1) * sizeof(mad_timer_t));
#ifdef __uClinux__
if((playbuf.buf = mmap(0, playbuf.length, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED)
#else
if((playbuf.buf = mmap(0, playbuf.length, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED)
#endif
{
mpg321_error(currentfile);
continue;
}
playbuf.frames[0] = playbuf.buf;
mad_decoder_init(&decoder, &playbuf, read_from_mmap, read_header, /*filter*/0,
output, handle_error, /* message */ 0);
fall_back_to_read_from_fd: //FIXME. Reported that on some embedded systems with low memory, less than 16MB doesn't work properly.
if(fallback)
{
playbuf.fd = fd;
playbuf.buf = malloc(BUF_SIZE);
playbuf.length = BUF_SIZE;
mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
output, handle_error, /* message */ 0);
fallback = 1;
}
}
if(!(options.opt & MPG321_QUIET_PLAY))/*zip it!!!*/
{
/* Because dirname might modify the argument */
char * dirc = strdup(currentfile);
char * basec = strdup(currentfile);
char * basen = basename(basec);
char * dirn = dirname(dirc);
/* make sure that the file has a pathname; otherwise don't print out
a Directory: listing */
if(strchr(currentfile, '/') && strncmp(old_dir, dirn, PATH_MAX) != 0)
{
/* Print information about the file */
fprintf(stderr, "\n");
fprintf(stderr,"Directory: %s\n", dirn);
strncpy(old_dir, dirn, PATH_MAX);
old_dir[PATH_MAX-1] = '\0';
}
/* print a newline between different songs only, not after
Directory: listing */
else
{
fprintf(stderr, "\n");
}
fprintf(stderr,"Playing MPEG stream from %s ...\n", basen);
/* Printing xterm title */
if(set_xterm)
{
osc_print(0,0,basen);
}
free(dirc);
free(basec);
}
signal(SIGINT, handle_signals);
signal(SIGCHLD, handle_sigchld);
/*Give control back so that we can implement SIG's*/
if(set_xterm)
{
set_tty_restore();
if (tcgetattr(0, &terminal_settings) < 0)
perror("tcgetattr()");
memcpy(&old_terminal_settings, &terminal_settings, sizeof(struct termios));
/* disable canonical mode processing in the line discipline driver */
terminal_settings.c_lflag &= ~(ICANON | ECHO);
/* apply our new settings */
if (tcsetattr(0, TCSANOW, &terminal_settings) < 0)
perror("tcsetattr ICANON");
if(options.opt & MPG321_ENABLE_BASIC)
{
/* Late thread start */
sem_post(&main_lock);
}
}
/* Every time the user gets us to rewind, we exit decoding,
reinitialize it, and re-start it */
if(options.opt & MPG321_ENABLE_BUFFER)
{
Decoded_Frames->total_decoded_frames = 0;
Decoded_Frames->done = 0;
}
while (1)
{
decoder.options |= MAD_OPTION_IGNORECRC;
mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
if(options.opt & MPG321_ENABLE_BUFFER)
{
static struct sembuf start_sops = {2,-1,0};
semop(semarray,&start_sops,1);
mad_decoder_position = 0;
output_buffer_position = 0;
union semun sem_ops;
sem_ops.val = 0;
semctl(semarray,2,SETVAL,sem_ops);
Decoded_Frames->total_decoded_frames = 0;
Decoded_Frames->done = 0;
Decoded_Frames->is_http = 0;
Decoded_Frames->is_file = 0;
}
/* if we're rewinding on an mmap()ed stream */
if(status == MPG321_REWINDING && playbuf.fd == -1)
{
mad_decoder_init(&decoder, &playbuf, read_from_mmap, read_header, /*filter*/0,
output, /*error*/0, /* message */ 0);
}
else
break;
}
if (!(options.opt & MPG321_QUIET_PLAY))
{
char time_formatted[11];
mad_timer_string(current_time, time_formatted, "%.1u:%.2u", MAD_UNITS_MINUTES,
MAD_UNITS_SECONDS, 0);
fprintf(stderr," \r");
fprintf(stderr, "\n[%s] Decoding of %s finished.\n",time_formatted, basename(currentfile)); /* Report total decoded seconds. Maybe for the frame buffer report only total played time?? */
}
if (options.opt & MPG321_REMOTE_PLAY && status == MPG321_STOPPED)
{
clear_remote_file(pl);
}
mad_decoder_finish(&decoder);
if (playbuf.frames)
free(playbuf.frames);
if (playbuf.times)
free(playbuf.times);
if (playbuf.fd == -1)
{
munmap(playbuf.buf, playbuf.length);
close(fd);
}
else
{
free(playbuf.buf);
if (playbuf.fd != fileno(stdin))
close(playbuf.fd);
}
}
if(!(options.opt & MPG321_ENABLE_BUFFER))
{
if(playdevice)
ao_close(playdevice);
ao_shutdown();
}
if (!(options.opt & MPG321_REMOTE_PLAY))
{
if(options.opt & MPG321_ENABLE_BASIC)
{
pflag = 1;
/* Restore TTY from keyboard reader thread */
if (tcsetattr(0, TCSANOW, &old_terminal_settings) < 0)
perror("tcsetattr ICANON");
}
}
/*Restoring TTY*/
if(set_xterm)
{
set_tty_restore();
osc_print(0,0,title);
if (ctty)
fclose(ctty);
}
out:
if(options.opt & MPG321_ENABLE_BUFFER)
{
if(kill(output_pid,SIGUSR1) == -1)
perror("Error while stopping output process");
static int wstatus;
wait(&wstatus);
if(wstatus == -1)
perror("Error while waiting for output process to exit");
if(semctl(semarray,0,IPC_RMID) == -1)
perror("Error while destroying semaphores");
if(shmdt(Output_Queue) == -1)
perror("Error while detaching shared buffer");
if(shmctl(shm_id,IPC_RMID,NULL))
perror("Cannot destroy shared buffer");
if(shmctl(frames_id,IPC_RMID,NULL))
perror("Cannot destroy shared buffer");
}
return(0);
}
static int run_amz_file(clamz_downloader *dl,
const clamz_config *cfg,
FILE *amzfile,
const char *fname)
{
char *inbuf;
unsigned char *xml;
size_t sz;
clamz_playlist *pl;
int i;
int status, rv = 0;
char *logname;
FILE *logfile;
sz = 0;
inbuf = NULL;
while (!feof(amzfile) && !ferror(amzfile)) {
if (inbuf)
inbuf = realloc(inbuf, (sz + 1024) * sizeof(char));
else
inbuf = malloc((sz + 1024) * sizeof(char));
sz += fread(&inbuf[sz], 1, 1024, amzfile);
}
if (amzfile != stdin)
fclose(amzfile);
if (cfg->printonly && cfg->printasxml) {
xml = decrypt_amz_file(inbuf, sz, fname);
if (!xml) {
free(inbuf);
return 2;
}
printf("%s", xml);
free(xml);
free(inbuf);
return 0;
}
else {
if (!cfg->printonly) {
if (write_backup_file(inbuf, sz, getbasename(fname))) {
free(inbuf);
return 3;
}
}
pl = new_playlist();
if (read_amz_file(pl, inbuf, sz, fname)) {
free(inbuf);
free_playlist(pl);
return 2;
}
if (!cfg->printonly) {
logname = get_config_file_name("logs", getbasename(fname), ".log");
if (!logname) {
free(inbuf);
return 1;
}
logfile = fopen(logname, "w");
if (!logfile) {
perror(logname);
free(logname);
free(inbuf);
return 3;
}
free(logname);
set_download_log_file(dl, logfile);
}
else {
logfile = NULL;
}
if (cfg->printonly || cfg->verbose)
print_pl_info(pl, fname);
for (i = 0; i < pl->num_tracks; i++) {
if (cfg->printonly || cfg->verbose)
print_tr_info(pl->tracks[i], i + 1);
status = download_track(dl, pl->tracks[i]);
if (!rv)
rv = status;
fputc('\n', stderr);
}
set_download_log_file(dl, NULL);
free(inbuf);
free_playlist(pl);
if (logfile)
fclose(logfile);
return rv;
}
}
int main(int argc, char **argv)
{
char *socketname = get_config_name("control");
/* check if japlay is already running */
if (socketname && file_exists(socketname)) {
int fd = unix_socket_connect(socketname);
if (fd >= 0) {
int i;
for (i = 1; i < argc; ++i) {
char *path = absolute_path(argv[i]);
if (path) {
sendto(fd, path, strlen(path), 0, NULL, 0);
free(path);
}
}
close(fd);
return 0;
}
/* remove leftover socket */
unlink(socketname);
}
g_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
gtk_init(&argc, &argv);
main_thread = g_thread_self();
if (japlay_init(&argc, argv)) {
error("Can not initialize japlay\n");
return -1;
}
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), APP_NAME);
g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(destroy_cb), NULL);
g_signal_connect(G_OBJECT(main_window), "key-press-event", G_CALLBACK(key_pressed_cb), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
GtkWidget *file_menu = gtk_menu_new();
GtkWidget *item = gtk_menu_item_new_with_label("New playlist");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(new_playlist_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("Add directory to the playlist...");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(add_dir_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("Clear playlist");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(clear_playlist_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_check_menu_item_new_with_label("Enable shuffle");
g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_shuffle_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_check_menu_item_new_with_label("Enable automatic volume");
g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_autovol_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
/*item = gtk_menu_item_new_with_label("Scan playlist");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(scan_playlist_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);*/
item = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("Quit");
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(destroy_cb), NULL);
gtk_menu_append(GTK_MENU(file_menu), item);
item = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), file_menu);
gtk_menu_bar_append(GTK_MENU_BAR(menubar), item);
static const struct button {
const char *stockid;
const char *help;
void (*const cb)(GtkButton *button, gpointer ptr);
} buttons[] = {
{GTK_STOCK_MEDIA_PLAY, "Play", play_cb},
{GTK_STOCK_MEDIA_STOP, "stop", stop_cb},
{GTK_STOCK_MEDIA_PAUSE, "Pause", pause_cb},
{GTK_STOCK_MEDIA_NEXT, "Skip to the next song in the queue", next_cb},
{GTK_STOCK_OPEN, "Add files to the playlist", add_cb},
{GTK_STOCK_OK, "Add selected songs to the queue", enqueue_cb},
{GTK_STOCK_DELETE, "Remove selected songs", remove_cb},
{NULL, NULL, NULL}
};
GtkWidget *toolbar = gtk_hbox_new(false, 0);
int i;
for (i = 0; buttons[i].stockid; ++i) {
GtkWidget *button = gtk_button_new();
GtkWidget *image = gtk_image_new_from_stock(buttons[i].stockid, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(button), image);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(buttons[i].cb), NULL);
gtk_box_pack_start(GTK_BOX(toolbar), button, false, true, 0);
gtk_widget_set_tooltip_text(button, buttons[i].help);
}
scope_area = gtk_drawing_area_new();
gtk_widget_set_size_request(scope_area, SCOPE_WIDTH, -1);
gtk_box_pack_start(GTK_BOX(toolbar), scope_area, false, true, 0);
g_signal_connect(G_OBJECT(scope_area), "expose_event", G_CALLBACK(expose_event_cb), NULL);
seekbar = gtk_hscale_new_with_range(0, 1, 1);
gtk_range_set_update_policy(GTK_RANGE(seekbar), GTK_UPDATE_DELAYED);
g_signal_connect(G_OBJECT(seekbar), "change-value", G_CALLBACK(seek_cb), NULL);
g_signal_connect(G_OBJECT(seekbar), "format-value", G_CALLBACK(format_seek_cb), NULL);
notebook = gtk_notebook_new();
GtkWidget *vbox = gtk_vbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(vbox), menubar, false, true, 0);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, false, true, 0);
gtk_box_pack_start(GTK_BOX(vbox), seekbar, false, true, 0);
gtk_box_pack_start(GTK_BOX(vbox), notebook, true, true, 0);
gtk_container_add(GTK_CONTAINER(main_window), vbox);
gtk_widget_show_all(main_window);
/* TODO: load all playlists */
main_playlist = new_playlist();
add_playlist_page(main_playlist, "Main");
add_playlist_page(japlay_queue, "Play queue");
add_playlist_page(japlay_history, "History");
char *playlistpath = get_config_name("main_playlist.m3u");
if (playlistpath)
load_playlist(main_playlist, playlistpath);
char *queuepath = get_config_name("queue.m3u");
if (queuepath)
load_playlist(japlay_queue, queuepath);
char *settingspath = get_config_name("settings.cfg");
if (settingspath)
load_settings(settingspath);
for (i = 1; i < argc; ++i)
add_file_playlist(main_playlist, argv[i]);
signal(SIGINT, handle_sigint);
int fd = -1;
if (socketname) {
fd = unix_socket_create(socketname);
if (fd >= 0) {
GIOChannel *io = g_io_channel_unix_new(fd);
g_io_add_watch(io, G_IO_IN, incoming_client, NULL);
}
}
gtk_main();
if (fd >= 0)
unlink(socketname);
if (playlistpath)
save_playlist_m3u(main_playlist, playlistpath);
if (queuepath)
save_playlist_m3u(japlay_queue, queuepath);
if (settingspath)
save_settings(settingspath);
japlay_exit();
return 0;
}
int main(int argc, char *argv[])
{
int fd = 0;
char *currentfile, old_dir[PATH_MAX];
playlist *pl = NULL;
struct id3_file *id3struct = NULL;
struct id3_tag *id3tag = NULL;
buffer playbuf;
struct mad_decoder decoder;
old_dir[0] = '\0';
playbuf.pl = pl = new_playlist();
if (!pl)
{
fprintf(stderr, "malloc failed at startup!\n");
exit(1);
}
options.volume = MAD_F_ONE;
status = MPG321_PLAYING;
/* Get the command line options */
parse_options(argc, argv, pl);
/* If there were no files and no playlist specified just print the usage */
if (!playlist_file && optind == argc)
{
usage(argv[0]);
exit(0);
}
if (playlist_file)
load_playlist(pl, playlist_file);
add_cmdline_files(pl, argv);
if (shuffle_play)
shuffle_files(pl);
ao_initialize();
check_default_play_device();
if (!(options.opt & MPG321_REMOTE_PLAY))
{
handle_signals(-1); /* initialize signal handler */
remote_input_buf[0] = '\0';
}
if (!(options.opt & MPG321_QUIET_PLAY))
mpg123_boilerplate();
if (options.opt & MPG321_REMOTE_PLAY)
{
printf ("@R MPG123\n");
}
/* Play the mpeg files or zip it! */
while((currentfile = get_next_file(pl, &playbuf)))
{
if (quit_now)
break;
signal(SIGINT, SIG_DFL);
playbuf.buf = NULL;
playbuf.fd = -1;
playbuf.length = 0;
playbuf.done = 0;
playbuf.num_frames = 0;
playbuf.max_frames = -1;
strncpy(playbuf.filename,currentfile, PATH_MAX);
playbuf.filename[PATH_MAX-1] = '\0';
if (status == MPG321_PLAYING)
file_change = 1;
mad_timer_reset(&playbuf.duration);
mad_timer_reset(¤t_time);
if (!(options.opt & MPG321_QUIET_PLAY) && file_change)
{
id3struct = id3_file_open (currentfile, ID3_FILE_MODE_READONLY);
if (id3struct)
{
id3tag = id3_file_tag (id3struct);
if (id3tag)
{
show_id3 (id3tag);
}
id3_file_close (id3struct);
}
}
if (options.opt & MPG321_REMOTE_PLAY && file_change)
{
id3struct = id3_file_open (currentfile, ID3_FILE_MODE_READONLY);
if (id3struct)
{
id3tag = id3_file_tag (id3struct);
if (id3tag)
{
if (!show_id3(id3tag))
{
/* This shouldn't be necessary, but it appears that
libid3tag doesn't necessarily know if there are no
id3 tags on a given mp3 */
char * basec = strdup(currentfile);
char * basen = basename(basec);
char * dot = strrchr(basen, '.');
if (dot)
*dot = '\0';
printf("@I %s\n", basen);
free(basec);
}
}
else
{
fprintf(stderr, "Allocation error");
exit(1);
}
id3_file_close (id3struct);
}
else
{
char * basec = strdup(currentfile);
char * basen = basename(basec);
char * dot = strrchr(basen, '.');
if (dot)
*dot = '\0';
printf("@I %s\n", basen);
free(basec);
}
}
/* Create the MPEG stream */
/* Check if source is on the network */
if((fd = raw_open(currentfile)) != 0 || (fd = http_open(currentfile)) != 0
|| (fd = ftp_open(currentfile)) != 0)
{
playbuf.fd = fd;
playbuf.buf = malloc(BUF_SIZE);
playbuf.length = BUF_SIZE;
mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
output, /*error*/0, /* message */ 0);
}
/* Check if we are to use stdin for input */
else if(strcmp(currentfile, "-") == 0)
{
playbuf.fd = fileno(stdin);
playbuf.buf = malloc(BUF_SIZE);
playbuf.length = BUF_SIZE;
mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
output, /*error*/0, /* message */ 0);
}
/* currentfile is a local file (presumably.) mmap() it */
else
{
struct stat stat;
if((fd = open(currentfile, O_RDONLY)) == -1)
{
mpg321_error(currentfile);
/* mpg123 stops immediately if it can't open a file */
break;
}
if(fstat(fd, &stat) == -1)
{
close(fd);
mpg321_error(currentfile);
continue;
}
if (!S_ISREG(stat.st_mode))
{
close(fd);
continue;
}
calc_length(currentfile, &playbuf);
if ((options.maxframes != -1) && (options.maxframes <= playbuf.num_frames))
{
playbuf.max_frames = options.maxframes;
}
playbuf.frames = malloc((playbuf.num_frames + 1) * sizeof(void*));
playbuf.times = malloc((playbuf.num_frames + 1) * sizeof(mad_timer_t));
if((playbuf.buf = mmap(0, playbuf.length, PROT_READ, MAP_SHARED, fd, 0))
== MAP_FAILED)
{
close(fd);
mpg321_error(currentfile);
continue;
}
close(fd);
playbuf.frames[0] = playbuf.buf;
mad_decoder_init(&decoder, &playbuf, read_from_mmap, read_header, /*filter*/0,
output, /*error*/0, /* message */ 0);
}
if(!(options.opt & MPG321_QUIET_PLAY))/*zip it!!!*/
{
/* Because dirname might modify the argument */
char * dirc = strdup(currentfile);
char * basec = strdup(currentfile);
char * basen = basename(basec);
char * dirn = dirname(dirc);
/* make sure that the file has a pathname; otherwise don't print out
a Directory: listing */
if(strchr(currentfile, '/') && strncmp(old_dir, dirn, PATH_MAX) != 0)
{
/* Print information about the file */
fprintf(stderr, "\n");
fprintf(stderr,"Directory: %s/\n", dirn);
strncpy(old_dir, dirn, PATH_MAX);
old_dir[PATH_MAX-1] = '\0';
}
/* print a newline between different songs only, not after
Directory: listing */
else
{
fprintf(stderr, "\n");
}
fprintf(stderr,"Playing MPEG stream from %s ...\n", basen);
free(dirc);
free(basec);
}
signal(SIGINT, handle_signals);
/* Every time the user gets us to rewind, we exit decoding,
reinitialize it, and re-start it */
while (1)
{
mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
/* if we're rewinding on an mmap()ed stream */
if(status == MPG321_REWINDING && playbuf.fd == -1)
{
mad_decoder_init(&decoder, &playbuf, read_from_mmap, read_header, /*filter*/0,
output, /*error*/0, /* message */ 0);
}
else
break;
}
if (!(options.opt & MPG321_QUIET_PLAY))
{
char time_formatted[11];
mad_timer_string(current_time, time_formatted, "%.1u:%.2u", MAD_UNITS_MINUTES,
MAD_UNITS_SECONDS, 0);
fprintf(stderr, "\n[%s] Decoding of %s finished.\n",time_formatted, basename(currentfile));
}
if (options.opt & MPG321_REMOTE_PLAY && status == MPG321_STOPPED)
{
clear_remote_file(pl);
}
mad_decoder_finish(&decoder);
if (quit_now)
break;
if (playbuf.frames)
free(playbuf.frames);
if (playbuf.times)
free(playbuf.times);
if (playbuf.fd == -1)
{
munmap(playbuf.buf, playbuf.length);
}
else
{
free(playbuf.buf);
if (playbuf.fd != fileno(stdin))
close(playbuf.fd);
}
}
if(playdevice)
ao_close(playdevice);
ao_shutdown();
#if defined(RAW_SUPPORT) || defined(HTTP_SUPPORT) || defined(FTP_SUPPORT)
if(fd) close(fd);
#endif
return(0);
}
