WebSVN - shark - Rev 3 - /shark/trunk/ports/mpg123/mpg123.c

/*
* Mpeg Layer audio decoder (see version.h for version number)
* ------------------------
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved.
* See also 'README' !
*
*/

#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>

/* #define SET_PRIO */

#include "mpg123.h"
#include "getlopt.h"

#include "version.h"

static void usage(char *dummy);
static void print_title(void);

static long rates[3][3] = {
{ 32000,44100,48000 } ,
{ 16000,22050,24000 } ,
{ 8000,11025,12000 }
};

int supported_rates = 0;

int outmode = DECODE_AUDIO;

char *listname = NULL;
long outscale = 32768;
int checkrange = FALSE;
int tryresync = TRUE;
int quiet = FALSE;
int verbose = 0;
int doublespeed= 0;
int halfspeed = 0;
int shuffle = 0;
int change_always = 1;
int force_8bit = 0;
int force_frequency = -1;
long numframes = -1;
long startFrame= 0;
int usebuffer = 0;
int frontend_type = 0;
int remote = 0;
int buffer_fd[2];
int buffer_pid;

static void catch_child(void)
{
while (waitpid(-1, NULL, WNOHANG) > 0);
}

static int intflag = FALSE;
static int remflag = FALSE;

static void catch_interrupt(void)
{
intflag = TRUE;
}

static char remote_buffer[1024];
static struct frame fr;
static struct audio_info_struct ai;
txfermem *buffermem;
#define FRAMEBUFUNIT (18 * 64 * 4)

void print_rheader(struct frame *fr);

static void catch_remote(void)
{
remflag = TRUE;
intflag = TRUE;
if(usebuffer)
kill(buffer_pid,SIGINT);
}

char *handle_remote(void)
{
switch(frontend_type) {
case FRONTEND_SAJBER:
#ifdef FRONTEND
control_sajber(&fr);
#endif
break;
case FRONTEND_TK3PLAY:
#ifdef FRONTEND
control_tk3play(&fr);
#endif
break;
default:
fgets(remote_buffer,1024,stdin);
remote_buffer[strlen(remote_buffer)-1]=0;

switch(remote_buffer[0]) {
case 'P':
return remote_buffer+1;
}

if(usebuffer)
kill(buffer_pid,SIGINT);
break;
}

return NULL;
}

void init_output(void)
{
static int init_done = FALSE;

if (init_done)
return;
init_done = TRUE;
#ifndef OS2
if (usebuffer) {
unsigned int bufferbytes;
sigset_t newsigset, oldsigset;

if (usebuffer < 32)
usebuffer = 32; /* minimum is 32 Kbytes! */
bufferbytes = (usebuffer * 1024);
bufferbytes -= bufferbytes % FRAMEBUFUNIT;
xfermem_init (&buffermem, bufferbytes, sizeof(ai.rate));
pcm_sample = (unsigned char *) buffermem->data;
pcm_point = 0;
sigemptyset (&newsigset);
sigaddset (&newsigset, SIGUSR1);
sigprocmask (SIG_BLOCK, &newsigset, &oldsigset);
catchsignal (SIGCHLD, catch_child);
switch ((buffer_pid = fork())) {
case -1: /* error */
perror("fork()");
exit(1);
case 0: /* child */
xfermem_init_reader (buffermem);
buffer_loop (&ai, &oldsigset);
xfermem_done_reader (buffermem);
xfermem_done (buffermem);
_exit(0);
default: /* parent */
xfermem_init_writer (buffermem);
outmode = DECODE_BUFFER;
}
}
else {
#endif
if (!(pcm_sample = (unsigned char *) malloc(audiobufsize * 2))) {
perror ("malloc()");
exit (1);
#ifndef OS2
}
#endif
}

if(outmode==DECODE_AUDIO) {
if(audio_open(&ai) < 0) {
perror("audio");
exit(1);
}
/* audio_set_rate (&ai); should already be done in audio_open() [OF] */
}
}

