chiark - git - mdw - disorder/blob - plugins/tracklength.c

   1 /*
   2  * This file is part of DisOrder.
   3  * Portions copyright (C) 2004, 2005 Richard Kettlewell (see also below)
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20
  21 #include <config.h>
  22
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <math.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <sys/mman.h>
  31 #include <errno.h>
  32
  33 #include <vorbis/vorbisfile.h>
  34 #include <mad.h>
  35
  36 #include <disorder.h>
  37
  38 #include "madshim.h"
  39
  40 static void *mmap_file(const char *path, size_t *lengthp) {
  41   int fd;
  42   void *base;
  43   struct stat sb;
  44
  45   if((fd = open(path, O_RDONLY)) < 0) {
  46     disorder_error(errno, "error opening %s", path);
  47     return 0;
  48   }
  49   if(fstat(fd, &sb) < 0) {
  50     disorder_error(errno, "error calling stat on %s", path);
  51     goto error;
  52   }
  53   if(sb.st_size == 0)                   /* can't map 0-length files */
  54     goto error;
  55   if((base = mmap(0, sb.st_size, PROT_READ,
  56                   MAP_SHARED, fd, 0)) == (void *)-1) {
  57     disorder_error(errno, "error calling mmap on %s", path);
  58     goto error;
  59   }
  60   *lengthp = sb.st_size;
  61   close(fd);
  62   return base;
  63 error:
  64   close(fd);
  65   return 0;
  66 }
  67
  68 static long tl_mp3(const char *path) {
  69   size_t length;
  70   void *base;
  71   buffer b;
  72
  73   if(!(base = mmap_file(path, &length))) return -1;
  74   b.duration = mad_timer_zero;
  75   scan_mp3(base, length, &b);
  76   munmap(base, length);
  77   return b.duration.seconds + !!b.duration.fraction;
  78 }
  79
  80 static long tl_ogg(const char *path) {
  81   OggVorbis_File vf;
  82   FILE *fp = 0;
  83   double length;
  84
  85   if(!path) goto error;
  86   if(!(fp = fopen(path, "rb"))) goto error;
  87   if(ov_open(fp, &vf, 0, 0)) goto error;
  88   fp = 0;
  89   length = ov_time_total(&vf, -1);
  90   ov_clear(&vf);
  91   return ceil(length);
  92 error:
  93   if(fp) fclose(fp);
  94   return -1;
  95 }
  96
  97 static long tl_wav(const char *path) {
  98   size_t length;
  99   void *base;
 100   long duration = -1;
 101   unsigned char *ptr;
 102   unsigned n, m, data_bytes = 0, samples_per_second = 0;
 103   unsigned n_channels = 0, bits_per_sample = 0, sample_point_size;
 104   unsigned sample_frame_size, n_samples;
 105
 106   /* Sources:
 107    *
 108    * http://www.technology.niagarac.on.ca/courses/comp530/WavFileFormat.html
 109    * http://www.borg.com/~jglatt/tech/wave.htm
 110    * http://www.borg.com/~jglatt/tech/aboutiff.htm
 111    *
 112    * These files consists of a header followed by chunks.
 113    * Multibyte values are little-endian.
 114    *
 115    * 12 byte file header:
 116    *  offset  size  meaning
 117    *  00      4     'RIFF'
 118    *  04      4     length of rest of file
 119    *  08      4     'WAVE'
 120    *
 121    * The length includes 'WAVE' but excludes the 1st 8 bytes.
 122    *
 123    * Chunk header:
 124    *  00      4     chunk ID
 125    *  04      4     length of rest of chunk
 126    *
 127    * The stated length may be odd, if so then there is an implicit padding byte
 128    * appended to the chunk to make it up to an even length (someone wasn't
 129    * think about 32/64-bit worlds).
 130    *
 131    * Also some files seem to have extra stuff at the end of chunks that nobody
 132    * I know of documents.  Go figure, but check the length field rather than
 133    * deducing the length from the ID.
 134    *
 135    * Format chunk:
 136    *  00      4     'fmt'
 137    *  04      4     length of rest of chunk
 138    *  08      2     compression (1 = none)
 139    *  0a      2     number of channels
 140    *  0c      4     samples/second
 141    *  10      4     average bytes/second, = (samples/sec) * (bytes/sample)
 142    *  14      2     bytes/sample
 143    *  16      2     bits/sample point
 144    *
 145    * 'sample' means 'sample frame' above, i.e. a sample point for each channel.
 146    *
 147    * Data chunk:
 148    *  00      4     'data'
 149    *  04      4     length of rest of chunk
 150    *  08      ...   data
 151    *
 152    * There is only allowed to be one data chunk.  Some people violate this; we
 153    * shall encourage people to fix their broken WAV files by not supporting
 154    * this violation and because it's easier.
 155    *
 156    * As to the encoding of the data:
 157    *
 158    * Firstly, samples up to 8 bits in size are unsigned, larger samples are
 159    * signed.  Madness.
 160    *
 161    * Secondly sample points are stored rounded up to a multiple of 8 bits in
 162    * size.  Marginally saner.
 163    *
 164    * Written as a single word (of 8, 16, 24, whatever bits) the padding to
 165    * implement this happens at the right hand (least significant) end.
 166    * e.g. assuming a 9 bit sample:
 167    *
 168    * |                 padded sample word              |
 169    * | 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 |
 170    * |  8  7  6  5  4  3  2  1  0  -  -  -  -  -  -  - |
 171    *
 172    * But this is a little-endian file format so the least significant byte is
 173    * the first, which means that the padding is "between" the bits if you
 174    * imagine them in their usual order:
 175    *
 176    *  |     first byte         |     second byte        |
 177    *  | 7  6  5  4  3  2  1  0 | 7  6  5  4  3  2  1  0 |
 178    *  | 0  -  -  -  -  -  -  - | 8  7  6  5  4  3  2  1 |
 179    *
 180    * Sample points are grouped into sample frames, consisting of as many
 181    * samples points as their are channels.  It seems that there are standard
 182    * orderings of different channels.
 183    *
 184    * Given all of the above all we need to do is pick up some numbers from the
 185    * format chunk, and the length of the data chunk, and do some arithmetic.
 186    */
 187   if(!(base = mmap_file(path, &length))) return -1;
 188 #define get16(p) ((p)[0] + 256 * (p)[1])
 189 #define get32(p) ((p)[0] + 256 * ((p)[1] + 256 * ((p)[2] + 256 * (p)[3])))
 190   ptr = base;
 191   if(length < 12) goto out;
 192   if(strncmp((char *)ptr, "RIFF", 4)) goto out; /* wrong type */
 193   n = get32(ptr + 4);                   /* file length */
 194   if(n > length - 8) goto out;          /* truncated */
 195   ptr += 8;                             /* skip file header */
 196   if(n < 4 || strncmp((char *)ptr, "WAVE", 4)) goto out; /* wrong type */
 197   ptr += 4;                             /* skip 'WAVE' */
 198   n -= 4;
 199   while(n >= 8) {
 200     m = get32(ptr + 4);                 /* chunk length */
 201     if(m > n - 8) goto out;             /* truncated */
 202     if(!strncmp((char *)ptr, "fmt ", 4)) {
 203       if(samples_per_second) goto out;  /* duplicate format chunk! */
 204       n_channels = get16(ptr + 0x0a);
 205       samples_per_second = get32(ptr + 0x0c);
 206       bits_per_sample = get16(ptr + 0x16);
 207       if(!samples_per_second) goto out; /* bogus! */
 208     } else if(!strncmp((char *)ptr, "data", 4)) {
 209       if(data_bytes) goto out;          /* multiple data chunks! */
 210       data_bytes = m;                   /* remember data size */
 211     }
 212     m += 8;                             /* include chunk header */
 213     ptr += m;                           /* skip chunk */
 214     n -= m;
 215   }
 216   sample_point_size = (bits_per_sample + 7) / 8;
 217   sample_frame_size = sample_point_size * n_channels;
 218   if(!sample_frame_size) goto out;      /* bogus or overflow */
 219   n_samples = data_bytes / sample_frame_size;
 220   duration = (n_samples + samples_per_second - 1) / samples_per_second;
 221 out:
 222   munmap(base, length);
 223   return duration;
 224 }
 225
 226 static const struct {
 227   const char *ext;
 228   long (*fn)(const char *path);
 229 } file_formats[] = {
 230   { ".MP3", tl_mp3 },
 231   { ".OGG", tl_ogg },
 232   { ".WAV", tl_wav },
 233   { ".mp3", tl_mp3 },
 234   { ".ogg", tl_ogg },
 235   { ".wav", tl_wav }
 236 };
 237 #define N_FILE_FORMATS (int)(sizeof file_formats / sizeof *file_formats)
 238
 239 long disorder_tracklength(const char attribute((unused)) *track,
 240                           const char *path) {
 241   const char *ext = strrchr(path, '.');
 242   int l, r, m = 0, c = 0;               /* quieten compiler */
 243
 244   if(ext) {
 245     l = 0;
 246     r = N_FILE_FORMATS - 1;
 247     while(l <= r && (c = strcmp(ext, file_formats[m = (l + r) / 2].ext)))
 248       if(c < 0)
 249         r = m - 1;
 250       else
 251         l = m + 1;
 252     if(!c)
 253       return file_formats[m].fn(path);
 254   }
 255   return 0;
 256 }
 257
 258 /*
 259 Local Variables:
 260 c-basic-offset:2
 261 comment-column:40
 262 fill-column:79
 263 End:
 264 */