2 * Copyright (C) 1997-2007 Andre Noll <maan@systemlinux.org>
4 * Licensed under the GPL v2. For licencing details see COPYING.
7 /** \file vss.c the virtual streaming system
9 * This contains the audio streaming code of para_server which is independent
10 * of the current audio format, audio file selector and of the activated
17 #include <sys/mman.h> /* mmap */
18 #include <sys/time.h> /* gettimeofday */
19 #include "server.cmdline.h"
20 #include "afs_common.h"
27 extern const char *status_item_list
[];
29 static struct timeval announce_tv
;
30 static struct timeval data_send_barrier
;
31 static struct timeval eof_barrier
;
32 static struct timeval autoplay_barrier
;
34 extern struct misc_meta_data
*mmd
;
35 extern struct audio_file_selector selectors
[];
36 extern struct sender senders
[];
38 static int audio_file
;
41 /* The mp3 audio format handler does not need any libs. */
42 void mp3_init(struct audio_format_handler
*);
45 void ogg_init(struct audio_format_handler
*);
48 void aac_afh_init(struct audio_format_handler
*);
52 * The list of supported audio formats.
54 * We always define the full array of audio formats even if some audio formats
55 * were not compiled in. This is because for each audio file the number of its
56 * audio format is stored in the databse. We don't want that numbers to become
57 * stale just because the user installed a new version of paraslash that
58 * supports a different set of audio formats.
60 * It can still be easily detected whether an audio format is compiled in by
61 * checking if the init function pointer is not \p NULL.
63 static struct audio_format_handler afl
[] = {
85 static inline int next_audio_format(int format
)
88 if (!afl
[format
].name
)
97 /** Iterate over each supported audio format. */
98 #define FOR_EACH_AUDIO_FORMAT(i) for (i = 0; afl[i].name; i = next_audio_format(i))
102 * check if vss status flag \a P (playing) is set
104 * \return greater than zero if playing, zero otherwise.
107 unsigned int vss_playing(void)
109 return mmd
->new_vss_status_flags
& VSS_PLAYING
;
113 * check if \a N (next) status flag is set
115 * \return greater than zero if set, zero if not.
118 unsigned int vss_next(void)
120 return mmd
->new_vss_status_flags
& VSS_NEXT
;
124 * check if a reposition request is pending
126 * \return greater than zero if true, zero otherwise.
129 unsigned int vss_repos(void)
131 return mmd
->new_vss_status_flags
& VSS_REPOS
;
135 * check if the vss is currently paused
137 * \return greater than zero if paused, zero otherwise.
140 unsigned int vss_paused(void)
142 return !(mmd
->new_vss_status_flags
& VSS_NEXT
)
143 && !(mmd
->new_vss_status_flags
& VSS_PLAYING
);
147 * get the name of the given audio format
149 * \param i the audio format number
151 * This returns a pointer to statically allocated memory so it
152 * must not be freed by the caller.
154 const char *audio_format_name(int i
)
156 return i
>= 0? afl
[i
].name
: "(none)";
160 * initialize the virtual streaming system
162 * Call the init functions of all supported audio format handlers and
163 * initialize all supported senders.
168 char *hn
= para_hostname(), *home
= para_homedir();
169 long unsigned announce_time
= conf
.announce_time_arg
> 0?
170 conf
.announce_time_arg
: 300,
171 autoplay_delay
= conf
.autoplay_delay_arg
> 0?
172 conf
.autoplay_delay_arg
: 0;
174 PARA_DEBUG_LOG("supported audio formats: %s\n",
175 SUPPORTED_AUDIO_FORMATS
);
176 FOR_EACH_AUDIO_FORMAT(i
) {
177 PARA_NOTICE_LOG("initializing %s handler\n",
179 afl
[i
].init(&afl
[i
]);
181 ms2tv(announce_time
, &announce_tv
);
182 PARA_INFO_LOG("announce timeval: %lums\n", tv2ms(&announce_tv
));
183 for (i
= 0; senders
[i
].name
; i
++) {
184 PARA_NOTICE_LOG("initializing %s sender\n", senders
[i
].name
);
185 senders
[i
].init(&senders
[i
]);
189 if (conf
.autoplay_given
) {
190 struct timeval now
, tmp
;
191 mmd
->vss_status_flags
|= VSS_PLAYING
;
192 mmd
->new_vss_status_flags
|= VSS_PLAYING
;
193 gettimeofday(&now
, NULL
);
194 ms2tv(autoplay_delay
, &tmp
);
195 tv_add(&now
, &tmp
, &autoplay_barrier
);
199 static int get_file_info(int i
)
201 return afl
[i
].get_file_info(map
, mmd
->size
, &mmd
->afi
);
205 * guess the audio format judging from filename
207 * \param name the filename
209 * \return This function returns -1 if it has no idea what kind of audio
210 * file this might be. Otherwise the (non-negative) number of the audio format
213 int guess_audio_format(const char *name
)
215 int i
,j
, len
= strlen(name
);
217 FOR_EACH_AUDIO_FORMAT(i
) {
218 for (j
= 0; afl
[i
].suffixes
[j
]; j
++) {
219 const char *p
= afl
[i
].suffixes
[j
];
220 int plen
= strlen(p
);
223 if (name
[len
- plen
- 1] != '.')
225 if (strcasecmp(name
+ len
- plen
, p
))
227 // PARA_DEBUG_LOG("might be %s\n", audio_format_name(i));
234 static int get_audio_format(int omit
)
238 FOR_EACH_AUDIO_FORMAT(i
) {
241 if (get_file_info(i
) > 0)
244 return -E_AUDIO_FORMAT
;
248 * Call get_file_info() to obtain an afhi structure.
250 * \param path The full path of the audio file.
251 * \param data Pointer to the contents of the (mapped) file.
252 * \param size The file size in bytes.
253 * \param afhi Result pointer.
255 * \return The number of the audio format on success, \p -E_AUDIO_FORMAT if no
256 * compiled in audio format handler is able to handler the file.
258 * This function tries to find an audio format handler that can interpret the
259 * file given by \a data and \a size.
261 * It first tries to determine the audio format from the filename given by \a
262 * path. If this doesn't work, all other audio format handlers are tried until
263 * one is found that can handle the file.
265 int compute_afhi(const char *path
, char *data
, size_t size
,
266 struct audio_format_info
*afhi
)
268 int ret
, i
, format
= guess_audio_format(path
);
271 ret
= afl
[format
].get_file_info(data
, size
, afhi
);
275 FOR_EACH_AUDIO_FORMAT(i
) {
276 if (i
== format
) /* we already tried this one to no avail */
278 ret
= afl
[i
].get_file_info(data
, size
, afhi
);
282 return -E_AUDIO_FORMAT
;
288 static int update_mmd(void)
292 i
= guess_audio_format(mmd
->filename
);
293 if (i
< 0 || get_file_info(i
) < 0)
294 i
= get_audio_format(i
);
297 mmd
->audio_format
= i
;
298 mmd
->chunks_sent
= 0;
299 mmd
->current_chunk
= 0;
305 static void vss_get_audio_file(void)
307 char **sl
= selectors
[mmd
->selector_num
].get_audio_file_list(10);
309 struct stat file_status
;
313 for (i
= 0; sl
[i
]; i
++) {
315 PARA_INFO_LOG("trying %s\n", sl
[i
]);
316 if (strlen(sl
[i
]) >= _POSIX_PATH_MAX
)
318 audio_file
= open(sl
[i
], O_RDONLY
);
321 if (fstat(audio_file
, &file_status
) == -1 ||
322 !file_status
.st_size
) {
326 mmd
->size
= file_status
.st_size
;
327 mmd
->mtime
= file_status
.st_mtime
;
328 map
= para_mmap(mmd
->size
, PROT_READ
, MAP_PRIVATE
,
330 strcpy(mmd
->filename
, sl
[i
]);
331 mmd
->afi
.header_len
= 0; /* default: no header */
332 if (update_mmd() < 0) { /* invalid file */
334 munmap(map
, mmd
->size
);
339 if (selectors
[mmd
->selector_num
].update_audio_file
)
340 selectors
[mmd
->selector_num
].update_audio_file(sl
[i
]);
341 PARA_NOTICE_LOG("next audio file: %s\n", mmd
->filename
);
342 mmd
->new_vss_status_flags
&= (~VSS_NEXT
);
343 gettimeofday(&now
, NULL
);
344 tv_add(&now
, &announce_tv
, &data_send_barrier
);
348 PARA_ERROR_LOG("%s", "no valid files found\n");
349 mmd
->new_vss_status_flags
= VSS_NEXT
;
352 for (i
= 0; sl
[i
]; i
++)
358 static int chk_barrier(const char *bname
, const struct timeval
*now
,
359 const struct timeval
*barrier
, struct timeval
*diff
,
364 if (tv_diff(now
, barrier
, diff
) > 0)
368 PARA_DEBUG_LOG("%s barrier: %lims left\n", bname
, ms
);
372 static void vss_next_chunk_time(struct timeval
*due
)
376 tv_scale(mmd
->chunks_sent
, &mmd
->afi
.chunk_tv
, &tmp
);
377 tv_add(&tmp
, &mmd
->stream_start
, due
);
381 * != NULL: timeout for next chunk
382 * NULL: nothing to do
384 static struct timeval
*vss_compute_timeout(void)
386 static struct timeval the_timeout
;
387 struct timeval now
, next_chunk
;
389 if (vss_next() && mmd
->audio_format
>= 0) {
390 /* only sleep a bit, nec*/
391 the_timeout
.tv_sec
= 0;
392 the_timeout
.tv_usec
= 100;
395 gettimeofday(&now
, NULL
);
396 if (chk_barrier("autoplay_delay", &now
, &autoplay_barrier
,
397 &the_timeout
, 1) < 0)
399 if (chk_barrier("eof", &now
, &eof_barrier
, &the_timeout
, 1) < 0)
401 if (chk_barrier("data send", &now
, &data_send_barrier
,
402 &the_timeout
, 1) < 0)
404 if (mmd
->audio_format
< 0 || !vss_playing() || !map
)
406 vss_next_chunk_time(&next_chunk
);
407 if (chk_barrier(afl
[mmd
->audio_format
].name
, &now
, &next_chunk
,
408 &the_timeout
, 0) < 0)
410 /* chunk is due or bof */
411 the_timeout
.tv_sec
= 0;
412 the_timeout
.tv_usec
= 0;
416 static void vss_eof(void)
423 for (i
= 0; senders
[i
].name
; i
++)
424 senders
[i
].shutdown_clients();
427 gettimeofday(&now
, NULL
);
428 tv_add(&mmd
->afi
.eof_tv
, &now
, &eof_barrier
);
429 munmap(map
, mmd
->size
);
432 mmd
->audio_format
= -1;
433 mmd
->chunks_sent
= 0;
435 mmd
->afi
.seconds_total
= 0;
436 free(mmd
->afi
.chunk_table
);
437 mmd
->afi
.chunk_table
= NULL
;
438 tmp
= make_message("%s:\n%s:\n%s:\n", status_item_list
[SI_AUDIO_INFO1
],
439 status_item_list
[SI_AUDIO_INFO2
], status_item_list
[SI_AUDIO_INFO3
]);
440 strcpy(mmd
->afi
.info_string
, tmp
);
442 tmp
= make_message("%s:\n%s:\n%s:\n", status_item_list
[SI_DBINFO1
],
443 status_item_list
[SI_DBINFO2
], status_item_list
[SI_DBINFO3
]);
444 strcpy(mmd
->selector_info
, tmp
);
446 mmd
->filename
[0] = '\0';
452 * Get the header of the current audio file.
454 * \param header_len the length of the header is stored here
456 * \return a pointer to a buffer containing the header, or NULL, if no audio
457 * file is selected or if the current audio format does not need special header
461 char *vss_get_header(size_t *header_len
)
463 if (mmd
->audio_format
< 0 || !map
|| !mmd
->afi
.header_len
)
465 *header_len
= mmd
->afi
.header_len
;
466 return map
+ mmd
->afi
.header_offset
;
470 * get the list of all supported audio formats
472 * \return a space separated list of all supported audio formats
473 * It is not allocated at runtime, i.e. there is no need to free
474 * the returned string in the caller.
476 const char *supported_audio_formats(void)
478 return SUPPORTED_AUDIO_FORMATS
;
482 * get the chunk time of the current audio file
484 * \return a pointer to a struct containing the chunk time, or NULL,
485 * if currently no audio file is selected.
487 struct timeval
*vss_chunk_time(void)
489 if (mmd
->audio_format
< 0)
491 return &mmd
->afi
.chunk_tv
;
495 * compute the timeout for para_server's main select-loop
497 * This function gets called from para_server to determine the timeout value
498 * for its main select loop.
500 * Before the timeout is computed, the current vss status flags are evaluated
501 * and acted upon by calling appropriate functions from the lower layers.
502 * Possible actions include
504 * - request a new file list from the current audio file selector
505 * - shutdown of all senders (stop/pause command)
506 * - reposition the stream (ff/jmp command)
508 * \return A pointer to a struct timeval containing the timeout for the next
509 * chunk of data to be sent, or NULL if we're not sending right now.
511 struct timeval
*vss_preselect(void)
513 struct audio_format_handler
*af
= NULL
;
517 format
= mmd
->audio_format
;
521 for (i
= 0; senders
[i
].name
; i
++)
522 senders
[i
].shutdown_clients();
523 if (vss_next() && af
) {
525 return vss_compute_timeout();
527 if (vss_paused() || vss_repos()) {
528 for (i
= 0; senders
[i
].name
; i
++)
529 senders
[i
].shutdown_clients();
532 gettimeofday(&now
, NULL
);
533 if (!vss_paused() || mmd
->chunks_sent
)
534 tv_add(&mmd
->afi
.eof_tv
, &now
, &eof_barrier
);
536 tv_add(&now
, &announce_tv
, &data_send_barrier
);
537 if (mmd
->new_vss_status_flags
& VSS_NOMORE
)
538 mmd
->new_vss_status_flags
= VSS_NEXT
;
540 mmd
->chunks_sent
= 0;
543 mmd
->new_vss_status_flags
&= ~(VSS_REPOS
);
544 mmd
->current_chunk
= mmd
->repos_request
;
546 ret
= vss_compute_timeout();
547 if (!ret
&& !map
&& vss_playing() &&
548 !(mmd
->new_vss_status_flags
& VSS_NOMORE
)) {
549 PARA_DEBUG_LOG("%s", "ready and playing, but no audio file\n");
550 vss_get_audio_file();
556 static void get_chunk(long unsigned chunk_num
, char **buf
, size_t *len
)
558 size_t pos
= mmd
->afi
.chunk_table
[chunk_num
];
560 *len
= mmd
->afi
.chunk_table
[chunk_num
+ 1] - pos
;
564 * Get the data of the given chunk.
566 * \param chunk_num The number of the desired chunk.
567 * \param buf Chunk data.
568 * \param len Chunk length in bytes.
570 * \return Positive on success, negative on errors.
572 int vss_get_chunk(long unsigned chunk_num
, char **buf
, size_t *len
)
574 if (mmd
->audio_format
< 0 || !map
|| !vss_playing())
576 if (chunk_num
>= mmd
->afi
.chunks_total
)
578 get_chunk(chunk_num
, buf
, len
);
583 * main sending function
585 * This function gets called from para_server as soon as the next chunk of
586 * data should be pushed out. It first calls the read_chunk() function of
587 * the current audio format handler to obtain a pointer to the data to be
588 * sent out as well as its length. This information is then passed to each
589 * supported sender's send() function which does the actual sending.
591 void vss_send_chunk(void)
594 struct audio_format_handler
*af
;
595 struct timeval now
, due
;
597 if (mmd
->audio_format
< 0 || !map
|| !vss_playing())
599 af
= &afl
[mmd
->audio_format
];
600 gettimeofday(&now
, NULL
);
601 vss_next_chunk_time(&due
);
602 if (tv_diff(&due
, &now
, NULL
) > 0)
604 if (chk_barrier("eof", &now
, &eof_barrier
, &due
, 1) < 0)
606 if (chk_barrier("data send", &now
, &data_send_barrier
,
609 mmd
->new_vss_status_flags
&= ~VSS_REPOS
;
610 if (mmd
->current_chunk
>= mmd
->afi
.chunks_total
) { /* eof */
611 mmd
->new_vss_status_flags
|= VSS_NEXT
;
615 * We call the send function also in case of empty chunks as they
616 * might have still some data queued which can be sent in this case.
618 if (!mmd
->chunks_sent
) {
620 gettimeofday(&mmd
->stream_start
, NULL
);
621 tv_scale(mmd
->current_chunk
, &mmd
->afi
.chunk_tv
, &tmp
);
622 mmd
->offset
= tv2ms(&tmp
);
625 for (i
= 0; senders
[i
].name
; i
++) {
628 get_chunk(mmd
->current_chunk
, &buf
, &len
);
629 senders
[i
].send(mmd
->current_chunk
, mmd
->chunks_sent
, buf
, len
);
631 mmd
->new_vss_status_flags
|= VSS_PLAYING
;
633 mmd
->current_chunk
++;