char *get_next_file (int argc, char *argv[])
{
static FILE *listfile = NULL;
static char line[1024];

#ifdef SHUFFLESUPPORT
static int ord[2048];
int temp, randomized,pos;
static char initialized=0;
time_t t;
#endif

if (remote)
return handle_remote();

if (listname || listfile) {
if (!listfile) {
if (!*listname || !strcmp(listname, "-")) {
listfile = stdin;
listname = NULL;
}
else if (!strncmp(listname, "http://", 7))
listfile = http_open(listname);
else if (!(listfile = fopen(listname, "rb"))) {
perror (listname);
exit (1);
}
if (verbose)
fprintf (stderr, "Using playlist from %s ...\n",
listname ? listname : "standard input");
}
do {
if (fgets(line, 1023, listfile)) {
line[strcspn(line, "\t\n\r")] = '\0';
if (line[0]=='\0' || line[0]=='#')
continue;
return (line);
}
else {
if (*listname)
fclose (listfile);
listname = NULL;
listfile = NULL;
}
} while (listfile);
}

#ifdef SHUFFLESUPPORT
if(!initialized){
for(pos=0;pos<=argc; pos++) ord[pos]=pos;
initialized=1;
}
if(shuffle){
fprintf(stderr, "\nShuffle play - %u file(s) in loop.\n", argc-loptind);
srandom(time(&t));
for(pos=loptind;pos<argc;pos++){
randomized=(random()%(argc-pos))+pos;
temp=ord[pos];
ord[pos]=ord[randomized];
ord[randomized]=temp;
}
shuffle=0;
}
if (loptind < argc)
return (argv[ord[loptind++]]);
return (NULL);
#else
if (loptind < argc)
return (argv[loptind++]);
return (NULL);
#endif
}

void set_synth (char *arg)
{
if (*arg == '2') {
fr.down_sample = 1;
}
else {
fr.down_sample = 2;
}
}

#ifdef VARMODESUPPORT
void set_varmode (char *arg)
{
audiobufsize = ((audiobufsize >> 1) + 63) & 0xffffc0;
}
#endif

void set_output (char *arg)
{
switch (*arg) {
case 'h': ai.output = AUDIO_OUT_HEADPHONES; break;
case 's': ai.output = AUDIO_OUT_INTERNAL_SPEAKER; break;
case 'l': ai.output = AUDIO_OUT_LINE_OUT; break;
default:
fprintf (stderr, "%s: Unknown argument \"%s\" to option \"%s\".\n",
prgName, arg, loptarg);
exit (1);
}
}

void set_verbose (char *arg)
{
verbose++;
}

topt opts[] = {
{'k', "skip", GLO_ARG | GLO_NUM, 0, &startFrame, 0},
{'a', "audiodevice", GLO_ARG | GLO_CHAR, 0, &ai.device, 0},
{'2', "2to1", 0, set_synth, 0, 0},
{'4', "4to1", 0, set_synth, 0, 0},
{'t', "test", 0, 0, &outmode, DECODE_TEST},
{'s', "stdout", 0, 0, &outmode, DECODE_STDOUT},
{'c', "check", 0, 0, &checkrange, TRUE},
{'v', "verbose", 0, set_verbose, 0, 0},
{'q', "quiet", 0, 0, &quiet, TRUE},
{'y', "resync", 0, 0, &tryresync, FALSE},
{'0', "single0", 0, 0, &fr.single, 0},
{0, "left", 0, 0, &fr.single, 0},
{'1', "single1", 0, 0, &fr.single, 1},
{0, "right", 0, 0, &fr.single, 1},
{'m', "singlemix", 0, 0, &fr.single, 3},
{0, "mix", 0, 0, &fr.single, 3},
{'g', "gain", GLO_ARG | GLO_NUM, 0, &ai.gain, 0},
{'r', "rate", GLO_ARG | GLO_NUM, 0, &force_frequency, 0},
{0, "8bit", 0, 0, &force_8bit, 1},
{0, "headphones", 0, 0, &ai.output, AUDIO_OUT_HEADPHONES},
{0, "speaker", 0, 0, &ai.output, AUDIO_OUT_INTERNAL_SPEAKER},
{0, "lineout", 0, 0, &ai.output, AUDIO_OUT_LINE_OUT},
{'o', "output", GLO_ARG | GLO_CHAR, set_output, 0, 0},
{'f', "scale", GLO_ARG | GLO_NUM, 0, &outscale, 0},
{'n', "frames", GLO_ARG | GLO_NUM, 0, &numframes, 0},
#ifdef VARMODESUPPORT
{'v', "var", 0, set_varmode, &varmode, TRUE},
#endif
{'b', "buffer", GLO_ARG | GLO_NUM, 0, &usebuffer, 0},
{'R', "remote", 0, 0, &remote, TRUE},
{'d', "doublespeed", GLO_ARG | GLO_NUM, 0, &doublespeed,0},
{'h', "halfspeed", GLO_ARG | GLO_NUM, 0, &halfspeed, 0},
{'p', "proxy", GLO_ARG | GLO_CHAR, 0, &proxyurl, 0},
{'@', "list", GLO_ARG | GLO_CHAR, 0, &listname, 0},
#ifdef SHUFFLESUPPORT
/* 'z' comes from the the german word 'zufall' (eng: random) */
{'z', "shuffle", 0, 0, &shuffle, 1},
#endif
{'?', "help", 0, usage, 0, 0},
{0, 0, 0, 0, 0, 0}
};

