minmad.c

   1 /*
   2  * minmad - a minimal mp3 player using libmad and oss
   3  *
   4  * Copyright (C) 2009-2013 Ali Gholami Rudi
   5  *
   6  * This program is released under the modified BSD license.
   7  */
   8 #include <ctype.h>
   9 #include <fcntl.h>
  10 #include <pty.h>
  11 #include <signal.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/stat.h>
  16 #include <sys/mman.h>
  17 #include <sys/poll.h>
  18 #include <termios.h>
  19 #include <unistd.h>
  20 #include <sys/soundcard.h>
  21 #include <mad.h>
  22
  23 #define CTRLKEY(x)              ((x) - 96)
  24 #define MIN(a, b)       ((a) < (b) ? (a) : (b))
  25 #define MAX(a, b)       ((a) > (b) ? (a) : (b))
  26 #define JMP3            600
  27 #define JMP2            60
  28 #define JMP1            10
  29
  30 static struct mad_decoder decoder;
  31 static struct termios termios;
  32 static int afd;                 /* oss fd */
  33
  34 static char filename[1 << 12];
  35 static unsigned char *mem;
  36 static long len;
  37 static long pos;
  38 static int frame_sz;            /* frame size */
  39 static int frame_ms;            /* frame duration in milliseconds */
  40 static int played;              /* playing time in milliseconds */
  41 static int rate;
  42
  43 static int exited;
  44 static int paused;
  45 static int count;
  46
  47 static int oss_open(void)
  48 {
  49         afd = open("/dev/dsp", O_WRONLY);
  50         return afd < 0;
  51 }
  52
  53 static void oss_close(void)
  54 {
  55         if (afd > 0)            /* zero fd is used for input */
  56                 close(afd);
  57         afd = 0;
  58         rate = 0;
  59 }
  60
  61 static void oss_conf(void)
  62 {
  63         int ch = 2;
  64         int bits = 16;
  65         ioctl(afd, SOUND_PCM_WRITE_CHANNELS, &ch);
  66         ioctl(afd, SOUND_PCM_WRITE_BITS, &bits);
  67         ioctl(afd, SOUND_PCM_WRITE_RATE, &rate);
  68 }
  69
  70 static int readkey(void)
  71 {
  72         char b;
  73         if (read(0, &b, 1) <= 0)
  74                 return -1;
  75         return b;
  76 }
  77
  78 static void updatepos(void)
  79 {
  80         int sz, ms;
  81         if (decoder.sync) {
  82                 pos = decoder.sync->stream.this_frame - mem;
  83                 sz = decoder.sync->stream.next_frame -
  84                         decoder.sync->stream.this_frame;
  85                 ms = mad_timer_count(decoder.sync->frame.header.duration,
  86                                         MAD_UNITS_MILLISECONDS);
  87                 frame_ms = frame_ms ? ((frame_ms << 5) - frame_ms + ms) >> 5 : ms;
  88                 frame_sz = frame_sz ? ((frame_sz << 5) - frame_sz + sz) >> 5 : sz;
  89         }
  90 }
  91
  92 static void printinfo(void)
  93 {
  94         int per = pos * 1000.0 / len;
  95         int loc = pos / frame_sz * frame_ms / 1000;
  96         printf("%c %02d.%d%%  (%d:%02d:%02d - %04d.%ds)   [%s]\r",
  97                 paused ? (afd < 0 ? '*' : ' ') : '>',
  98                 per / 10, per % 10,
  99                 loc / 3600, (loc % 3600) / 60, loc % 60,
 100                 played / 1000, (played / 100) % 10,
 101                 filename);
 102         fflush(stdout);
 103 }
 104
 105 static int getcount(int def)
 106 {
 107         int result = count ? count : def;
 108         count = 0;
 109         return result;
 110 }
 111
 112 static void seek(int n)
 113 {
 114         int diff = n * frame_sz * 1000 / (frame_ms ? frame_ms : 40);
 115         pos = MAX(0, MIN(len, pos + diff));
 116 }
 117
 118 static void seek_thousands(int n)
 119 {
 120         pos = len * (float) n / 1000;
 121         pos -= pos % frame_sz;
 122 }
 123
 124 static int execkey(void)
 125 {
 126         int c;
 127         updatepos();
 128         while ((c = readkey()) != -1) {
 129                 switch (c) {
 130                 case 'J':
 131                         seek(JMP3 * getcount(1));
 132                         return 1;
 133                 case 'K':
 134                         seek(-JMP3 * getcount(1));
 135                         return 1;
 136                 case 'j':
 137                         seek(JMP2 * getcount(1));
 138                         return 1;
 139                 case 'k':
 140                         seek(-JMP2 * getcount(1));
 141                         return 1;
 142                 case 'l':
 143                         seek(JMP1 * getcount(1));
 144                         return 1;
 145                 case 'h':
 146                         seek(-JMP1 * getcount(1));
 147                         return 1;
 148                 case '%':
 149                         seek_thousands(getcount(0) * 10);
 150                         return 1;
 151                 case 'i':
 152                         printinfo();
 153                         break;
 154                 case 'p':
 155                 case ' ':
 156                         if (paused)
 157                                 if (oss_open())
 158                                         break;
 159                         if (!paused)
 160                                 oss_close();
 161                         paused = !paused;
 162                         return 1;
 163                 case 'q':
 164                         exited = 1;
 165                         return 1;
 166                 case 27:
 167                         count = 0;
 168                         break;
 169                 default:
 170                         if (isdigit(c))
 171                                 count = count * 10 + c - '0';
 172                 }
 173         }
 174         return 0;
 175 }
 176
 177 static enum mad_flow input(void *data, struct mad_stream *stream)
 178 {
 179         static unsigned long cpos;
 180         if (pos && pos == cpos) {
 181                 exited = 1;
 182                 return MAD_FLOW_STOP;
 183         }
 184         cpos = pos;
 185         mad_stream_buffer(stream, mem + pos, len - pos);
 186         return MAD_FLOW_CONTINUE;
 187 }
 188
 189 static signed int scale(mad_fixed_t sample)
 190 {
 191         /* round */
 192         sample += (1L << (MAD_F_FRACBITS - 16));
 193         /* clip */
 194         if (sample >= MAD_F_ONE)
 195                 sample = MAD_F_ONE - 1;
 196         else if (sample < -MAD_F_ONE)
 197                 sample = -MAD_F_ONE;
 198         /* quantize */
 199         return sample >> (MAD_F_FRACBITS + 1 - 16);
 200 }
 201
 202 static void push_sample(char *buf, mad_fixed_t sample)
 203 {
 204         *buf++ = (sample >> 0) & 0xff;
 205         *buf++ = (sample >> 8) & 0xff;
 206 }
 207
 208 static char mixed[1 << 20];
 209 static enum mad_flow output(void *data,
 210                          struct mad_header const *header,
 211                          struct mad_pcm *pcm)
 212 {
 213         int i;
 214         int right = pcm->channels > 1 ? 1 : 0;
 215         played += mad_timer_count(decoder.sync->frame.header.duration,
 216                                         MAD_UNITS_MILLISECONDS);
 217         for (i = 0; i < pcm->length; i++) {
 218                 push_sample(mixed + i * 4, scale(pcm->samples[0][i]));
 219                 push_sample(mixed + i * 4 + 2, scale(pcm->samples[right][i]));
 220         }
 221         if (header->samplerate != rate) {
 222                 rate = header->samplerate;
 223                 oss_conf();
 224         }
 225         write(afd, mixed, pcm->length * 4);
 226         return execkey() ? MAD_FLOW_STOP : MAD_FLOW_CONTINUE;
 227 }
 228
 229 static enum mad_flow error(void *data,
 230                                 struct mad_stream *stream,
 231                                 struct mad_frame *frame)
 232 {
 233         return MAD_FLOW_CONTINUE;
 234 }
 235
 236 static void waitkey(void)
 237 {
 238         struct pollfd ufds[1];
 239         ufds[0].fd = 0;
 240         ufds[0].events = POLLIN;
 241         poll(ufds, 1, -1);
 242 }
 243
 244 static void decode(void)
 245 {
 246         mad_decoder_init(&decoder, NULL, input, 0, 0, output, error, 0);
 247         while (!exited) {
 248                 if (paused) {
 249                         waitkey();
 250                         execkey();
 251                 } else {
 252                         mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
 253                 }
 254         }
 255         mad_decoder_finish(&decoder);
 256 }
 257
 258 static void term_setup(void)
 259 {
 260         struct termios newtermios;
 261         tcgetattr(0, &termios);
 262         newtermios = termios;
 263         newtermios.c_lflag &= ~ICANON;
 264         newtermios.c_lflag &= ~ECHO;
 265         tcsetattr(0, TCSAFLUSH, &newtermios);
 266         fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 267 }
 268
 269 static void term_cleanup(void)
 270 {
 271         tcsetattr(0, 0, &termios);
 272 }
 273
 274 static void sigcont(int sig)
 275 {
 276         term_setup();
 277 }
 278
 279 int main(int argc, char *argv[])
 280 {
 281         struct stat stat;
 282         int fd;
 283         if (argc < 2)
 284                 return 1;
 285         fd = open(argv[1], O_RDONLY);
 286         strcpy(filename, argv[1]);
 287         filename[30] = '\0';
 288         if (fstat(fd, &stat) == -1 || stat.st_size == 0)
 289                 return 1;
 290         mem = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, fd, 0);
 291         len = stat.st_size;
 292         if (mem == MAP_FAILED)
 293                 return 1;
 294         term_setup();
 295         signal(SIGCONT, sigcont);
 296         if (oss_open()) {
 297                 fprintf(stderr, "minmad: /dev/dsp busy?\n");
 298                 return 1;
 299         }
 300         decode();
 301         oss_close();
 302         term_cleanup();
 303         munmap(mem, stat.st_size);
 304         close(fd);
 305         printf("\n");
 306         return 0;
 307 }