Mercurial > audlegacy
annotate Plugins/Input/mpg123/mpg123.c @ 558:3fb3657d2e14 trunk
[svn] - Update mpg123 configure options
- Update NEWS.
author | nenolod |
---|---|
date | Wed, 01 Feb 2006 13:57:44 -0800 |
parents | e2775c9b8b13 |
children | 59602b2e2781 |
rev | line source |
---|---|
61 | 1 #include "mpg123.h" |
354
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
2 #include "common.h" |
61 | 3 |
4 #include <glib.h> | |
5 #include <glib/gi18n.h> | |
6 #include <gtk/gtk.h> | |
7 #include <stdlib.h> | |
8 #include <string.h> | |
354
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
9 #include <unistd.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
10 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
11 #include <fcntl.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
12 #include <unistd.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
13 #include <errno.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
14 #include <sys/types.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
15 #include <sys/socket.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
16 #include <sys/time.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
17 #include <netinet/in.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
18 #include <arpa/inet.h> |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
19 #include <netdb.h> |
61 | 20 |
21 #include <libaudacious/util.h> | |
22 #include <libaudacious/configdb.h> | |
23 #include <libaudacious/vfs.h> | |
24 #include <libaudacious/titlestring.h> | |
25 | |
26 #include "audacious/util.h" | |
27 | |
28 static const long outscale = 32768; | |
29 | |
354
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
30 #define BUFSIZE_X 2048 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
31 |
61 | 32 static struct frame fr, temp_fr; |
33 | |
34 PlayerInfo *mpg123_info = NULL; | |
35 static GThread *decode_thread; | |
36 | |
37 static gboolean audio_error = FALSE, output_opened = FALSE, dopause = FALSE; | |
38 gint mpg123_bitrate, mpg123_frequency, mpg123_length, mpg123_layer, | |
39 mpg123_lsf; | |
40 gchar *mpg123_title = NULL, *mpg123_filename = NULL; | |
41 static int disp_bitrate, skip_frames = 0; | |
42 static int cpu_fflags, cpu_efflags; | |
43 gboolean mpg123_stereo, mpg123_mpeg25; | |
44 int mpg123_mode; | |
45 | |
46 gchar **mpg123_id3_encoding_list = NULL; | |
47 | |
48 const char *mpg123_id3_genres[GENRE_MAX] = { | |
49 N_("Blues"), N_("Classic Rock"), N_("Country"), N_("Dance"), | |
50 N_("Disco"), N_("Funk"), N_("Grunge"), N_("Hip-Hop"), | |
51 N_("Jazz"), N_("Metal"), N_("New Age"), N_("Oldies"), | |
52 N_("Other"), N_("Pop"), N_("R&B"), N_("Rap"), N_("Reggae"), | |
53 N_("Rock"), N_("Techno"), N_("Industrial"), N_("Alternative"), | |
54 N_("Ska"), N_("Death Metal"), N_("Pranks"), N_("Soundtrack"), | |
55 N_("Euro-Techno"), N_("Ambient"), N_("Trip-Hop"), N_("Vocal"), | |
56 N_("Jazz+Funk"), N_("Fusion"), N_("Trance"), N_("Classical"), | |
57 N_("Instrumental"), N_("Acid"), N_("House"), N_("Game"), | |
58 N_("Sound Clip"), N_("Gospel"), N_("Noise"), N_("AlternRock"), | |
59 N_("Bass"), N_("Soul"), N_("Punk"), N_("Space"), | |
60 N_("Meditative"), N_("Instrumental Pop"), | |
61 N_("Instrumental Rock"), N_("Ethnic"), N_("Gothic"), | |
62 N_("Darkwave"), N_("Techno-Industrial"), N_("Electronic"), | |
63 N_("Pop-Folk"), N_("Eurodance"), N_("Dream"), | |
64 N_("Southern Rock"), N_("Comedy"), N_("Cult"), | |
65 N_("Gangsta Rap"), N_("Top 40"), N_("Christian Rap"), | |
66 N_("Pop/Funk"), N_("Jungle"), N_("Native American"), | |
67 N_("Cabaret"), N_("New Wave"), N_("Psychedelic"), N_("Rave"), | |
68 N_("Showtunes"), N_("Trailer"), N_("Lo-Fi"), N_("Tribal"), | |
69 N_("Acid Punk"), N_("Acid Jazz"), N_("Polka"), N_("Retro"), | |
70 N_("Musical"), N_("Rock & Roll"), N_("Hard Rock"), N_("Folk"), | |
71 N_("Folk/Rock"), N_("National Folk"), N_("Swing"), | |
72 N_("Fast-Fusion"), N_("Bebob"), N_("Latin"), N_("Revival"), | |
73 N_("Celtic"), N_("Bluegrass"), N_("Avantgarde"), | |
74 N_("Gothic Rock"), N_("Progressive Rock"), | |
75 N_("Psychedelic Rock"), N_("Symphonic Rock"), N_("Slow Rock"), | |
76 N_("Big Band"), N_("Chorus"), N_("Easy Listening"), | |
77 N_("Acoustic"), N_("Humour"), N_("Speech"), N_("Chanson"), | |
78 N_("Opera"), N_("Chamber Music"), N_("Sonata"), N_("Symphony"), | |
79 N_("Booty Bass"), N_("Primus"), N_("Porn Groove"), | |
80 N_("Satire"), N_("Slow Jam"), N_("Club"), N_("Tango"), | |
81 N_("Samba"), N_("Folklore"), N_("Ballad"), N_("Power Ballad"), | |
82 N_("Rhythmic Soul"), N_("Freestyle"), N_("Duet"), | |
83 N_("Punk Rock"), N_("Drum Solo"), N_("A Cappella"), | |
84 N_("Euro-House"), N_("Dance Hall"), N_("Goa"), | |
85 N_("Drum & Bass"), N_("Club-House"), N_("Hardcore"), | |
86 N_("Terror"), N_("Indie"), N_("BritPop"), N_("Negerpunk"), | |
87 N_("Polsk Punk"), N_("Beat"), N_("Christian Gangsta Rap"), | |
88 N_("Heavy Metal"), N_("Black Metal"), N_("Crossover"), | |
89 N_("Contemporary Christian"), N_("Christian Rock"), | |
90 N_("Merengue"), N_("Salsa"), N_("Thrash Metal"), | |
91 N_("Anime"), N_("JPop"), N_("Synthpop") | |
92 }; | |
93 | |
94 double | |
95 mpg123_compute_tpf(struct frame *fr) | |
96 { | |
97 const int bs[4] = { 0, 384, 1152, 1152 }; | |
98 double tpf; | |
99 | |
100 tpf = bs[fr->lay]; | |
101 tpf /= mpg123_freqs[fr->sampling_frequency] << (fr->lsf); | |
102 return tpf; | |
103 } | |
104 | |
105 static void | |
106 set_synth_functions(struct frame *fr) | |
107 { | |
108 typedef int (*func) (real *, int, unsigned char *, int *); | |
109 typedef int (*func_mono) (real *, unsigned char *, int *); | |
110 typedef void (*func_dct36) (real *, real *, real *, real *, real *); | |
111 | |
112 int ds = fr->down_sample; | |
113 int p8 = 0; | |
114 | |
115 static func funcs[][3] = { | |
116 {mpg123_synth_1to1, | |
117 mpg123_synth_2to1, | |
118 mpg123_synth_4to1}, | |
119 {mpg123_synth_1to1_8bit, | |
120 mpg123_synth_2to1_8bit, | |
121 mpg123_synth_4to1_8bit}, | |
122 }; | |
123 | |
124 static func_mono funcs_mono[2][4] = { | |
125 {mpg123_synth_1to1_mono, | |
126 mpg123_synth_2to1_mono, | |
127 mpg123_synth_4to1_mono}, | |
128 {mpg123_synth_1to1_8bit_mono, | |
129 mpg123_synth_2to1_8bit_mono, | |
130 mpg123_synth_4to1_8bit_mono} | |
131 }; | |
132 | |
133 if (mpg123_cfg.resolution == 8) | |
134 p8 = 1; | |
135 fr->synth = funcs[p8][ds]; | |
136 fr->synth_mono = funcs_mono[p8][ds]; | |
137 fr->synth_type = SYNTH_FPU; | |
138 | |
139 if (p8) { | |
140 mpg123_make_conv16to8_table(); | |
141 } | |
142 } | |
143 | |
144 static void | |
145 init(void) | |
146 { | |
147 ConfigDb *db; | |
148 | |
149 mpg123_make_decode_tables(outscale); | |
150 | |
151 mpg123_cfg.resolution = 16; | |
152 mpg123_cfg.channels = 2; | |
153 mpg123_cfg.downsample = 0; | |
154 mpg123_cfg.http_buffer_size = 128; | |
155 mpg123_cfg.http_prebuffer = 25; | |
156 mpg123_cfg.proxy_port = 8080; | |
157 mpg123_cfg.proxy_use_auth = FALSE; | |
158 mpg123_cfg.proxy_user = NULL; | |
159 mpg123_cfg.proxy_pass = NULL; | |
160 mpg123_cfg.use_udp_channel = TRUE; | |
161 mpg123_cfg.title_override = FALSE; | |
162 mpg123_cfg.disable_id3v2 = FALSE; | |
163 mpg123_cfg.detect_by = DETECT_EXTENSION; | |
164 mpg123_cfg.default_synth = SYNTH_AUTO; | |
165 | |
166 mpg123_cfg.title_encoding_enabled = FALSE; | |
167 mpg123_cfg.title_encoding = NULL; | |
168 | |
169 db = bmp_cfg_db_open(); | |
170 | |
171 bmp_cfg_db_get_int(db, "MPG123", "resolution", &mpg123_cfg.resolution); | |
172 bmp_cfg_db_get_int(db, "MPG123", "channels", &mpg123_cfg.channels); | |
173 bmp_cfg_db_get_int(db, "MPG123", "downsample", &mpg123_cfg.downsample); | |
174 bmp_cfg_db_get_int(db, "MPG123", "http_buffer_size", | |
175 &mpg123_cfg.http_buffer_size); | |
176 bmp_cfg_db_get_int(db, "MPG123", "http_prebuffer", | |
177 &mpg123_cfg.http_prebuffer); | |
178 bmp_cfg_db_get_bool(db, "MPG123", "save_http_stream", | |
179 &mpg123_cfg.save_http_stream); | |
180 if (!bmp_cfg_db_get_string | |
181 (db, "MPG123", "save_http_path", &mpg123_cfg.save_http_path)) | |
182 mpg123_cfg.save_http_path = g_strdup(g_get_home_dir()); | |
183 | |
184 bmp_cfg_db_get_bool(db, "MPG123", "use_udp_channel", | |
185 &mpg123_cfg.use_udp_channel); | |
186 | |
187 bmp_cfg_db_get_bool(db, "MPG123", "use_proxy", &mpg123_cfg.use_proxy); | |
188 if (!bmp_cfg_db_get_string | |
189 (db, "MPG123", "proxy_host", &mpg123_cfg.proxy_host)) | |
190 mpg123_cfg.proxy_host = g_strdup("localhost"); | |
191 bmp_cfg_db_get_int(db, "MPG123", "proxy_port", &mpg123_cfg.proxy_port); | |
192 bmp_cfg_db_get_bool(db, "MPG123", "proxy_use_auth", | |
193 &mpg123_cfg.proxy_use_auth); | |
194 bmp_cfg_db_get_string(db, "MPG123", "proxy_user", &mpg123_cfg.proxy_user); | |
195 bmp_cfg_db_get_string(db, "MPG123", "proxy_pass", &mpg123_cfg.proxy_pass); | |
196 | |
197 bmp_cfg_db_get_bool(db, "MPG123", "title_override", | |
198 &mpg123_cfg.title_override); | |
199 bmp_cfg_db_get_bool(db, "MPG123", "disable_id3v2", | |
200 &mpg123_cfg.disable_id3v2); | |
201 if (!bmp_cfg_db_get_string | |
202 (db, "MPG123", "id3_format", &mpg123_cfg.id3_format)) | |
203 mpg123_cfg.id3_format = g_strdup("%p - %t"); | |
204 bmp_cfg_db_get_int(db, "MPG123", "detect_by", &mpg123_cfg.detect_by); | |
205 bmp_cfg_db_get_int(db, "MPG123", "default_synth", | |
206 &mpg123_cfg.default_synth); | |
207 | |
208 bmp_cfg_db_get_bool(db, "MPG123", "title_encoding_enabled", &mpg123_cfg.title_encoding_enabled); | |
209 bmp_cfg_db_get_string(db, "MPG123", "title_encoding", &mpg123_cfg.title_encoding); | |
210 if (mpg123_cfg.title_encoding_enabled) | |
211 mpg123_id3_encoding_list = g_strsplit_set(mpg123_cfg.title_encoding, ENCODING_SEPARATOR, 0); | |
212 | |
213 bmp_cfg_db_close(db); | |
214 | |
215 if (mpg123_cfg.resolution != 16 && mpg123_cfg.resolution != 8) | |
216 mpg123_cfg.resolution = 16; | |
217 | |
218 mpg123_cfg.channels = CLAMP(mpg123_cfg.channels, 0, 2); | |
219 mpg123_cfg.downsample = CLAMP(mpg123_cfg.downsample, 0, 2); | |
220 mpg123_getcpuflags(&cpu_fflags, &cpu_efflags); | |
221 } | |
222 | |
223 static void | |
224 cleanup(void) | |
225 { | |
226 g_strfreev(mpg123_id3_encoding_list); | |
227 } | |
228 | |
229 /* needed for is_our_file() */ | |
230 static int | |
231 read_n_bytes(VFSFile * file, guint8 * buf, int n) | |
232 { | |
233 | |
234 if (vfs_fread(buf, 1, n, file) != n) { | |
235 return FALSE; | |
236 } | |
237 return TRUE; | |
238 } | |
239 | |
240 static guint32 | |
241 convert_to_header(guint8 * buf) | |
242 { | |
243 | |
244 return (buf[0] << 24) + (buf[1] << 16) + (buf[2] << 8) + buf[3]; | |
245 } | |
246 | |
247 static guint32 | |
248 convert_to_long(guint8 * buf) | |
249 { | |
250 | |
251 return (buf[3] << 24) + (buf[2] << 16) + (buf[1] << 8) + buf[0]; | |
252 } | |
253 | |
254 static guint16 | |
255 read_wav_id(char *filename) | |
256 { | |
257 VFSFile *file; | |
258 guint16 wavid; | |
259 guint8 buf[4]; | |
260 guint32 head; | |
261 long seek; | |
262 | |
263 if (!(file = vfs_fopen(filename, "rb"))) { /* Could not open file */ | |
264 return 0; | |
265 } | |
266 if (!(read_n_bytes(file, buf, 4))) { | |
267 vfs_fclose(file); | |
268 return 0; | |
269 } | |
270 head = convert_to_header(buf); | |
271 if (head == ('R' << 24) + ('I' << 16) + ('F' << 8) + 'F') { /* Found a riff -- maybe WAVE */ | |
272 if (vfs_fseek(file, 4, SEEK_CUR) != 0) { /* some error occured */ | |
273 vfs_fclose(file); | |
274 return 0; | |
275 } | |
276 if (!(read_n_bytes(file, buf, 4))) { | |
277 vfs_fclose(file); | |
278 return 0; | |
279 } | |
280 head = convert_to_header(buf); | |
281 if (head == ('W' << 24) + ('A' << 16) + ('V' << 8) + 'E') { /* Found a WAVE */ | |
282 seek = 0; | |
283 do { | |
284 /* we'll be looking for the fmt-chunk which comes before the data-chunk */ | |
285 /* A chunk consists of an header identifier (4 bytes), the length of the chunk | |
286 (4 bytes), and the chunkdata itself, padded to be an even number of bytes. | |
287 We'll skip all chunks until we find the "data"-one which could contain | |
288 mpeg-data */ | |
289 if (seek != 0) { | |
290 if (vfs_fseek(file, seek, SEEK_CUR) != 0) { /* some error occured */ | |
291 vfs_fclose(file); | |
292 return 0; | |
293 } | |
294 } | |
295 if (!(read_n_bytes(file, buf, 4))) { | |
296 vfs_fclose(file); | |
297 return 0; | |
298 } | |
299 head = convert_to_header(buf); | |
300 if (!(read_n_bytes(file, buf, 4))) { | |
301 vfs_fclose(file); | |
302 return 0; | |
303 } | |
304 seek = convert_to_long(buf); | |
305 seek = seek + (seek % 2); /* Has to be even (padding) */ | |
306 if (seek >= 2 | |
307 && head == ('f' << 24) + ('m' << 16) + ('t' << 8) + ' ') { | |
308 if (!(read_n_bytes(file, buf, 2))) { | |
309 vfs_fclose(file); | |
310 return 0; | |
311 } | |
312 wavid = buf[0] + 256 * buf[1]; | |
313 seek -= 2; | |
314 /* we could go on looking for | |
315 other things, but all we | |
316 wanted was the wavid */ | |
317 vfs_fclose(file); | |
318 return wavid; | |
319 } | |
320 } | |
321 while (head != ('d' << 24) + ('a' << 16) + ('t' << 8) + 'a'); | |
322 /* it's RIFF WAVE */ | |
323 } | |
324 /* it's RIFF */ | |
325 } | |
326 /* it's not even RIFF */ | |
327 vfs_fclose(file); | |
328 return 0; | |
329 } | |
330 | |
331 #define DET_BUF_SIZE 1024 | |
332 | |
333 static gboolean | |
334 mpg123_detect_by_content(char *filename) | |
335 { | |
336 VFSFile *file; | |
337 guchar tmp[4]; | |
338 guint32 head; | |
339 struct frame fr; | |
340 guchar buf[DET_BUF_SIZE]; | |
341 int in_buf, i; | |
342 gboolean ret = FALSE; | |
343 | |
344 if ((file = vfs_fopen(filename, "rb")) == NULL) | |
345 return FALSE; | |
346 if (vfs_fread(tmp, 1, 4, file) != 4) | |
347 goto done; | |
348 head = convert_to_header(tmp); | |
349 while (!mpg123_head_check(head)) { | |
350 /* | |
351 * The mpeg-stream can start anywhere in the file, | |
352 * so we check the entire file | |
353 */ | |
354 /* Optimize this */ | |
355 in_buf = vfs_fread(buf, 1, DET_BUF_SIZE, file); | |
356 if (in_buf == 0) | |
357 goto done; | |
358 | |
359 for (i = 0; i < in_buf; i++) { | |
360 head <<= 8; | |
361 head |= buf[i]; | |
362 if (mpg123_head_check(head)) { | |
363 vfs_fseek(file, i + 1 - in_buf, SEEK_CUR); | |
364 break; | |
365 } | |
366 } | |
367 } | |
368 if (mpg123_decode_header(&fr, head)) { | |
369 /* | |
370 * We found something which looks like a MPEG-header. | |
371 * We check the next frame too, to be sure | |
372 */ | |
373 | |
374 if (vfs_fseek(file, fr.framesize, SEEK_CUR) != 0) | |
375 goto done; | |
376 if (vfs_fread(tmp, 1, 4, file) != 4) | |
377 goto done; | |
378 head = convert_to_header(tmp); | |
379 if (mpg123_head_check(head) && mpg123_decode_header(&fr, head)) | |
380 ret = TRUE; | |
381 } | |
382 | |
383 done: | |
384 vfs_fclose(file); | |
385 return ret; | |
386 } | |
387 | |
354
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
388 static gboolean |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
389 mpg123_detect_by_content_stream(gchar *url) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
390 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
391 gchar *buf, inbuf[BUFSIZE_X]; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
392 struct hostent *hp; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
393 struct sockaddr_in sa; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
394 gint s, i, y = 0; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
395 gchar *user, *pass, *host, *filename; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
396 gint port; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
397 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
398 g_strstrip(url); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
399 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
400 parse_url(url, &user, &pass, &host, &port, &filename); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
401 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
402 if (!(s = socket(AF_INET, SOCK_STREAM, 0))) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
403 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
404 perror("socket"); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
405 return FALSE; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
406 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
407 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
408 if ((hp = gethostbyname(host)) == NULL) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
409 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
410 g_print("[stream detect] Unable to resolve %s\n", host); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
411 close(s); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
412 return FALSE; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
413 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
414 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
415 memset(&sa, '\0', sizeof(sa)); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
416 sa.sin_family = AF_INET; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
417 sa.sin_port = htons(port); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
418 memcpy(&sa.sin_addr, hp->h_addr, hp->h_length); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
419 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
420 if (connect(s, (struct sockaddr *)&sa, sizeof(sa)) < 0) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
421 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
422 perror("connect"); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
423 return FALSE; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
424 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
425 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
426 g_print("[stream detect] connected to %s, port %d\n", host, port); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
427 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
428 buf = g_strdup_printf("GET /%s HTTP/1.0\r\nUser-Agent: " PACKAGE "/" PACKAGE_VERSION "\r\n\r\n", filename ? filename : ""); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
429 i = write(s, buf, strlen(buf)); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
430 g_free(buf); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
431 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
432 if (i == -1) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
433 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
434 perror("write"); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
435 return FALSE; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
436 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
437 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
438 /* don't ask. --nenolod */ |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
439 while ((i = read(s, inbuf + y, BUFSIZE_X - y)) != 0 && y < BUFSIZE_X) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
440 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
441 inbuf[y + i] = '\0'; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
442 y += i; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
443 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
444 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
445 close(s); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
446 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
447 buf = strtok(inbuf, "\n"); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
448 while ((buf = strtok(NULL, "\n")) != NULL) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
449 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
450 if (!g_strncasecmp("content-type:audio/mpeg", buf, 23) || |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
451 !g_strncasecmp("icy-br:", buf, 7) || /* XXX ShoutCAST sometimes doesnt send the content-type header */ |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
452 !g_strncasecmp("Content-Type: audio/mpeg", buf, 24)) |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
453 { |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
454 g_print("[stream detect] server is providing audio/mpeg stream\n"); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
455 return TRUE; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
456 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
457 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
458 |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
459 g_print("[stream detect] server is NOT providing audio/mpeg stream\n"); |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
460 return FALSE; |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
461 } |
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
462 |
61 | 463 static int |
464 is_our_file(char *filename) | |
465 { | |
466 char *ext; | |
467 guint16 wavid; | |
468 | |
469 if (!strncasecmp(filename, "http://", 7)) { | |
354
e2775c9b8b13
[svn] very rudementary http stream detection support for mpg123-clone.
nenolod
parents:
353
diff
changeset
|
470 return mpg123_detect_by_content_stream(filename); |
61 | 471 } |
558 | 472 else |
61 | 473 return (mpg123_detect_by_content(filename)); |
474 | |
475 return FALSE; | |
476 } | |
477 | |
478 static void | |
479 play_frame(struct frame *fr) | |
480 { | |
481 if (fr->error_protection) { | |
482 bsi.wordpointer += 2; | |
483 /* mpg123_getbits(16); *//* skip crc */ | |
484 } | |
485 if (!fr->do_layer(fr)) { | |
486 skip_frames = 2; | |
487 mpg123_info->output_audio = FALSE; | |
488 } | |
489 else { | |
490 if (!skip_frames) | |
491 mpg123_info->output_audio = TRUE; | |
492 else | |
493 skip_frames--; | |
494 } | |
495 } | |
496 | |
497 static const char * | |
498 get_id3_genre(unsigned char genre_code) | |
499 { | |
500 if (genre_code < GENRE_MAX) | |
501 return gettext(mpg123_id3_genres[genre_code]); | |
502 | |
503 return ""; | |
504 } | |
505 | |
506 guint | |
507 mpg123_strip_spaces(char *src, size_t n) | |
508 { | |
509 gchar *space = NULL, /* last space in src */ | |
510 *start = src; | |
511 | |
512 while (n--) | |
513 switch (*src++) { | |
514 case '\0': | |
515 n = 0; /* breaks out of while loop */ | |
516 | |
517 src--; | |
518 break; | |
519 case ' ': | |
520 if (space == NULL) | |
521 space = src - 1; | |
522 break; | |
523 default: | |
524 space = NULL; /* don't terminate intermediate spaces */ | |
525 | |
526 break; | |
527 } | |
528 if (space != NULL) { | |
529 src = space; | |
530 *src = '\0'; | |
531 } | |
532 return src - start; | |
533 } | |
534 | |
535 /* | |
536 * Function extname (filename) | |
537 * | |
538 * Return pointer within filename to its extenstion, or NULL if | |
539 * filename has no extension. | |
540 * | |
541 */ | |
542 static gchar * | |
543 extname(const char *filename) | |
544 { | |
545 gchar *ext = strrchr(filename, '.'); | |
546 | |
547 if (ext != NULL) | |
548 ++ext; | |
549 | |
550 return ext; | |
551 } | |
552 | |
553 /* | |
554 * Function id3v1_to_id3v2 (v1, v2) | |
555 * | |
556 * Convert ID3v1 tag `v1' to ID3v2 tag `v2'. | |
557 * | |
558 */ | |
559 void | |
560 mpg123_id3v1_to_id3v2(struct id3v1tag_t *v1, struct id3tag_t *v2) | |
561 { | |
562 memset(v2, 0, sizeof(struct id3tag_t)); | |
563 strncpy(v2->title, v1->title, 30); | |
564 strncpy(v2->artist, v1->artist, 30); | |
565 strncpy(v2->album, v1->album, 30); | |
566 strncpy(v2->comment, v1->u.v1_0.comment, 30); | |
567 strncpy(v2->genre, get_id3_genre(v1->genre), sizeof(v2->genre)); | |
568 g_strstrip(v2->title); | |
569 g_strstrip(v2->artist); | |
570 g_strstrip(v2->album); | |
571 g_strstrip(v2->comment); | |
572 g_strstrip(v2->genre); | |
573 v2->year = atoi(v1->year); | |
574 | |
575 /* Check for v1.1 tags. */ | |
576 if (v1->u.v1_1.__zero == 0) | |
577 v2->track_number = v1->u.v1_1.track_number; | |
578 else | |
579 v2->track_number = 0; | |
580 } | |
581 | |
582 static char * | |
583 mpg123_getstr(char *str) | |
584 { | |
585 if (str && strlen(str) > 0) | |
586 return str; | |
587 return NULL; | |
588 } | |
589 | |
590 static gchar * | |
591 convert_id3_title(gchar * title) | |
592 { | |
593 gchar **encoding = mpg123_id3_encoding_list; | |
594 gchar *new_title = NULL; | |
595 | |
596 if (g_utf8_validate(title, -1, NULL)) | |
597 return title; | |
598 | |
599 while (*encoding && !new_title) { | |
600 new_title = g_convert(title, strlen(title), "UTF-8", *encoding++, | |
601 NULL, NULL, NULL); | |
602 } | |
603 | |
604 if (new_title) { | |
605 g_free(title); | |
606 return new_title; | |
607 } | |
608 | |
609 /* FIXME: We're relying on BMP core to provide fallback | |
610 * conversion */ | |
611 return title; | |
612 } | |
613 | |
614 /* | |
615 * Function mpg123_format_song_title (tag, filename) | |
616 * | |
617 * Create song title according to `tag' and/or `filename' and | |
618 * return it. The title must be subsequently freed using g_free(). | |
619 * | |
620 */ | |
621 gchar * | |
622 mpg123_format_song_title(struct id3tag_t * tag, gchar * filename) | |
623 { | |
624 gchar *title = NULL; | |
625 TitleInput *input; | |
626 | |
627 input = bmp_title_input_new(); | |
628 | |
629 if (tag) { | |
630 input->performer = mpg123_getstr(tag->artist); | |
631 input->album_name = mpg123_getstr(tag->album); | |
632 input->track_name = mpg123_getstr(tag->title); | |
633 input->year = tag->year; | |
634 input->track_number = tag->track_number; | |
635 input->genre = mpg123_getstr(tag->genre); | |
636 input->comment = mpg123_getstr(tag->comment); | |
637 } | |
638 | |
639 input->file_name = g_path_get_basename(filename); | |
640 input->file_path = g_path_get_dirname(filename); | |
641 input->file_ext = extname(filename); | |
642 | |
643 title = xmms_get_titlestring(mpg123_cfg.title_override ? | |
644 mpg123_cfg.id3_format : | |
645 xmms_get_gentitle_format(), input); | |
646 | |
647 if (!title) { | |
648 /* Format according to filename. */ | |
649 title = g_path_get_basename(filename); | |
650 if (extname(title)) | |
651 *(extname(title) - 1) = '\0'; /* removes period */ | |
652 } | |
653 | |
654 g_free(input->file_path); | |
655 g_free(input->file_name); | |
656 g_free(input); | |
657 | |
658 if (mpg123_cfg.title_encoding_enabled) | |
659 title = convert_id3_title(title); | |
660 | |
661 return title; | |
662 } | |
663 | |
664 /* | |
665 * Function mpg123_get_id3v2 (id3d, tag) | |
666 * | |
667 * Get desired contents from the indicated id3tag and store it in | |
668 * `tag'. | |
669 * | |
670 */ | |
671 void | |
672 mpg123_get_id3v2(struct id3_tag *id3d, struct id3tag_t *tag) | |
673 { | |
674 struct id3_frame *id3frm; | |
675 gchar *txt; | |
676 gint tlen, num; | |
677 | |
678 #define ID3_SET(_tid,_fld) \ | |
679 { \ | |
680 id3frm = id3_get_frame( id3d, _tid, 1 ); \ | |
681 if (id3frm) { \ | |
682 txt = _tid == ID3_TCON ? id3_get_content(id3frm) \ | |
683 : id3_get_text(id3frm); \ | |
684 if(txt) \ | |
685 { \ | |
686 tlen = strlen(txt); \ | |
687 if ( tlen >= sizeof(tag->_fld) ) \ | |
688 tlen = sizeof(tag->_fld)-1; \ | |
689 strncpy( tag->_fld, txt, tlen ); \ | |
690 tag->_fld[tlen] = 0; \ | |
691 g_free(txt); \ | |
692 } \ | |
693 else \ | |
694 tag->_fld[0] = 0; \ | |
695 } else { \ | |
696 tag->_fld[0] = 0; \ | |
697 } \ | |
698 } | |
699 | |
700 #define ID3_SET_NUM(_tid,_fld) \ | |
701 { \ | |
702 id3frm = id3_get_frame(id3d, _tid, 1); \ | |
703 if (id3frm) { \ | |
704 num = id3_get_text_number(id3frm); \ | |
705 tag->_fld = num >= 0 ? num : 0; \ | |
706 } else \ | |
707 tag->_fld = 0; \ | |
708 } | |
709 | |
710 ID3_SET(ID3_TIT2, title); | |
711 ID3_SET(ID3_TPE1, artist); | |
712 if (strlen(tag->artist) == 0) | |
713 ID3_SET(ID3_TPE2, artist); | |
714 ID3_SET(ID3_TALB, album); | |
715 ID3_SET_NUM(ID3_TYER, year); | |
716 ID3_SET_NUM(ID3_TRCK, track_number); | |
717 ID3_SET(ID3_COMM, comment); | |
718 ID3_SET(ID3_TCON, genre); | |
719 } | |
720 | |
721 | |
722 /* | |
723 * Function get_song_title (fd, filename) | |
724 * | |
725 * Get song title of file. File position of `fd' will be | |
726 * clobbered. `fd' may be NULL, in which case `filename' is opened | |
727 * separately. The returned song title must be subsequently freed | |
728 * using g_free(). | |
729 * | |
730 */ | |
731 static gchar * | |
732 get_song_title(VFSFile * fd, char *filename) | |
733 { | |
734 VFSFile *file = fd; | |
735 char *ret = NULL; | |
736 struct id3v1tag_t id3v1tag; | |
737 struct id3tag_t id3tag; | |
738 | |
739 if (file || (file = vfs_fopen(filename, "rb")) != 0) { | |
740 struct id3_tag *id3 = NULL; | |
741 | |
742 /* | |
743 * Try reading ID3v2 tag. | |
744 */ | |
745 if (!mpg123_cfg.disable_id3v2) { | |
746 vfs_fseek(file, 0, SEEK_SET); | |
747 id3 = id3_open_fp(file, 0); | |
748 if (id3) { | |
749 mpg123_get_id3v2(id3, &id3tag); | |
750 ret = mpg123_format_song_title(&id3tag, filename); | |
751 id3_close(id3); | |
752 } | |
753 } | |
754 | |
755 /* | |
756 * Try reading ID3v1 tag. | |
757 */ | |
758 if (!id3 && (vfs_fseek(file, -1 * sizeof(id3v1tag), SEEK_END) == 0) && | |
759 (vfs_fread(&id3v1tag, 1, sizeof(id3v1tag), file) == | |
760 sizeof(id3v1tag)) && (strncmp(id3v1tag.tag, "TAG", 3) == 0)) { | |
761 mpg123_id3v1_to_id3v2(&id3v1tag, &id3tag); | |
762 ret = mpg123_format_song_title(&id3tag, filename); | |
763 } | |
764 | |
765 if (!fd) | |
766 /* | |
767 * File was opened in this function. | |
768 */ | |
769 vfs_fclose(file); | |
770 } | |
771 | |
772 if (ret == NULL) | |
773 /* | |
774 * Unable to get ID3 tag. | |
775 */ | |
776 ret = mpg123_format_song_title(NULL, filename); | |
777 | |
778 return ret; | |
779 } | |
780 | |
781 static long | |
782 get_song_length(VFSFile * file) | |
783 { | |
784 int len; | |
785 char tmp[4]; | |
786 | |
787 vfs_fseek(file, 0, SEEK_END); | |
788 len = vfs_ftell(file); | |
789 vfs_fseek(file, -128, SEEK_END); | |
790 vfs_fread(tmp, 1, 3, file); | |
791 if (!strncmp(tmp, "TAG", 3)) | |
792 len -= 128; | |
793 return len; | |
794 } | |
795 | |
796 | |
797 static guint | |
798 get_song_time(VFSFile * file) | |
799 { | |
800 guint32 head; | |
801 guchar tmp[4], *buf; | |
802 struct frame frm; | |
803 xing_header_t xing_header; | |
804 double tpf, bpf; | |
805 guint32 len; | |
806 | |
807 if (!file) | |
808 return -1; | |
809 | |
810 vfs_fseek(file, 0, SEEK_SET); | |
811 if (vfs_fread(tmp, 1, 4, file) != 4) | |
812 return 0; | |
813 head = convert_to_header(tmp); | |
814 while (!mpg123_head_check(head)) { | |
815 head <<= 8; | |
816 if (vfs_fread(tmp, 1, 1, file) != 1) | |
817 return 0; | |
818 head |= tmp[0]; | |
819 } | |
820 if (mpg123_decode_header(&frm, head)) { | |
821 buf = g_malloc(frm.framesize + 4); | |
822 vfs_fseek(file, -4, SEEK_CUR); | |
823 vfs_fread(buf, 1, frm.framesize + 4, file); | |
824 tpf = mpg123_compute_tpf(&frm); | |
825 if (mpg123_get_xing_header(&xing_header, buf)) { | |
826 g_free(buf); | |
827 if (xing_header.bytes == 0) | |
828 xing_header.bytes = get_song_length(file); | |
829 return (tpf * xing_header.frames * 1000); | |
830 } | |
831 g_free(buf); | |
832 bpf = mpg123_compute_bpf(&frm); | |
833 len = get_song_length(file); | |
834 return ((guint) (len / bpf) * tpf * 1000); | |
835 } | |
836 return 0; | |
837 } | |
838 | |
839 static void | |
840 get_song_info(char *filename, char **title_real, int *len_real) | |
841 { | |
842 VFSFile *file; | |
843 | |
844 (*len_real) = -1; | |
845 (*title_real) = NULL; | |
846 | |
847 /* | |
848 * TODO: Getting song info from http streams. | |
849 */ | |
850 if (!strncasecmp(filename, "http://", 7)) | |
851 return; | |
852 | |
853 if ((file = vfs_fopen(filename, "rb")) != NULL) { | |
854 (*len_real) = get_song_time(file); | |
855 (*title_real) = get_song_title(file, filename); | |
856 vfs_fclose(file); | |
857 } | |
858 } | |
859 | |
860 static int | |
861 open_output(void) | |
862 { | |
863 int r; | |
864 AFormat fmt = mpg123_cfg.resolution == 16 ? FMT_S16_NE : FMT_U8; | |
865 int freq = mpg123_freqs[fr.sampling_frequency] >> mpg123_cfg.downsample; | |
866 int channels = mpg123_cfg.channels == 2 ? fr.stereo : 1; | |
867 r = mpg123_ip.output->open_audio(fmt, freq, channels); | |
868 | |
869 if (r && dopause) { | |
870 mpg123_ip.output->pause(TRUE); | |
871 dopause = FALSE; | |
872 } | |
873 | |
874 return r; | |
875 } | |
876 | |
877 | |
878 static int | |
879 mpg123_seek(struct frame *fr, xing_header_t * xh, gboolean vbr, int time) | |
880 { | |
881 int jumped = -1; | |
882 | |
883 if (xh) { | |
884 int percent = ((double) time * 100.0) / | |
885 (mpg123_info->num_frames * mpg123_info->tpf); | |
886 int byte = mpg123_seek_point(xh, percent); | |
887 jumped = mpg123_stream_jump_to_byte(fr, byte); | |
888 } | |
889 else if (vbr && mpg123_length > 0) { | |
890 int byte = ((guint64) time * 1000 * mpg123_info->filesize) / | |
891 mpg123_length; | |
892 jumped = mpg123_stream_jump_to_byte(fr, byte); | |
893 } | |
894 else { | |
895 int frame = time / mpg123_info->tpf; | |
896 jumped = mpg123_stream_jump_to_frame(fr, frame); | |
897 } | |
898 | |
899 return jumped; | |
900 } | |
901 | |
902 | |
903 static void * | |
904 decode_loop(void *arg) | |
905 { | |
906 gboolean have_xing_header = FALSE, vbr = FALSE; | |
907 int disp_count = 0, temp_time; | |
908 char *filename = arg; | |
909 xing_header_t xing_header; | |
910 | |
911 /* This is used by fileinfo on http streams */ | |
912 mpg123_bitrate = 0; | |
913 | |
914 mpg123_pcm_sample = g_malloc0(32768); | |
915 mpg123_pcm_point = 0; | |
916 mpg123_filename = filename; | |
917 | |
918 mpg123_read_frame_init(); | |
919 | |
920 mpg123_open_stream(filename, -1); | |
921 | |
922 if (mpg123_info->eof || !mpg123_read_frame(&fr)) | |
923 mpg123_info->eof = TRUE; | |
924 | |
925 if (!mpg123_info->eof && mpg123_info->going) { | |
926 if (mpg123_cfg.channels == 2) | |
927 fr.single = -1; | |
928 else | |
929 fr.single = 3; | |
930 | |
931 fr.down_sample = mpg123_cfg.downsample; | |
932 fr.down_sample_sblimit = SBLIMIT >> mpg123_cfg.downsample; | |
933 set_synth_functions(&fr); | |
934 mpg123_init_layer3(fr.down_sample_sblimit); | |
935 | |
936 mpg123_info->tpf = mpg123_compute_tpf(&fr); | |
937 if (strncasecmp(filename, "http://", 7)) { | |
938 if (mpg123_stream_check_for_xing_header(&fr, &xing_header)) { | |
939 mpg123_info->num_frames = xing_header.frames; | |
940 have_xing_header = TRUE; | |
941 mpg123_read_frame(&fr); | |
942 } | |
943 } | |
944 | |
945 for (;;) { | |
946 memcpy(&temp_fr, &fr, sizeof(struct frame)); | |
947 if (!mpg123_read_frame(&temp_fr)) { | |
948 mpg123_info->eof = TRUE; | |
949 break; | |
950 } | |
951 if (fr.lay != temp_fr.lay || | |
952 fr.sampling_frequency != temp_fr.sampling_frequency || | |
953 fr.stereo != temp_fr.stereo || fr.lsf != temp_fr.lsf) | |
954 memcpy(&fr, &temp_fr, sizeof(struct frame)); | |
955 else | |
956 break; | |
957 } | |
958 | |
959 if (!have_xing_header && strncasecmp(filename, "http://", 7)) | |
960 mpg123_info->num_frames = mpg123_calc_numframes(&fr); | |
961 | |
962 memcpy(&fr, &temp_fr, sizeof(struct frame)); | |
963 mpg123_bitrate = tabsel_123[fr.lsf][fr.lay - 1][fr.bitrate_index]; | |
964 disp_bitrate = mpg123_bitrate; | |
965 mpg123_frequency = mpg123_freqs[fr.sampling_frequency]; | |
966 mpg123_stereo = fr.stereo; | |
967 mpg123_layer = fr.lay; | |
968 mpg123_lsf = fr.lsf; | |
969 mpg123_mpeg25 = fr.mpeg25; | |
970 mpg123_mode = fr.mode; | |
971 | |
972 if (strncasecmp(filename, "http://", 7)) { | |
973 mpg123_length = mpg123_info->num_frames * mpg123_info->tpf * 1000; | |
974 if (!mpg123_title) | |
975 mpg123_title = get_song_title(NULL, filename); | |
976 } | |
977 else { | |
978 if (!mpg123_title) | |
979 mpg123_title = mpg123_http_get_title(filename); | |
980 mpg123_length = -1; | |
981 } | |
982 | |
983 mpg123_ip.set_info(mpg123_title, mpg123_length, | |
984 mpg123_bitrate * 1000, | |
985 mpg123_freqs[fr.sampling_frequency], fr.stereo); | |
986 | |
987 output_opened = TRUE; | |
988 | |
989 if (!open_output()) { | |
990 audio_error = TRUE; | |
991 mpg123_info->eof = TRUE; | |
992 } | |
993 else | |
994 play_frame(&fr); | |
995 } | |
996 | |
997 mpg123_info->first_frame = FALSE; | |
998 while (mpg123_info->going) { | |
999 if (mpg123_info->jump_to_time != -1) { | |
1000 void *xp = NULL; | |
1001 if (have_xing_header) | |
1002 xp = &xing_header; | |
1003 if (mpg123_seek(&fr, xp, vbr, mpg123_info->jump_to_time) > -1) { | |
1004 mpg123_ip.output->flush(mpg123_info->jump_to_time * 1000); | |
1005 mpg123_info->eof = FALSE; | |
1006 } | |
1007 mpg123_info->jump_to_time = -1; | |
1008 } | |
1009 if (!mpg123_info->eof) { | |
1010 if (mpg123_read_frame(&fr) != 0) { | |
1011 if (fr.lay != mpg123_layer || fr.lsf != mpg123_lsf) { | |
1012 memcpy(&temp_fr, &fr, sizeof(struct frame)); | |
1013 if (mpg123_read_frame(&temp_fr) != 0) { | |
1014 if (fr.lay == temp_fr.lay && fr.lsf == temp_fr.lsf) { | |
1015 mpg123_layer = fr.lay; | |
1016 mpg123_lsf = fr.lsf; | |
1017 memcpy(&fr, &temp_fr, sizeof(struct frame)); | |
1018 } | |
1019 else { | |
1020 memcpy(&fr, &temp_fr, sizeof(struct frame)); | |
1021 skip_frames = 2; | |
1022 mpg123_info->output_audio = FALSE; | |
1023 continue; | |
1024 } | |
1025 | |
1026 } | |
1027 } | |
1028 if (mpg123_freqs[fr.sampling_frequency] != mpg123_frequency | |
1029 || mpg123_stereo != fr.stereo) { | |
1030 memcpy(&temp_fr, &fr, sizeof(struct frame)); | |
1031 if (mpg123_read_frame(&temp_fr) != 0) { | |
1032 if (fr.sampling_frequency == | |
1033 temp_fr.sampling_frequency | |
1034 && temp_fr.stereo == fr.stereo) { | |
1035 mpg123_ip.output->buffer_free(); | |
1036 mpg123_ip.output->buffer_free(); | |
1037 while (mpg123_ip.output->buffer_playing() | |
1038 && mpg123_info->going | |
1039 && mpg123_info->jump_to_time == -1) | |
1040 xmms_usleep(20000); | |
1041 if (!mpg123_info->going) | |
1042 break; | |
1043 temp_time = mpg123_ip.output->output_time(); | |
1044 mpg123_ip.output->close_audio(); | |
1045 mpg123_frequency = | |
1046 mpg123_freqs[fr.sampling_frequency]; | |
1047 mpg123_stereo = fr.stereo; | |
1048 if (!mpg123_ip.output-> | |
1049 open_audio(mpg123_cfg.resolution == | |
1050 16 ? FMT_S16_NE : FMT_U8, | |
1051 mpg123_freqs[fr.sampling_frequency] | |
1052 >> mpg123_cfg.downsample, | |
1053 mpg123_cfg.channels == | |
1054 2 ? fr.stereo : 1)) { | |
1055 audio_error = TRUE; | |
1056 mpg123_info->eof = TRUE; | |
1057 } | |
1058 mpg123_ip.output->flush(temp_time); | |
1059 mpg123_ip.set_info(mpg123_title, mpg123_length, | |
1060 mpg123_bitrate * 1000, | |
1061 mpg123_frequency, | |
1062 mpg123_stereo); | |
1063 memcpy(&fr, &temp_fr, sizeof(struct frame)); | |
1064 } | |
1065 else { | |
1066 memcpy(&fr, &temp_fr, sizeof(struct frame)); | |
1067 skip_frames = 2; | |
1068 mpg123_info->output_audio = FALSE; | |
1069 continue; | |
1070 } | |
1071 } | |
1072 } | |
1073 | |
1074 if (tabsel_123[fr.lsf][fr.lay - 1][fr.bitrate_index] != | |
1075 mpg123_bitrate) | |
1076 mpg123_bitrate = | |
1077 tabsel_123[fr.lsf][fr.lay - 1][fr.bitrate_index]; | |
1078 | |
1079 if (!disp_count) { | |
1080 disp_count = 20; | |
1081 if (mpg123_bitrate != disp_bitrate) { | |
1082 /* FIXME networks streams */ | |
1083 disp_bitrate = mpg123_bitrate; | |
1084 if (!have_xing_header | |
1085 && strncasecmp(filename, "http://", 7)) { | |
1086 double rel = mpg123_relative_pos(); | |
1087 if (rel) { | |
1088 mpg123_length = | |
1089 mpg123_ip.output->written_time() / rel; | |
1090 vbr = TRUE; | |
1091 } | |
1092 | |
1093 if (rel == 0 || !(mpg123_length > 0)) { | |
1094 mpg123_info->num_frames = | |
1095 mpg123_calc_numframes(&fr); | |
1096 mpg123_info->tpf = mpg123_compute_tpf(&fr); | |
1097 mpg123_length = | |
1098 mpg123_info->num_frames * | |
1099 mpg123_info->tpf * 1000; | |
1100 } | |
1101 | |
1102 | |
1103 } | |
1104 mpg123_ip.set_info(mpg123_title, mpg123_length, | |
1105 mpg123_bitrate * 1000, | |
1106 mpg123_frequency, mpg123_stereo); | |
1107 } | |
1108 } | |
1109 else | |
1110 disp_count--; | |
1111 play_frame(&fr); | |
1112 } | |
1113 else { | |
1114 mpg123_ip.output->buffer_free(); | |
1115 mpg123_ip.output->buffer_free(); | |
1116 mpg123_info->eof = TRUE; | |
1117 xmms_usleep(10000); | |
1118 } | |
1119 } | |
1120 else { | |
1121 xmms_usleep(10000); | |
1122 } | |
1123 } | |
1124 g_free(mpg123_title); | |
1125 mpg123_title = NULL; | |
1126 mpg123_stream_close(); | |
1127 if (output_opened && !audio_error) | |
1128 mpg123_ip.output->close_audio(); | |
1129 g_free(mpg123_pcm_sample); | |
1130 mpg123_filename = NULL; | |
1131 g_free(filename); | |
1132 | |
1133 return NULL; | |
1134 } | |
1135 | |
1136 static void | |
1137 play_file(char *filename) | |
1138 { | |
1139 memset(&fr, 0, sizeof(struct frame)); | |
1140 memset(&temp_fr, 0, sizeof(struct frame)); | |
1141 | |
1142 mpg123_info = g_malloc0(sizeof(PlayerInfo)); | |
1143 mpg123_info->going = 1; | |
1144 mpg123_info->first_frame = TRUE; | |
1145 mpg123_info->output_audio = TRUE; | |
1146 mpg123_info->jump_to_time = -1; | |
1147 skip_frames = 0; | |
1148 audio_error = FALSE; | |
1149 output_opened = FALSE; | |
1150 dopause = FALSE; | |
1151 | |
1152 decode_thread = g_thread_create(decode_loop, g_strdup(filename), TRUE, | |
1153 NULL); | |
1154 } | |
1155 | |
1156 static void | |
1157 stop(void) | |
1158 { | |
1159 if (mpg123_info && mpg123_info->going) { | |
1160 mpg123_info->going = FALSE; | |
1161 g_thread_join(decode_thread); | |
1162 g_free(mpg123_info); | |
1163 mpg123_info = NULL; | |
1164 } | |
1165 } | |
1166 | |
1167 static void | |
1168 seek(int time) | |
1169 { | |
1170 mpg123_info->jump_to_time = time; | |
1171 | |
1172 while (mpg123_info->jump_to_time != -1) | |
1173 xmms_usleep(10000); | |
1174 } | |
1175 | |
1176 static void | |
1177 do_pause(short p) | |
1178 { | |
1179 if (output_opened) | |
1180 mpg123_ip.output->pause(p); | |
1181 else | |
1182 dopause = p; | |
1183 } | |
1184 | |
1185 static int | |
1186 get_time(void) | |
1187 { | |
1188 if (audio_error) | |
1189 return -2; | |
1190 if (!mpg123_info) | |
1191 return -1; | |
1192 if (!mpg123_info->going | |
1193 || (mpg123_info->eof && !mpg123_ip.output->buffer_playing())) | |
1194 return -1; | |
1195 return mpg123_ip.output->output_time(); | |
1196 } | |
1197 | |
1198 static void | |
1199 aboutbox(void) | |
1200 { | |
1201 static GtkWidget *aboutbox; | |
1202 | |
1203 if (aboutbox != NULL) | |
1204 return; | |
1205 | |
1206 aboutbox = xmms_show_message(_("About MPEG Audio Plugin"), | |
223
e7e9a86c0c01
[svn] Update credits on here reflecting audacious-decoder changes.
nenolod
parents:
177
diff
changeset
|
1207 _("Audacious decoding engine by William Pitcock <nenolod@nenolod.net>, derived from:\n" |
e7e9a86c0c01
[svn] Update credits on here reflecting audacious-decoder changes.
nenolod
parents:
177
diff
changeset
|
1208 "mpg123 decoding engine by Michael Hipp <mh@mpg123.de>\n" |
e7e9a86c0c01
[svn] Update credits on here reflecting audacious-decoder changes.
nenolod
parents:
177
diff
changeset
|
1209 "Derived partially from mpg123 0.59s.mc3 as well.\n" |
129
ce9d4aa5889a
[svn] Update the credits to note the code sync that occured.
nenolod
parents:
61
diff
changeset
|
1210 "Based on the original XMMS plugin."), |
ce9d4aa5889a
[svn] Update the credits to note the code sync that occured.
nenolod
parents:
61
diff
changeset
|
1211 _("Ok"), |
ce9d4aa5889a
[svn] Update the credits to note the code sync that occured.
nenolod
parents:
61
diff
changeset
|
1212 FALSE, NULL, NULL); |
61 | 1213 |
1214 g_signal_connect(G_OBJECT(aboutbox), "destroy", | |
1215 G_CALLBACK(gtk_widget_destroyed), &aboutbox); | |
1216 } | |
1217 | |
1218 InputPlugin mpg123_ip = { | |
1219 NULL, | |
1220 NULL, | |
1221 NULL, /* Description */ | |
1222 init, | |
1223 aboutbox, | |
1224 mpg123_configure, | |
1225 is_our_file, | |
1226 NULL, | |
1227 play_file, | |
1228 stop, | |
1229 do_pause, | |
1230 seek, | |
1231 mpg123_set_eq, | |
1232 get_time, | |
1233 NULL, NULL, | |
1234 cleanup, | |
1235 NULL, | |
1236 NULL, NULL, NULL, | |
1237 get_song_info, | |
1238 mpg123_file_info_box, /* file_info_box */ | |
1239 NULL | |
1240 }; | |
1241 | |
1242 InputPlugin * | |
1243 get_iplugin_info(void) | |
1244 { | |
1245 mpg123_ip.description = g_strdup_printf(_("MPEG Audio Plugin")); | |
1246 return &mpg123_ip; | |
1247 } |