| 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 | */ |