/*
* Change the playback sample rate.
*/
static void reset_audio_samplerate(void)
{
if (usebuffer) {
/* wait until the buffer is empty,
* then tell the buffer process to
* change the sample rate. [OF]
*/
while (xfermem_get_usedspace(buffermem) > 0)
if (xfermem_block(XF_WRITER, buffermem) == XF_CMD_TERMINATE) {
intflag = TRUE;
break;
}
buffermem->freeindex = -1;
buffermem->readindex = 0; /* I know what I'm doing! ;-) */
buffermem->freeindex = 0;
if (intflag)
return;
memcpy (buffermem->metadata, &ai.rate, sizeof(ai.rate));
kill (buffer_pid, SIGUSR1);
}
else if (outmode == DECODE_AUDIO) {
/* audio_reset_parameters(&ai); */
/* close and re-open in order to flush
* the device's internal buffer before
* changing the sample rate. [OF]
*/
audio_close (&ai);
if (audio_open(&ai) < 0) {
perror("audio");
exit(1);
}
}
}

/*
* play a frame read read_frame();
* (re)initialize audio if necessary.
*/
void play_frame(int init,struct frame *fr)
{
int clip;

if((fr->header_change && change_always) || init) {
int reset_audio = 0;

if(remote)
print_rheader(fr);

if (!quiet && init)
if (verbose)
print_header(fr);
else
print_header_compact(fr);

if(force_frequency < 0) {
if(ai.rate != freqs[fr->sampling_frequency]>>(fr->down_sample)) {
ai.rate = freqs[fr->sampling_frequency]>>(fr->down_sample);
reset_audio = 1;
}
}
else if(ai.rate != force_frequency) {
ai.rate = force_frequency;
reset_audio = 1;
}
init_output();
if(reset_audio) {
reset_audio_samplerate();
if (intflag)
return;
}
}

if (fr->error_protection) {
getbits(16); /* crc */
}

clip = (fr->do_layer)(fr,outmode,&ai);

#ifndef OS2
if (usebuffer) {
if (!intflag) {
buffermem->freeindex =
(buffermem->freeindex + pcm_point) % buffermem->size;
if (buffermem->wakeme[XF_READER])
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP);
}
pcm_sample = (unsigned char *) (buffermem->data + buffermem->freeindex);
pcm_point = 0;
while (xfermem_get_freespace(buffermem) < (FRAMEBUFUNIT << 1))
if (xfermem_block(XF_WRITER, buffermem) == XF_CMD_TERMINATE) {
intflag = TRUE;
break;
}
if (intflag)
return;
}
#endif

if(clip > 0 && checkrange)
fprintf(stderr,"%d samples clipped\n", clip);
}

