/**
* Render the given text at (x,y) on the target image.
* Justify is left, right, or center
*/
void FontEngine::render(string text, int x, int y, int justify, SDL_Surface *target, int color) {
int dest_x;
int dest_y;
// calculate actual starting x,y based on justify
if (justify == JUSTIFY_LEFT) {
dest_x = x;
dest_y = y;
}
else if (justify == JUSTIFY_RIGHT) {
dest_x = x - calc_length(text);
dest_y = y;
}
else if (justify == JUSTIFY_CENTER) {
dest_x = x - calc_length(text)/2;
dest_y = y;
}
// render and blit the text
SDL_Rect dest;
dest.x = dest_x;
dest.y = dest_y;
const char* char_text = text.c_str(); //makes it so SDL_ttf functions can read it
ttf = TTF_RenderUTF8_Blended(font, char_text, colors[color]);
if (ttf != NULL) SDL_BlitSurface(ttf, NULL, target, &dest);
SDL_FreeSurface(ttf);
ttf = NULL;
}
/**
* Using the given wrap width, calculate the width and height necessary to display this text
*/
Point FontEngine::calc_size(string text_with_newlines, int width) {
char newline = 10;
string text = text_with_newlines;
// if this contains newlines, recurse
int check_newline = text.find_first_of(newline);
if (check_newline > -1) {
Point p1 = calc_size(text.substr(0, check_newline), width);
Point p2 = calc_size(text.substr(check_newline+1, text.length()), width);
Point p3;
if (p1.x > p2.x) p3.x = p1.x;
else p3.x = p2.x;
p3.y = p1.y + p2.y;
return p3;
}
int height = 0;
int max_width = 0;
string segment;
string fulltext;
string builder = "";
string builder_prev = "";
char space = 32;
fulltext = text + " ";
segment = eatFirstString(fulltext, space);
while(segment != "" || fulltext.length() > 0) { // don't exit early on double spaces
builder = builder + segment;
if (calc_length(builder) > width) {
height = height + getLineHeight();
if (calc_length(builder_prev) > max_width) max_width = calc_length(builder_prev);
builder_prev = "";
builder = segment + " ";
}
else {
builder = builder + " ";
builder_prev = builder;
}
segment = eatFirstString(fulltext, space);
}
height = height + getLineHeight();
builder = trim(builder, ' '); //removes whitespace that shouldn't be included in the size
if (calc_length(builder) > max_width) max_width = calc_length(builder);
Point size;
size.x = max_width;
size.y = height;
return size;
}
double calc_length(node *anynode)
{
double temp=0.0;
if (anynode->desc_left==NULL) temp = anynode->time;
else temp = calc_length(anynode->desc_left) +
anynode->time-anynode->desc_left->time;
if (anynode->desc_right==NULL) temp += anynode->time;
else temp += calc_length(anynode->desc_right) +
anynode->time-anynode->desc_right->time;
return temp;
}
static int
clnt_setup_long_reply(CONN *conn, struct clist **clpp, uint_t length)
{
if (length == 0) {
*clpp = NULL;
return (CLNT_RDMA_SUCCESS);
}
*clpp = clist_alloc();
(*clpp)->rb_longbuf.len = calc_length(length);
(*clpp)->rb_longbuf.type = RDMA_LONG_BUFFER;
if (rdma_buf_alloc(conn, &((*clpp)->rb_longbuf))) {
clist_free(*clpp);
*clpp = NULL;
return (CLNT_RDMA_FAIL);
}
(*clpp)->u.c_daddr3 = (*clpp)->rb_longbuf.addr;
(*clpp)->c_len = (*clpp)->rb_longbuf.len;
(*clpp)->c_next = NULL;
(*clpp)->c_dmemhandle = (*clpp)->rb_longbuf.handle;
if (clist_register(conn, *clpp, CLIST_REG_DST)) {
DTRACE_PROBE(krpc__e__clntrdma__longrep_regbuf);
rdma_buf_free(conn, &((*clpp)->rb_longbuf));
clist_free(*clpp);
return (CLNT_RDMA_FAIL);
}
return (CLNT_RDMA_SUCCESS);
}
/**
* Word wrap to width
*/
void FontEngine::render(string text, int x, int y, int justify, SDL_Surface *target, int width, int color) {
cursor_y = y;
string segment;
string fulltext;
string builder = "";
string builder_prev = "";
char space = 32;
fulltext = text + " ";
segment = eatFirstString(fulltext, space);
while(segment != "" || fulltext.length() > 0) { // don't exit early on double spaces
builder = builder + segment;
if (calc_length(builder) > width) {
render(builder_prev, x, cursor_y, justify, target, color);
cursor_y += getLineHeight();
builder_prev = "";
builder = segment + " ";
}
else {
builder = builder + " ";
builder_prev = builder;
}
segment = eatFirstString(fulltext, space);
}
render(builder, x, cursor_y, justify, target, color);
cursor_y += getLineHeight();
}
edge::edge( const point& one, const point& two ) :
a( one ), b( two ), length( calc_length( one, two ) )
{
if ( a == b )
throw std::invalid_argument( "an edge must have distinct vertices" );
if ( b < a ) {
point t = a;
a = b;
b = t;
}
}
int main() {
unsigned long max_start = 0;
unsigned long max_length = 0;
for (unsigned long i = 0; i < 1000000; i++) {
unsigned long length;
if ((length = calc_length(i)) > max_length) {
max_length = length;
max_start = i;
}
printf("starting at %lu generates chain of length %lu\n", i, length);
}
printf("max start is %lu\n", max_start);
printf("max length is %lu\n", max_length);
return 0;
}
gboolean
analysis_tool_frequency_engine (G_GNUC_UNUSED GOCmdContext *gcc, data_analysis_output_t *dao, gpointer specs,
analysis_tool_engine_t selector, gpointer result)
{
analysis_tools_data_frequency_t *info = specs;
switch (selector) {
case TOOL_ENGINE_UPDATE_DESCRIPTOR:
return (dao_command_descriptor (dao, _("Frequency Table (%s)"), result)
== NULL);
case TOOL_ENGINE_UPDATE_DAO:
{
int i;
prepare_input_range (&info->base.input, info->base.group_by);
i = 2 + ((info->predetermined) ? calc_length (info->bin) : info->n);
dao_adjust (dao, g_slist_length (info->base.input) + 1, i);
return FALSE;
}
case TOOL_ENGINE_CLEAN_UP:
return analysis_tool_generic_clean (specs);
case TOOL_ENGINE_LAST_VALIDITY_CHECK:
return FALSE;
case TOOL_ENGINE_PREPARE_OUTPUT_RANGE:
dao_prepare_output (NULL, dao, _("Frequency Table"));
return FALSE;
case TOOL_ENGINE_FORMAT_OUTPUT_RANGE:
return dao_format_output (dao, _("Frequency Table"));
case TOOL_ENGINE_PERFORM_CALC:
default:
return analysis_tool_frequency_engine_run (dao, specs);
}
return TRUE;
}
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);
}
void CNewFile::fix_controls()
{
// Enable controls that dep. on which size option is selected
ctl_size_factor_.EnableWindow(fill_.size_src == 1);
ctl_size_length_.EnableWindow(fill_.size_src == 1);
ASSERT(GetDlgItem(IDC_SPIN_SIZE_FACTOR) != NULL);
GetDlgItem(IDC_SPIN_SIZE_FACTOR)->EnableWindow(fill_.size_src == 1);
ASSERT(GetDlgItem(IDC_STATIC1) != NULL);
GetDlgItem(IDC_STATIC1)->EnableWindow(fill_.size_src == 1);
ASSERT(GetDlgItem(IDC_STATIC1) != NULL);
GetDlgItem(IDC_STATIC1)->EnableWindow(fill_.size_src == 1);
ASSERT(GetDlgItem(IDC_STATIC2) != NULL);
GetDlgItem(IDC_STATIC2)->EnableWindow(fill_.size_src == 1);
ASSERT(GetDlgItem(IDC_STATIC3) != NULL);
GetDlgItem(IDC_STATIC3)->EnableWindow(fill_.size_src == 1);
ctl_decimal_size_.EnableWindow(fill_.size_src == 0);
ctl_hex_size_.EnableWindow(fill_.size_src == 0);
ASSERT(GetDlgItem(IDC_SPIN_DECIMAL_SIZE) != NULL);
GetDlgItem(IDC_SPIN_DECIMAL_SIZE)->EnableWindow(fill_.size_src == 0);
ASSERT(GetDlgItem(IDC_DESC_DECIMAL_SIZE) != NULL);
GetDlgItem(IDC_DESC_DECIMAL_SIZE)->EnableWindow(fill_.size_src == 0);
ASSERT(GetDlgItem(IDC_DESC_HEX_SIZE) != NULL);
GetDlgItem(IDC_DESC_HEX_SIZE)->EnableWindow(fill_.size_src == 0);
ASSERT(GetDlgItem(IDC_STATIC4) != NULL);
GetDlgItem(IDC_STATIC4)->EnableWindow(fill_.size_src == 0);
// Disable clipboard option if clipboard is empty or there is nothing there we can use
ASSERT(GetDlgItem(IDC_FILL_CLIPBOARD) != NULL);
GetDlgItem(IDC_FILL_CLIPBOARD)->EnableWindow(clipboard_format_ > 0);
// Hide "Prompt for file name" control if we are only in insert block mode
ASSERT(GetDlgItem(IDC_FILL_DISK) != NULL);
GetDlgItem(IDC_FILL_DISK)->ShowWindow(insert_block_mode_ ? SW_HIDE : SW_SHOW);
// Enable controls depending on type of fill selected
ctl_hex_value_.EnableWindow(fill_.type == FILL_HEX);
ctl_fill_string_value_.EnableWindow(fill_.type == FILL_STRING);
ctl_desc_fill_string_charset_.EnableWindow(fill_.type == FILL_STRING);
ctl_fill_string_charset_.EnableWindow(fill_.type == FILL_STRING);
ctl_fill_clipboard_sample_.EnableWindow(fill_.type == FILL_CLIPBOARD);
ctl_fill_clipboard_length_.EnableWindow(fill_.type == FILL_CLIPBOARD);
ctl_desc_fill_clipboard_length_.EnableWindow(fill_.type == FILL_CLIPBOARD);
ctl_fill_random_range_.EnableWindow(fill_.type == FILL_RANDOM);
ctl_fill_number_value_.EnableWindow(fill_.type == FILL_NUMBER);
ctl_desc_fill_number_type_.EnableWindow(fill_.type == FILL_NUMBER);
ctl_fill_number_type_.EnableWindow(fill_.type == FILL_NUMBER);
// ctl_desc_fill_number_format_.EnableWindow(fill_.type == FILL_NUMBER);
// ctl_fill_number_format_.EnableWindow(fill_.type == FILL_NUMBER);
ctl_big_endian_.EnableWindow(fill_.type == FILL_NUMBER && (fill_.number_is_float || fill_.number_type > 0));
// Fix number type drop down list depending on type of number entered
bool is_float = fill_number_value_.Find('.') != -1 ||
fill_number_value_.Find('e') != -1 ||
fill_number_value_.Find('E') != -1;
if (first_time_ || is_float != (bool)fill_.number_is_float)
{
if (is_float)
{
ctl_fill_number_type_.ResetContent();
ctl_fill_number_type_.AddString("32 bit IEEE");
ctl_fill_number_type_.AddString("64 bit IEEE");
if (fill_.number_type > 1) fill_.number_type = 1;
ctl_fill_number_type_.SetCurSel(fill_.number_type);
}
else
{
ctl_fill_number_type_.ResetContent();
ctl_fill_number_type_.AddString("8 bit int");
ctl_fill_number_type_.AddString("16 bit int");
ctl_fill_number_type_.AddString("32 bit int");
ctl_fill_number_type_.AddString("64 bit int");
ctl_fill_number_type_.SetCurSel(fill_.number_type);
}
fill_.number_is_float = is_float;
}
first_time_ = false;
calc_length();
}
/* ARGSUSED */
static enum clnt_stat
clnt_rdma_kcallit(CLIENT *h, rpcproc_t procnum, xdrproc_t xdr_args,
caddr_t argsp, xdrproc_t xdr_results, caddr_t resultsp,
struct timeval wait)
{
cku_private_t *p = htop(h);
int try_call_again;
int refresh_attempt = AUTH_REFRESH_COUNT;
int status;
int msglen;
XDR *call_xdrp, callxdr; /* for xdrrdma encoding the RPC call */
XDR *reply_xdrp, replyxdr; /* for xdrrdma decoding the RPC reply */
XDR *rdmahdr_o_xdrs, *rdmahdr_i_xdrs;
struct rpc_msg reply_msg;
rdma_registry_t *m;
struct clist *cl_sendlist;
struct clist *cl_recvlist;
struct clist *cl;
struct clist *cl_rpcmsg;
struct clist *cl_rdma_reply;
struct clist *cl_rpcreply_wlist;
struct clist *cl_long_reply;
rdma_buf_t rndup;
uint_t vers;
uint_t op;
uint_t off;
uint32_t seg_array_len;
uint_t long_reply_len;
uint_t rpcsec_gss;
uint_t gss_i_or_p;
CONN *conn = NULL;
rdma_buf_t clmsg;
rdma_buf_t rpcmsg;
rdma_chunkinfo_lengths_t rcil;
clock_t ticks;
bool_t wlist_exists_reply;
uint32_t rdma_credit = rdma_bufs_rqst;
RCSTAT_INCR(rccalls);
call_again:
bzero(&clmsg, sizeof (clmsg));
bzero(&rpcmsg, sizeof (rpcmsg));
bzero(&rndup, sizeof (rndup));
try_call_again = 0;
cl_sendlist = NULL;
cl_recvlist = NULL;
cl = NULL;
cl_rpcmsg = NULL;
cl_rdma_reply = NULL;
call_xdrp = NULL;
reply_xdrp = NULL;
wlist_exists_reply = FALSE;
cl_rpcreply_wlist = NULL;
cl_long_reply = NULL;
rcil.rcil_len = 0;
rcil.rcil_len_alt = 0;
long_reply_len = 0;
rw_enter(&rdma_lock, RW_READER);
m = (rdma_registry_t *)p->cku_rd_handle;
if (m->r_mod_state == RDMA_MOD_INACTIVE) {
/*
* If we didn't find a matching RDMA module in the registry
* then there is no transport.
*/
rw_exit(&rdma_lock);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
ticks = clnt_rdma_min_delay * drv_usectohz(1000000);
if (h->cl_nosignal == TRUE) {
delay(ticks);
} else {
if (delay_sig(ticks) == EINTR) {
p->cku_err.re_status = RPC_INTR;
p->cku_err.re_errno = EINTR;
}
}
return (RPC_CANTSEND);
}
/*
* Get unique xid
*/
if (p->cku_xid == 0)
p->cku_xid = alloc_xid();
status = RDMA_GET_CONN(p->cku_rd_mod->rdma_ops, &p->cku_srcaddr,
&p->cku_addr, p->cku_addrfmly, p->cku_rd_handle, &conn);
rw_exit(&rdma_lock);
/*
* If there is a problem with the connection reflect the issue
* back to the higher level to address, we MAY delay for a short
* period so that we are kind to the transport.
*/
if (conn == NULL) {
/*
* Connect failed to server. Could be because of one
* of several things. In some cases we don't want
* the caller to retry immediately - delay before
* returning to caller.
*/
switch (status) {
case RDMA_TIMEDOUT:
/*
* Already timed out. No need to delay
* some more.
*/
p->cku_err.re_status = RPC_TIMEDOUT;
p->cku_err.re_errno = ETIMEDOUT;
break;
case RDMA_INTR:
/*
* Failed because of an signal. Very likely
* the caller will not retry.
*/
p->cku_err.re_status = RPC_INTR;
p->cku_err.re_errno = EINTR;
break;
default:
/*
* All other failures - server down or service
* down or temporary resource failure. Delay before
* returning to caller.
*/
ticks = clnt_rdma_min_delay * drv_usectohz(1000000);
p->cku_err.re_status = RPC_CANTCONNECT;
p->cku_err.re_errno = EIO;
if (h->cl_nosignal == TRUE) {
delay(ticks);
} else {
if (delay_sig(ticks) == EINTR) {
p->cku_err.re_status = RPC_INTR;
p->cku_err.re_errno = EINTR;
}
}
break;
}
return (p->cku_err.re_status);
}
if (p->cku_srcaddr.maxlen < conn->c_laddr.len) {
if ((p->cku_srcaddr.maxlen != 0) &&
(p->cku_srcaddr.buf != NULL))
kmem_free(p->cku_srcaddr.buf, p->cku_srcaddr.maxlen);
p->cku_srcaddr.buf = kmem_zalloc(conn->c_laddr.maxlen,
KM_SLEEP);
p->cku_srcaddr.maxlen = conn->c_laddr.maxlen;
}
p->cku_srcaddr.len = conn->c_laddr.len;
bcopy(conn->c_laddr.buf, p->cku_srcaddr.buf, conn->c_laddr.len);
clnt_check_credit(conn);
status = CLNT_RDMA_FAIL;
rpcsec_gss = gss_i_or_p = FALSE;
if (IS_RPCSEC_GSS(h)) {
rpcsec_gss = TRUE;
if (rpc_gss_get_service_type(h->cl_auth) ==
rpc_gss_svc_integrity ||
rpc_gss_get_service_type(h->cl_auth) ==
rpc_gss_svc_privacy)
gss_i_or_p = TRUE;
}
/*
* Try a regular RDMA message if RPCSEC_GSS is not being used
* or if RPCSEC_GSS is being used for authentication only.
*/
if (rpcsec_gss == FALSE ||
(rpcsec_gss == TRUE && gss_i_or_p == FALSE)) {
/*
* Grab a send buffer for the request. Try to
* encode it to see if it fits. If not, then it
* needs to be sent in a chunk.
*/
rpcmsg.type = SEND_BUFFER;
if (rdma_buf_alloc(conn, &rpcmsg)) {
DTRACE_PROBE(krpc__e__clntrdma__callit_nobufs);
goto done;
}
/* First try to encode into regular send buffer */
op = RDMA_MSG;
call_xdrp = &callxdr;
xdrrdma_create(call_xdrp, rpcmsg.addr, rpcmsg.len,
rdma_minchunk, NULL, XDR_ENCODE, conn);
status = clnt_compose_rpcmsg(h, procnum, &rpcmsg, call_xdrp,
xdr_args, argsp);
if (status != CLNT_RDMA_SUCCESS) {
/* Clean up from previous encode attempt */
rdma_buf_free(conn, &rpcmsg);
XDR_DESTROY(call_xdrp);
} else {
XDR_CONTROL(call_xdrp, XDR_RDMA_GET_CHUNK_LEN, &rcil);
}
}
/* If the encode didn't work, then try a NOMSG */
if (status != CLNT_RDMA_SUCCESS) {
msglen = CKU_HDRSIZE + BYTES_PER_XDR_UNIT + MAX_AUTH_BYTES +
xdr_sizeof(xdr_args, argsp);
msglen = calc_length(msglen);
/* pick up the lengths for the reply buffer needed */
(void) xdrrdma_sizeof(xdr_args, argsp, 0,
&rcil.rcil_len, &rcil.rcil_len_alt);
/*
* Construct a clist to describe the CHUNK_BUFFER
* for the rpcmsg.
*/
cl_rpcmsg = clist_alloc();
cl_rpcmsg->c_len = msglen;
cl_rpcmsg->rb_longbuf.type = RDMA_LONG_BUFFER;
cl_rpcmsg->rb_longbuf.len = msglen;
if (rdma_buf_alloc(conn, &cl_rpcmsg->rb_longbuf)) {
clist_free(cl_rpcmsg);
goto done;
}
cl_rpcmsg->w.c_saddr3 = cl_rpcmsg->rb_longbuf.addr;
op = RDMA_NOMSG;
call_xdrp = &callxdr;
xdrrdma_create(call_xdrp, cl_rpcmsg->rb_longbuf.addr,
cl_rpcmsg->rb_longbuf.len, 0,
cl_rpcmsg, XDR_ENCODE, conn);
status = clnt_compose_rpcmsg(h, procnum, &rpcmsg, call_xdrp,
xdr_args, argsp);
if (status != CLNT_RDMA_SUCCESS) {
p->cku_err.re_status = RPC_CANTENCODEARGS;
p->cku_err.re_errno = EIO;
DTRACE_PROBE(krpc__e__clntrdma__callit__composemsg);
goto done;
}
}
/*
* During the XDR_ENCODE we may have "allocated" an RDMA READ or
* RDMA WRITE clist.
*
* First pull the RDMA READ chunk list from the XDR private
* area to keep it handy.
*/
XDR_CONTROL(call_xdrp, XDR_RDMA_GET_RLIST, &cl);
if (gss_i_or_p) {
long_reply_len = rcil.rcil_len + rcil.rcil_len_alt;
long_reply_len += MAX_AUTH_BYTES;
} else {
long_reply_len = rcil.rcil_len;
}
/*
* Update the chunk size information for the Long RPC msg.
*/
if (cl && op == RDMA_NOMSG)
cl->c_len = p->cku_outsz;
/*
* Prepare the RDMA header. On success xdrs will hold the result
* of xdrmem_create() for a SEND_BUFFER.
*/
status = clnt_compose_rdma_header(conn, h, &clmsg,
&rdmahdr_o_xdrs, &op);
if (status != CLNT_RDMA_SUCCESS) {
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
RCSTAT_INCR(rcnomem);
DTRACE_PROBE(krpc__e__clntrdma__callit__nobufs2);
goto done;
}
/*
* Now insert the RDMA READ list iff present
*/
status = clnt_setup_rlist(conn, rdmahdr_o_xdrs, call_xdrp);
if (status != CLNT_RDMA_SUCCESS) {
DTRACE_PROBE(krpc__e__clntrdma__callit__clistreg);
rdma_buf_free(conn, &clmsg);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
goto done;
}
/*
* Setup RDMA WRITE chunk list for nfs read operation
* other operations will have a NULL which will result
* as a NULL list in the XDR stream.
*/
status = clnt_setup_wlist(conn, rdmahdr_o_xdrs, call_xdrp, &rndup);
if (status != CLNT_RDMA_SUCCESS) {
rdma_buf_free(conn, &clmsg);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
goto done;
}
/*
* If NULL call and RPCSEC_GSS, provide a chunk such that
* large responses can flow back to the client.
* If RPCSEC_GSS with integrity or privacy is in use, get chunk.
*/
if ((procnum == 0 && rpcsec_gss == TRUE) ||
(rpcsec_gss == TRUE && gss_i_or_p == TRUE))
long_reply_len += 1024;
status = clnt_setup_long_reply(conn, &cl_long_reply, long_reply_len);
if (status != CLNT_RDMA_SUCCESS) {
rdma_buf_free(conn, &clmsg);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
goto done;
}
/*
* XDR encode the RDMA_REPLY write chunk
*/
seg_array_len = (cl_long_reply ? 1 : 0);
(void) xdr_encode_reply_wchunk(rdmahdr_o_xdrs, cl_long_reply,
seg_array_len);
/*
* Construct a clist in "sendlist" that represents what we
* will push over the wire.
*
* Start with the RDMA header and clist (if any)
*/
clist_add(&cl_sendlist, 0, XDR_GETPOS(rdmahdr_o_xdrs), &clmsg.handle,
clmsg.addr, NULL, NULL);
/*
* Put the RPC call message in sendlist if small RPC
*/
if (op == RDMA_MSG) {
clist_add(&cl_sendlist, 0, p->cku_outsz, &rpcmsg.handle,
rpcmsg.addr, NULL, NULL);
} else {
/* Long RPC already in chunk list */
RCSTAT_INCR(rclongrpcs);
}
/*
* Set up a reply buffer ready for the reply
*/
status = rdma_clnt_postrecv(conn, p->cku_xid);
if (status != RDMA_SUCCESS) {
rdma_buf_free(conn, &clmsg);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
goto done;
}
/*
* sync the memory for dma
*/
if (cl != NULL) {
status = clist_syncmem(conn, cl, CLIST_REG_SOURCE);
if (status != RDMA_SUCCESS) {
(void) rdma_clnt_postrecv_remove(conn, p->cku_xid);
rdma_buf_free(conn, &clmsg);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
goto done;
}
}
/*
* Send the RDMA Header and RPC call message to the server
*/
status = RDMA_SEND(conn, cl_sendlist, p->cku_xid);
if (status != RDMA_SUCCESS) {
(void) rdma_clnt_postrecv_remove(conn, p->cku_xid);
p->cku_err.re_status = RPC_CANTSEND;
p->cku_err.re_errno = EIO;
goto done;
}
/*
* RDMA plugin now owns the send msg buffers.
* Clear them out and don't free them.
*/
clmsg.addr = NULL;
if (rpcmsg.type == SEND_BUFFER)
rpcmsg.addr = NULL;
/*
* Recv rpc reply
*/
status = RDMA_RECV(conn, &cl_recvlist, p->cku_xid);
/*
* Now check recv status
*/
if (status != 0) {
if (status == RDMA_INTR) {
p->cku_err.re_status = RPC_INTR;
p->cku_err.re_errno = EINTR;
RCSTAT_INCR(rcintrs);
} else if (status == RPC_TIMEDOUT) {
p->cku_err.re_status = RPC_TIMEDOUT;
p->cku_err.re_errno = ETIMEDOUT;
RCSTAT_INCR(rctimeouts);
} else {
p->cku_err.re_status = RPC_CANTRECV;
p->cku_err.re_errno = EIO;
}
goto done;
}
/*
* Process the reply message.
*
* First the chunk list (if any)
*/
rdmahdr_i_xdrs = &(p->cku_inxdr);
xdrmem_create(rdmahdr_i_xdrs,
(caddr_t)(uintptr_t)cl_recvlist->w.c_saddr3,
cl_recvlist->c_len, XDR_DECODE);
/*
* Treat xid as opaque (xid is the first entity
* in the rpc rdma message).
* Skip xid and set the xdr position accordingly.
*/
XDR_SETPOS(rdmahdr_i_xdrs, sizeof (uint32_t));
(void) xdr_u_int(rdmahdr_i_xdrs, &vers);
(void) xdr_u_int(rdmahdr_i_xdrs, &rdma_credit);
(void) xdr_u_int(rdmahdr_i_xdrs, &op);
(void) xdr_do_clist(rdmahdr_i_xdrs, &cl);
clnt_update_credit(conn, rdma_credit);
wlist_exists_reply = FALSE;
if (! xdr_decode_wlist(rdmahdr_i_xdrs, &cl_rpcreply_wlist,
&wlist_exists_reply)) {
DTRACE_PROBE(krpc__e__clntrdma__callit__wlist_decode);
p->cku_err.re_status = RPC_CANTDECODERES;
p->cku_err.re_errno = EIO;
goto done;
}
/*
* The server shouldn't have sent a RDMA_SEND that
* the client needs to RDMA_WRITE a reply back to
* the server. So silently ignoring what the
* server returns in the rdma_reply section of the
* header.
*/
(void) xdr_decode_reply_wchunk(rdmahdr_i_xdrs, &cl_rdma_reply);
off = xdr_getpos(rdmahdr_i_xdrs);
clnt_decode_long_reply(conn, cl_long_reply,
cl_rdma_reply, &replyxdr, &reply_xdrp,
cl, cl_recvlist, op, off);
if (reply_xdrp == NULL)
goto done;
if (wlist_exists_reply) {
XDR_CONTROL(reply_xdrp, XDR_RDMA_SET_WLIST, cl_rpcreply_wlist);
}
reply_msg.rm_direction = REPLY;
reply_msg.rm_reply.rp_stat = MSG_ACCEPTED;
reply_msg.acpted_rply.ar_stat = SUCCESS;
reply_msg.acpted_rply.ar_verf = _null_auth;
/*
* xdr_results will be done in AUTH_UNWRAP.
*/
reply_msg.acpted_rply.ar_results.where = NULL;
reply_msg.acpted_rply.ar_results.proc = xdr_void;
/*
* Decode and validate the response.
*/
if (xdr_replymsg(reply_xdrp, &reply_msg)) {
enum clnt_stat re_status;
_seterr_reply(&reply_msg, &(p->cku_err));
re_status = p->cku_err.re_status;
if (re_status == RPC_SUCCESS) {
/*
* Reply is good, check auth.
*/
if (!AUTH_VALIDATE(h->cl_auth,
&reply_msg.acpted_rply.ar_verf)) {
p->cku_err.re_status = RPC_AUTHERROR;
p->cku_err.re_why = AUTH_INVALIDRESP;
RCSTAT_INCR(rcbadverfs);
DTRACE_PROBE(
krpc__e__clntrdma__callit__authvalidate);
} else if (!AUTH_UNWRAP(h->cl_auth, reply_xdrp,
xdr_results, resultsp)) {
p->cku_err.re_status = RPC_CANTDECODERES;
p->cku_err.re_errno = EIO;
DTRACE_PROBE(
krpc__e__clntrdma__callit__authunwrap);
}
} else {
/* set errno in case we can't recover */
if (re_status != RPC_VERSMISMATCH &&
re_status != RPC_AUTHERROR &&
re_status != RPC_PROGVERSMISMATCH)
p->cku_err.re_errno = EIO;
if (re_status == RPC_AUTHERROR) {
if ((refresh_attempt > 0) &&
AUTH_REFRESH(h->cl_auth, &reply_msg,
p->cku_cred)) {
refresh_attempt--;
try_call_again = 1;
goto done;
}
try_call_again = 0;
/*
* We have used the client handle to
* do an AUTH_REFRESH and the RPC status may
* be set to RPC_SUCCESS; Let's make sure to
* set it to RPC_AUTHERROR.
*/
p->cku_err.re_status = RPC_AUTHERROR;
/*
* Map recoverable and unrecoverable
* authentication errors to appropriate
* errno
*/
switch (p->cku_err.re_why) {
case AUTH_BADCRED:
case AUTH_BADVERF:
case AUTH_INVALIDRESP:
case AUTH_TOOWEAK:
case AUTH_FAILED:
case RPCSEC_GSS_NOCRED:
case RPCSEC_GSS_FAILED:
p->cku_err.re_errno = EACCES;
break;
case AUTH_REJECTEDCRED:
case AUTH_REJECTEDVERF:
default:
p->cku_err.re_errno = EIO;
break;
}
}
DTRACE_PROBE1(krpc__e__clntrdma__callit__rpcfailed,
int, p->cku_err.re_why);
}
} else {
/*
* If xp_wcl is NULL value, then the RPC payload will NOT carry
* an RDMA WRITE chunk list, in this case we insert FALSE into
* the XDR stream. Otherwise we use the clist and RDMA register
* the memory and encode the clist into the outbound XDR stream.
*/
static int
clnt_setup_wlist(CONN *conn, XDR *xdrs, XDR *call_xdrp, rdma_buf_t *rndbuf)
{
int status;
struct clist *wlist, *rndcl;
int wlen, rndlen;
int32_t xdr_flag = XDR_RDMA_WLIST_REG;
XDR_CONTROL(call_xdrp, XDR_RDMA_GET_WLIST, &wlist);
if (wlist != NULL) {
/*
* If we are sending a non 4-byte alligned length
* the server will roundup the length to 4-byte
* boundary. In such a case, a trailing chunk is
* added to take any spill over roundup bytes.
*/
wlen = clist_len(wlist);
rndlen = (roundup(wlen, BYTES_PER_XDR_UNIT) - wlen);
if (rndlen) {
rndcl = clist_alloc();
/*
* calc_length() will allocate a PAGESIZE
* buffer below.
*/
rndcl->c_len = calc_length(rndlen);
rndcl->rb_longbuf.type = RDMA_LONG_BUFFER;
rndcl->rb_longbuf.len = rndcl->c_len;
if (rdma_buf_alloc(conn, &rndcl->rb_longbuf)) {
clist_free(rndcl);
return (CLNT_RDMA_FAIL);
}
/* Roundup buffer freed back in caller */
*rndbuf = rndcl->rb_longbuf;
rndcl->u.c_daddr3 = rndcl->rb_longbuf.addr;
rndcl->c_next = NULL;
rndcl->c_dmemhandle = rndcl->rb_longbuf.handle;
wlist->c_next = rndcl;
}
status = clist_register(conn, wlist, CLIST_REG_DST);
if (status != RDMA_SUCCESS) {
rdma_buf_free(conn, rndbuf);
bzero(rndbuf, sizeof (rdma_buf_t));
return (CLNT_RDMA_FAIL);
}
XDR_CONTROL(call_xdrp, XDR_RDMA_SET_FLAGS, &xdr_flag);
}
if (!xdr_encode_wlist(xdrs, wlist)) {
if (rndlen) {
rdma_buf_free(conn, rndbuf);
bzero(rndbuf, sizeof (rdma_buf_t));
}
return (CLNT_RDMA_FAIL);
}
return (CLNT_RDMA_SUCCESS);
}
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);
}
