chiark / gitweb /
Doxygen-clean
[disorder] / plugins / tracklength.c
CommitLineData
460b9539 1/*
2 * This file is part of DisOrder.
c57f1201 3 * Copyright (C) 2004, 2005, 2007 Richard Kettlewell
460b9539 4 *
e7eb3a27 5 * This program is free software: you can redistribute it and/or modify
460b9539 6 * it under the terms of the GNU General Public License as published by
e7eb3a27 7 * the Free Software Foundation, either version 3 of the License, or
460b9539 8 * (at your option) any later version.
9 *
e7eb3a27
RK
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
460b9539 15 * You should have received a copy of the GNU General Public License
e7eb3a27 16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
460b9539 17 */
18
19#include <config.h>
20
21#include <string.h>
22#include <stdio.h>
23#include <math.h>
24#include <sys/types.h>
25#include <sys/stat.h>
26#include <unistd.h>
27#include <fcntl.h>
28#include <sys/mman.h>
29#include <errno.h>
30
31#include <vorbis/vorbisfile.h>
32#include <mad.h>
762806f1
RK
33/* libFLAC has had an API change and stupidly taken away the old API */
34#if HAVE_FLAC_FILE_DECODER_H
35# include <FLAC/file_decoder.h>
36#else
37# include <FLAC/stream_decoder.h>
38#define FLAC__FileDecoder FLAC__StreamDecoder
39#define FLAC__FileDecoderState FLAC__StreamDecoderState
40#endif
41
460b9539 42
43#include <disorder.h>
44
45#include "madshim.h"
ce6c36be 46#include "wav.h"
460b9539 47
48static void *mmap_file(const char *path, size_t *lengthp) {
49 int fd;
50 void *base;
51 struct stat sb;
52
53 if((fd = open(path, O_RDONLY)) < 0) {
54 disorder_error(errno, "error opening %s", path);
55 return 0;
56 }
57 if(fstat(fd, &sb) < 0) {
58 disorder_error(errno, "error calling stat on %s", path);
59 goto error;
60 }
61 if(sb.st_size == 0) /* can't map 0-length files */
62 goto error;
63 if((base = mmap(0, sb.st_size, PROT_READ,
64 MAP_SHARED, fd, 0)) == (void *)-1) {
65 disorder_error(errno, "error calling mmap on %s", path);
66 goto error;
67 }
68 *lengthp = sb.st_size;
69 close(fd);
70 return base;
71error:
72 close(fd);
73 return 0;
74}
75
76static long tl_mp3(const char *path) {
77 size_t length;
78 void *base;
79 buffer b;
80
81 if(!(base = mmap_file(path, &length))) return -1;
82 b.duration = mad_timer_zero;
83 scan_mp3(base, length, &b);
84 munmap(base, length);
85 return b.duration.seconds + !!b.duration.fraction;
86}
87
88static long tl_ogg(const char *path) {
89 OggVorbis_File vf;
90 FILE *fp = 0;
91 double length;
92
93 if(!path) goto error;
94 if(!(fp = fopen(path, "rb"))) goto error;
95 if(ov_open(fp, &vf, 0, 0)) goto error;
96 fp = 0;
97 length = ov_time_total(&vf, -1);
98 ov_clear(&vf);
99 return ceil(length);
100error:
101 if(fp) fclose(fp);
102 return -1;
103}
104
105static long tl_wav(const char *path) {
ce6c36be 106 struct wavfile f[1];
107 int err, sample_frame_size;
108 long duration;
460b9539 109
ce6c36be 110 if((err = wav_init(f, path))) {
111 disorder_error(err, "error opening %s", path);
112 return -1;
460b9539 113 }
ce6c36be 114 sample_frame_size = (f->bits + 7) / 8 * f->channels;
115 if(sample_frame_size) {
116 const long long n_samples = f->datasize / sample_frame_size;
117 duration = (n_samples + f->rate - 1) / f->rate;
118 } else
119 duration = -1;
120 wav_destroy(f);
460b9539 121 return duration;
122}
123
c57f1201 124/* libFLAC's "simplified" interface is rather heavyweight... */
125
126struct flac_state {
127 long duration;
128 const char *path;
129};
130
131static void flac_metadata(const FLAC__FileDecoder attribute((unused)) *decoder,
132 const FLAC__StreamMetadata *metadata,
133 void *client_data) {
134 struct flac_state *const state = client_data;
135 const FLAC__StreamMetadata_StreamInfo *const stream_info
136 = &metadata->data.stream_info;
137
138 if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO)
139 /* FLAC uses 0 to mean unknown and conveniently so do we */
140 state->duration = (stream_info->total_samples
141 + stream_info->sample_rate - 1)
142 / stream_info->sample_rate;
143}
144
145static void flac_error(const FLAC__FileDecoder attribute((unused)) *decoder,
146 FLAC__StreamDecoderErrorStatus status,
147 void *client_data) {
148 const struct flac_state *const state = client_data;
149
150 disorder_error(0, "error decoding %s: %s", state->path,
151 FLAC__StreamDecoderErrorStatusString[status]);
152}
153
154static FLAC__StreamDecoderWriteStatus flac_write
155 (const FLAC__FileDecoder attribute((unused)) *decoder,
156 const FLAC__Frame attribute((unused)) *frame,
157 const FLAC__int32 attribute((unused)) *const buffer_[],
158 void attribute((unused)) *client_data) {
159 const struct flac_state *const state = client_data;
160
161 if(state->duration >= 0)
162 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
163 else
164 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
165}
166
167static long tl_flac(const char *path) {
c57f1201 168 struct flac_state state[1];
169
170 state->duration = -1; /* error */
171 state->path = path;
762806f1
RK
172#if HAVE_FLAC_FILE_DECODER_H
173 {
174 FLAC__FileDecoder *fd = 0;
175 FLAC__FileDecoderState fs;
176
177 if(!(fd = FLAC__file_decoder_new())) {
178 disorder_error(0, "FLAC__file_decoder_new failed");
179 goto fail;
180 }
181 if(!(FLAC__file_decoder_set_filename(fd, path))) {
182 disorder_error(0, "FLAC__file_set_filename failed");
183 goto fail;
184 }
185 FLAC__file_decoder_set_metadata_callback(fd, flac_metadata);
186 FLAC__file_decoder_set_error_callback(fd, flac_error);
187 FLAC__file_decoder_set_write_callback(fd, flac_write);
188 FLAC__file_decoder_set_client_data(fd, state);
189 if((fs = FLAC__file_decoder_init(fd))) {
190 disorder_error(0, "FLAC__file_decoder_init: %s",
191 FLAC__FileDecoderStateString[fs]);
192 goto fail;
193 }
194 FLAC__file_decoder_process_until_end_of_metadata(fd);
195fail:
196 if(fd)
197 FLAC__file_decoder_delete(fd);
9f110560 198 }
762806f1
RK
199#else
200 {
201 FLAC__StreamDecoder *sd = 0;
202 FLAC__StreamDecoderInitStatus is;
203
204 if(!(sd = FLAC__stream_decoder_new())) {
205 disorder_error(0, "FLAC__stream_decoder_new failed");
206 goto fail;
207 }
208 if((is = FLAC__stream_decoder_init_file(sd, path, flac_write, flac_metadata,
209 flac_error, state))) {
210 disorder_error(0, "FLAC__stream_decoder_init_file %s: %s",
211 path, FLAC__StreamDecoderInitStatusString[is]);
212 goto fail;
213 }
214 FLAC__stream_decoder_process_until_end_of_metadata(sd);
c57f1201 215fail:
762806f1
RK
216 if(sd)
217 FLAC__stream_decoder_delete(sd);
218 }
219#endif
c57f1201 220 return state->duration;
221}
222
460b9539 223static const struct {
224 const char *ext;
225 long (*fn)(const char *path);
226} file_formats[] = {
c57f1201 227 { ".FLAC", tl_flac },
460b9539 228 { ".MP3", tl_mp3 },
229 { ".OGG", tl_ogg },
230 { ".WAV", tl_wav },
c57f1201 231 { ".flac", tl_flac },
460b9539 232 { ".mp3", tl_mp3 },
233 { ".ogg", tl_ogg },
234 { ".wav", tl_wav }
235};
236#define N_FILE_FORMATS (int)(sizeof file_formats / sizeof *file_formats)
237
238long disorder_tracklength(const char attribute((unused)) *track,
239 const char *path) {
240 const char *ext = strrchr(path, '.');
241 int l, r, m = 0, c = 0; /* quieten compiler */
242
243 if(ext) {
244 l = 0;
245 r = N_FILE_FORMATS - 1;
246 while(l <= r && (c = strcmp(ext, file_formats[m = (l + r) / 2].ext)))
247 if(c < 0)
248 r = m - 1;
249 else
250 l = m + 1;
251 if(!c)
252 return file_formats[m].fn(path);
253 }
254 return 0;
255}
256
257/*
258Local Variables:
259c-basic-offset:2
260comment-column:40
261fill-column:79
262End:
263*/