int main(int argc, char *argv[])
{
int result;
unsigned long frameNum = 0;
char *fname;
struct timeval start_time, now;
unsigned long secdiff;
int init;

#ifdef OS2
_wildcard(&argc,&argv);
#endif

#ifdef SET_PRIO
int mypid = getpid();
setpriority(PRIO_PROCESS,mypid,-20);
#endif

if(!strcmp("sajberplay",argv[0]))
frontend_type = FRONTEND_SAJBER;
if(!strcmp("mpg123m",argv[0]))
frontend_type = FRONTEND_TK3PLAY;

fr.single = -1; /* both channels */
fr.synth = synth_1to1;
fr.down_sample = 0;

ai.format = AUDIO_FORMAT_SIGNED_16;
ai.gain = ai.rate = ai.output = -1;
ai.device = NULL;
ai.channels = 2;

(prgName = strrchr(argv[0], '/')) ? prgName++ : (prgName = argv[0]);

while ((result = getlopt(argc, argv, opts)))
switch (result) {
case GLO_UNKNOWN:
fprintf (stderr, "%s: Unknown option \"%s\".\n", prgName, loptarg);
exit (1);
case GLO_NOARG:
fprintf (stderr, "%s: Missing argument for option \"%s\".\n",
prgName, loptarg);
exit (1);
}
if (loptind >= argc && !listname && !frontend_type)
usage(NULL);

if (remote){
verbose = 0;
quiet = 1;
catchsignal(SIGUSR1, catch_remote);
fprintf(stderr,"@R MPG123\n");
}

if (!quiet)
print_title();

{
int fmts;
int i,j;

struct audio_info_struct ai;

audio_info_struct_init(&ai);
if (outmode == DECODE_AUDIO) {
audio_open(&ai);
fmts = audio_get_formats(&ai);
}
else
fmts = AUDIO_FORMAT_SIGNED_16;

supported_rates = 0;
for(i=0;i<3;i++) {
for(j=0;j<3;j++) {
ai.rate = rates[i][j];
if (outmode == DECODE_AUDIO)
audio_rate_best_match(&ai);
/* allow about 2% difference */
if( ((rates[i][j]*98) < (ai.rate*100)) &&
((rates[i][j]*102) > (ai.rate*100)) )
supported_rates |= 1<<(i*3+j);
}
}

if (outmode == DECODE_AUDIO)
audio_close(&ai);

if(!force_8bit && !(fmts & AUDIO_FORMAT_SIGNED_16))
force_8bit = 1;

if(force_8bit && !(fmts & AUDIO_FORMAT_ULAW_8)) {
fprintf(stderr,"No supported audio format found!\n");
exit(1);
}
}

if(force_8bit) {
#if 0
ai.format = AUDIO_FORMAT_UNSIGNED_8;
ai.format = AUDIO_FORMAT_SIGNED_8;
#endif
ai.format = AUDIO_FORMAT_ULAW_8;
make_conv16to8_table(ai.format);
switch(fr.down_sample) {
case 0:
fr.synth = synth_1to1_8bit;
fr.synth_mono = synth_1to1_8bit_mono;
fr.block_size = 64;
break;
case 1:
fr.synth = synth_2to1_8bit;
fr.synth_mono = synth_2to1_8bit_mono;
fr.block_size = 32;
break;
case 2:
fr.synth = synth_4to1_8bit;
fr.synth_mono = synth_4to1_8bit_mono;
fr.block_size = 16;
break;
}
}
else {
switch(fr.down_sample) {
case 0:
fr.synth = synth_1to1;
fr.synth_mono = synth_1to1_mono;
fr.block_size = 128;
break;
case 1:
fr.synth = synth_2to1;
fr.synth_mono = synth_2to1_mono;
fr.block_size = 64;
break;
case 2:
fr.synth = synth_4to1;
fr.synth_mono = synth_4to1_mono;
fr.block_size = 32;
break;
}
}

make_decode_tables(outscale);
init_layer2(); /* inits also shared tables with layer1 */
init_layer3(fr.down_sample);
catchsignal (SIGINT, catch_interrupt);

if(frontend_type) {
handle_remote();
exit(0);
}

while ((fname = get_next_file(argc, argv))) {
char *dirname, *filename;

if(!*fname || !strcmp(fname, "-"))
fname = NULL;
open_stream(fname,-1);

if (!quiet) {
if (split_dir_file(fname ? fname : "standard input",
&dirname, &filename))
fprintf(stderr, "\nDirectory: %s", dirname);
fprintf(stderr, "\nPlaying MPEG stream from %s ...\n", filename);
}

gettimeofday (&start_time, NULL);
read_frame_init();

init = 1;
for(frameNum=0;read_frame(&fr) && numframes && !intflag;frameNum++) {
if(frameNum < startFrame || (doublespeed && (frameNum % doublespeed))) {
if(fr.lay == 3)
set_pointer(512);
continue;
}
numframes--;
play_frame(init,&fr);
init = 0;
if(verbose) {
if (verbose > 1 || !(frameNum & 0xf))
fprintf(stderr, "\r{%4lu} ",frameNum);
#ifndef OS2
if (verbose > 1 && usebuffer)
fprintf (stderr, "%7d ", xfermem_get_usedspace(buffermem));
#endif
}

}

close_stream();
if (!quiet) {
/* This formula seems to work at least for
* MPEG 1.0/2.0 layer 3 streams.
*/
int sfd = freqs[fr.sampling_frequency] * (fr.lsf + 1);
int secs = (frameNum * (fr.lay==1 ? 384 : 1152) + sfd / 2) / sfd;
fprintf(stderr,"[%d:%02d] Decoding of %s finished.\n", secs / 60,
secs % 60, filename);
}

if(remote)
fprintf(stderr,"@R MPG123\n");
if (remflag) {
intflag = FALSE;
remflag = FALSE;
}

if (intflag) {
gettimeofday (&now, NULL);
secdiff = (now.tv_sec - start_time.tv_sec) * 1000;
if (now.tv_usec >= start_time.tv_usec)
secdiff += (now.tv_usec - start_time.tv_usec) / 1000;
else
secdiff -= (start_time.tv_usec - now.tv_usec) / 1000;
if (secdiff < 1000)
break;
intflag = FALSE;
}
}
#ifndef OS2
if (usebuffer) {
xfermem_done_writer (buffermem);
waitpid (buffer_pid, NULL, 0);
xfermem_done (buffermem);
}
else {
#endif
audio_flush(outmode, &ai);
free (pcm_sample);
#ifndef OS2
}
#endif

if(outmode==DECODE_AUDIO)
audio_close(&ai);
exit( 0 );
}

