Subversion Repositories shark

/*

 * 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);

}