static void print_title(void)
{
fprintf(stderr,"High Performance MPEG 1.0/2.0 Audio Player for Layer 1, 2 and 3.\n");
fprintf(stderr,"Version %s (%s). Written and copyrights by Michael Hipp.\n", prgVersion, prgDate);
fprintf(stderr,"Uses code from various people. See 'README' for more!\n");
fprintf(stderr,"THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! USE AT YOUR OWN RISK!\n");
}

static void usage(char *dummy) /* print syntax & exit */
{
print_title();
fprintf(stderr,"\nusage: %s [option(s)] [file(s) | URL(s) | -]\n", prgName);
fprintf(stderr,"supported options [defaults in brackets]:\n");
fprintf(stderr," -v increase verbosity level -q quiet (don't print title)\n");
fprintf(stderr," -t testmode (no output) -s write to stdout\n");
fprintf(stderr," -k n skip first n frames [0] -n n decode only n frames [all]\n");
fprintf(stderr," -c check range violations -y DISABLE resync on errors\n");
fprintf(stderr," -b n output buffer: n Kbytes [0] -f n change scalefactor [32768]\n");
fprintf(stderr," -r n override samplerate [auto] -g n set audio hardware output gain\n");
fprintf(stderr," -os output to built-in speaker -oh output to headphones\n");
fprintf(stderr," -ol output to line-out connector -a d set audio device\n");
fprintf(stderr," -2 downsample 1:2 (22 kHz) -4 downsample 1:4 (11 kHz)\n");
fprintf(stderr," -d n play every n'th frame only -h n play every frame n times\n");
fprintf(stderr," -0 decode channel 0 (left) only -1 decode channel 1 (right) only\n");
fprintf(stderr," -m mix both channels (mono) -p p use HTTP proxy p [$HTTP_PROXY]\n");
fprintf(stderr," -@ f read filenames/URLs from f -z shuffle play (with wildcards)\n");
fprintf(stderr,"See the manpage %s(1) for more information.\n", prgName);
exit(1);
}

Subversion Repositories shark

(root)/shark/trunk/ports/mpg123/mpg123.c @ 880 - Rev 3