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
14 #include <sys/mman.h> /* mmap */
15 #include <sys/time.h> /* gettimeofday */
16 #include <sys/types.h>
26 #include "server.cmdline.h"
27 #include "afs_common.h"
33 extern const char *status_item_list
[];
35 static struct timeval announce_tv
;
36 static struct timeval data_send_barrier
;
37 static struct timeval eof_barrier
;
38 static struct timeval autoplay_barrier
;
40 extern struct misc_meta_data
*mmd
;
41 extern struct audio_file_selector selectors
[];
42 extern struct sender senders
[];
44 static int audio_file
;
47 /* The mp3 audio format handler does not need any libs. */
48 void mp3_init(struct audio_format_handler
*);
51 void ogg_init(struct audio_format_handler
*);
54 void aac_afh_init(struct audio_format_handler
*);
58 * The list of supported audio formats.
60 * We always define the full array of audio formats even if some audio formats
61 * were not compiled in. This is because for each audio file the number of its
62 * audio format is stored in the databse. We don't want that numbers to become
63 * stale just because the user installed a new version of paraslash that
64 * supports a different set of audio formats.
66 * It can still be easily detected whether an audio format is compiled in by
67 * checking if the init function pointer is not \p NULL.
69 static struct audio_format_handler afl
[] = {
91 static inline int next_audio_format(int format
)
94 if (!afl
[format
].name
)
103 /** Iterate over each supported audio format. */
104 #define FOR_EACH_AUDIO_FORMAT(i) for (i = 0; afl[i].name; i = next_audio_format(i))
108 * check if vss status flag \a P (playing) is set
110 * \return greater than zero if playing, zero otherwise.
113 unsigned int vss_playing(void)
115 return mmd
->new_vss_status_flags
& VSS_PLAYING
;
119 * check if \a N (next) status flag is set
121 * \return greater than zero if set, zero if not.
124 unsigned int vss_next(void)
126 return mmd
->new_vss_status_flags
& VSS_NEXT
;
130 * check if a reposition request is pending
132 * \return greater than zero if true, zero otherwise.
135 unsigned int vss_repos(void)
137 return mmd
->new_vss_status_flags
& VSS_REPOS
;
141 * check if the vss is currently paused
143 * \return greater than zero if paused, zero otherwise.
146 unsigned int vss_paused(void)
148 return !(mmd
->new_vss_status_flags
& VSS_NEXT
)
149 && !(mmd
->new_vss_status_flags
& VSS_PLAYING
);
153 * Get the name of the given audio format.
155 * \param i The audio format number.
157 * This returns a pointer to statically allocated memory so it
158 * must not be freed by the caller.
160 const char *audio_format_name(int i
)
162 //PARA_NOTICE_LOG("array size: %u¸ requested: %d\n", ARRAY_SIZE(afl), i);
163 assert(i
< 0 || i
< ARRAY_SIZE(afl
) - 1);
164 return i
>= 0? afl
[i
].name
: "(none)";
168 * initialize the virtual streaming system
170 * Call the init functions of all supported audio format handlers and
171 * initialize all supported senders.
176 char *hn
= para_hostname(), *home
= para_homedir();
177 long unsigned announce_time
= conf
.announce_time_arg
> 0?
178 conf
.announce_time_arg
: 300,
179 autoplay_delay
= conf
.autoplay_delay_arg
> 0?
180 conf
.autoplay_delay_arg
: 0;
182 PARA_DEBUG_LOG("supported audio formats: %s\n",
183 SUPPORTED_AUDIO_FORMATS
);
184 FOR_EACH_AUDIO_FORMAT(i
) {
185 PARA_NOTICE_LOG("initializing %s handler\n",
187 afl
[i
].init(&afl
[i
]);
189 ms2tv(announce_time
, &announce_tv
);
190 PARA_INFO_LOG("announce timeval: %lums\n", tv2ms(&announce_tv
));
191 for (i
= 0; senders
[i
].name
; i
++) {
192 PARA_NOTICE_LOG("initializing %s sender\n", senders
[i
].name
);
193 senders
[i
].init(&senders
[i
]);
197 if (conf
.autoplay_given
) {
198 struct timeval now
, tmp
;
199 mmd
->vss_status_flags
|= VSS_PLAYING
;
200 mmd
->new_vss_status_flags
|= VSS_PLAYING
;
201 gettimeofday(&now
, NULL
);
202 ms2tv(autoplay_delay
, &tmp
);
203 tv_add(&now
, &tmp
, &autoplay_barrier
);
208 * guess the audio format judging from filename
210 * \param name the filename
212 * \return This function returns -1 if it has no idea what kind of audio
213 * file this might be. Otherwise the (non-negative) number of the audio format
216 int guess_audio_format(const char *name
)
218 int i
,j
, len
= strlen(name
);
220 FOR_EACH_AUDIO_FORMAT(i
) {
221 for (j
= 0; afl
[i
].suffixes
[j
]; j
++) {
222 const char *p
= afl
[i
].suffixes
[j
];
223 int plen
= strlen(p
);
226 if (name
[len
- plen
- 1] != '.')
228 if (strcasecmp(name
+ len
- plen
, p
))
230 // PARA_DEBUG_LOG("might be %s\n", audio_format_name(i));
234 return -E_BAD_AUDIO_FILE_SUFFIX
;
238 * Call get_file_info() to obtain an afhi structure.
240 * \param path The full path of the audio file.
241 * \param data Pointer to the contents of the (mapped) file.
242 * \param size The file size in bytes.
243 * \param afhi Result pointer.
245 * \return The number of the audio format on success, \p -E_AUDIO_FORMAT if no
246 * compiled in audio format handler is able to handler the file.
248 * This function tries to find an audio format handler that can interpret the
249 * file given by \a data and \a size.
251 * It first tries to determine the audio format from the filename given by \a
252 * path. If this doesn't work, all other audio format handlers are tried until
253 * one is found that can handle the file.
255 int compute_afhi(const char *path
, char *data
, size_t size
,
256 struct audio_format_info
*afhi
)
258 int ret
, i
, format
= guess_audio_format(path
);
261 ret
= afl
[format
].get_file_info(data
, size
, afhi
);
265 FOR_EACH_AUDIO_FORMAT(i
) {
266 if (i
== format
) /* we already tried this one to no avail */
268 ret
= afl
[i
].get_file_info(data
, size
, afhi
);
271 PARA_WARNING_LOG("%s\n", PARA_STRERROR(-ret
));
273 return -E_AUDIO_FORMAT
;
276 static int chk_barrier(const char *bname
, const struct timeval
*now
,
277 const struct timeval
*barrier
, struct timeval
*diff
,
282 if (tv_diff(now
, barrier
, diff
) > 0)
286 PARA_DEBUG_LOG("%s barrier: %lims left\n", bname
, ms
);
290 static void vss_next_chunk_time(struct timeval
*due
)
294 tv_scale(mmd
->chunks_sent
, &mmd
->afi
.chunk_tv
, &tmp
);
295 tv_add(&tmp
, &mmd
->stream_start
, due
);
299 * != NULL: timeout for next chunk
300 * NULL: nothing to do
302 static struct timeval
*vss_compute_timeout(void)
304 static struct timeval the_timeout
;
305 struct timeval now
, next_chunk
;
307 if (vss_next() && mmd
->audio_format
>= 0) {
308 /* only sleep a bit, nec*/
309 the_timeout
.tv_sec
= 0;
310 the_timeout
.tv_usec
= 100;
313 gettimeofday(&now
, NULL
);
314 if (chk_barrier("autoplay_delay", &now
, &autoplay_barrier
,
315 &the_timeout
, 1) < 0)
317 if (chk_barrier("eof", &now
, &eof_barrier
, &the_timeout
, 1) < 0)
319 if (chk_barrier("data send", &now
, &data_send_barrier
,
320 &the_timeout
, 1) < 0)
322 if (mmd
->audio_format
< 0 || !vss_playing() || !map
)
324 vss_next_chunk_time(&next_chunk
);
325 if (chk_barrier(afl
[mmd
->audio_format
].name
, &now
, &next_chunk
,
326 &the_timeout
, 0) < 0)
328 /* chunk is due or bof */
329 the_timeout
.tv_sec
= 0;
330 the_timeout
.tv_usec
= 0;
334 static void vss_eof(void)
340 PARA_NOTICE_LOG("EOF\n");
342 for (i
= 0; senders
[i
].name
; i
++)
343 senders
[i
].shutdown_clients();
346 gettimeofday(&now
, NULL
);
347 tv_add(&mmd
->afi
.eof_tv
, &now
, &eof_barrier
);
348 munmap(map
, mmd
->size
);
351 mmd
->audio_format
= -1;
352 mmd
->chunks_sent
= 0;
354 mmd
->afi
.seconds_total
= 0;
355 free(mmd
->afi
.chunk_table
);
356 mmd
->afi
.chunk_table
= NULL
;
357 tmp
= make_message("%s:\n%s:\n%s:\n", status_item_list
[SI_AUDIO_INFO1
],
358 status_item_list
[SI_AUDIO_INFO2
], status_item_list
[SI_AUDIO_INFO3
]);
359 strcpy(mmd
->afi
.info_string
, tmp
);
361 tmp
= make_message("%s:\n%s:\n%s:\n", status_item_list
[SI_DBINFO1
],
362 status_item_list
[SI_DBINFO2
], status_item_list
[SI_DBINFO3
]);
363 strcpy(mmd
->selector_info
, tmp
);
365 mmd
->filename
[0] = '\0';
371 * Get the header of the current audio file.
373 * \param header_len the length of the header is stored here
375 * \return a pointer to a buffer containing the header, or NULL, if no audio
376 * file is selected or if the current audio format does not need special header
380 char *vss_get_header(size_t *header_len
)
382 if (mmd
->audio_format
< 0 || !map
|| !mmd
->afi
.header_len
)
384 *header_len
= mmd
->afi
.header_len
;
385 return map
+ mmd
->afi
.header_offset
;
389 * get the list of all supported audio formats
391 * \return a space separated list of all supported audio formats
392 * It is not allocated at runtime, i.e. there is no need to free
393 * the returned string in the caller.
395 const char *supported_audio_formats(void)
397 return SUPPORTED_AUDIO_FORMATS
;
401 * get the chunk time of the current audio file
403 * \return a pointer to a struct containing the chunk time, or NULL,
404 * if currently no audio file is selected.
406 struct timeval
*vss_chunk_time(void)
408 if (mmd
->audio_format
< 0)
410 return &mmd
->afi
.chunk_tv
;
413 enum afs_socket_status
{
415 AFS_SOCKET_CHECK_FOR_WRITE
,
416 AFS_SOCKET_AFD_PENDING
419 static enum afs_socket_status afsss
;
422 * Compute the timeout for para_server's main select-loop.
424 * This function gets called from para_server to determine the timeout value
425 * for its main select loop.
427 * Before the timeout is computed, the current vss status flags are evaluated
428 * and acted upon by calling appropriate functions from the lower layers.
429 * Possible actions include
431 * - request a new audio file from afs,
432 * - shutdown of all senders (stop/pause command),
433 * - reposition the stream (ff/jmp command).
435 * \return A pointer to a struct timeval containing the timeout for the next
436 * chunk of data to be sent, or NULL if we're not sending right now.
438 struct timeval
*vss_preselect(fd_set
*rfds
, fd_set
*wfds
, int *max_fileno
)
443 para_fd_set(afs_socket
, rfds
, max_fileno
);
445 for (i
= 0; senders
[i
].name
; i
++)
446 senders
[i
].shutdown_clients();
450 return vss_compute_timeout();
453 if (vss_paused() || vss_repos()) {
454 for (i
= 0; senders
[i
].name
; i
++)
455 senders
[i
].shutdown_clients();
458 gettimeofday(&now
, NULL
);
459 if (!vss_paused() || mmd
->chunks_sent
)
460 tv_add(&mmd
->afi
.eof_tv
, &now
, &eof_barrier
);
462 tv_add(&now
, &announce_tv
, &data_send_barrier
);
463 if (mmd
->new_vss_status_flags
& VSS_NOMORE
)
464 mmd
->new_vss_status_flags
= VSS_NEXT
;
466 mmd
->chunks_sent
= 0;
469 mmd
->new_vss_status_flags
&= ~(VSS_REPOS
);
470 mmd
->current_chunk
= mmd
->repos_request
;
472 tv
= vss_compute_timeout();
475 if (!map
&& vss_playing() &&
476 !(mmd
->new_vss_status_flags
& VSS_NOMORE
)) {
477 PARA_DEBUG_LOG("%s", "ready and playing, but no audio file\n");
478 if (afsss
== AFS_SOCKET_READY
) {
479 para_fd_set(afs_socket
, wfds
, max_fileno
);
480 afsss
= AFS_SOCKET_CHECK_FOR_WRITE
;
486 static int recv_afs_msg(int *fd
, uint32_t *code
, uint32_t *data
)
488 char control
[255], buf
[8];
489 struct msghdr msg
= {.msg_iov
= NULL
};
490 struct cmsghdr
*cmsg
;
495 iov
.iov_len
= sizeof(buf
);
498 msg
.msg_control
= control
;
499 msg
.msg_controllen
= sizeof(control
);
500 memset(buf
, 0, sizeof(buf
));
501 ret
= recvmsg(afs_socket
, &msg
, 0);
503 return -ERRNO_TO_PARA_ERROR(errno
);
504 if (iov
.iov_len
!= sizeof(buf
))
505 return -E_SHORT_AFS_READ
;
506 *code
= *(uint32_t*)buf
;
507 *data
= *(uint32_t*)(buf
+ 4);
508 cmsg
= CMSG_FIRSTHDR(&msg
);
509 for (cmsg
= CMSG_FIRSTHDR(&msg
); cmsg
; cmsg
= CMSG_NXTHDR(&msg
, cmsg
)) {
510 if (cmsg
->cmsg_level
!= SOL_SOCKET
511 || cmsg
->cmsg_type
!= SCM_RIGHTS
)
513 if ((cmsg
->cmsg_len
- CMSG_LEN(0)) / sizeof(int) != 1)
515 *fd
= *(int *)CMSG_DATA(cmsg
);
520 static void recv_afs_result(void)
522 int ret
, passed_fd
= -1, shmid
;
523 uint32_t afs_code
= 0, afs_data
= 0;
527 PARA_NOTICE_LOG("recv\n");
528 ret
= recv_afs_msg(&passed_fd
, &afs_code
, &afs_data
);
531 PARA_NOTICE_LOG("got the fd: %d, code: %u, shmid: %u\n",
532 passed_fd
, afs_code
, afs_data
);
533 ret
= -E_BAD_AFS_CODE
;
534 if (afs_code
!= NEXT_AUDIO_FILE
)
536 afsss
= AFS_SOCKET_READY
;
538 ret
= load_afd(shmid
, &mmd
->afd
);
542 PARA_NOTICE_LOG("next audio file: %s (%lu chunks)\n", mmd
->afd
.path
,
543 mmd
->afd
.afhi
.chunks_total
);
544 ret
= fstat(passed_fd
, &statbuf
);
546 ret
= -ERRNO_TO_PARA_ERROR(errno
);
549 mmd
->size
= statbuf
.st_size
;
550 mmd
->mtime
= statbuf
.st_mtime
;
551 map
= para_mmap(mmd
->size
, PROT_READ
, MAP_PRIVATE
,
553 strcpy(mmd
->filename
, mmd
->afd
.path
); /* FIXME: check length */
554 mmd
->afi
.header_len
= 0; /* default: no header */
555 mmd
->audio_format
= mmd
->afd
.afsi
.audio_format_id
;
556 mmd
->chunks_sent
= 0;
557 mmd
->current_chunk
= 0;
561 mmd
->afi
= mmd
->afd
.afhi
;
562 mmd
->new_vss_status_flags
&= (~VSS_NEXT
);
563 gettimeofday(&now
, NULL
);
564 tv_add(&now
, &announce_tv
, &data_send_barrier
);
569 PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret
));
572 void vss_post_select(fd_set
*rfds
, fd_set
*wfds
)
576 if (FD_ISSET(afs_socket
, rfds
))
578 if (afsss
!= AFS_SOCKET_CHECK_FOR_WRITE
|| !FD_ISSET(afs_socket
, wfds
))
580 PARA_NOTICE_LOG("requesting new socket\n");
581 ret
= send_buffer(afs_socket
, "new");
582 afsss
= AFS_SOCKET_AFD_PENDING
;
585 static void get_chunk(long unsigned chunk_num
, char **buf
, size_t *len
)
587 size_t pos
= mmd
->afi
.chunk_table
[chunk_num
];
589 *len
= mmd
->afi
.chunk_table
[chunk_num
+ 1] - pos
;
591 if (chunk_num
+ 5 > mmd
->afd
.afhi
.chunks_total
)
592 PARA_NOTICE_LOG("chunk %lu/%lu\n, len: %zu\n", chunk_num
,
593 mmd
->afd
.afhi
.chunks_total
, *len
);
597 * Get the data of the given chunk.
599 * \param chunk_num The number of the desired chunk.
600 * \param buf Chunk data.
601 * \param len Chunk length in bytes.
603 * \return Positive on success, negative on errors.
605 int vss_get_chunk(long unsigned chunk_num
, char **buf
, size_t *len
)
607 if (mmd
->audio_format
< 0 || !map
|| !vss_playing())
609 if (chunk_num
>= mmd
->afi
.chunks_total
)
611 get_chunk(chunk_num
, buf
, len
);
616 * main sending function
618 * This function gets called from para_server as soon as the next chunk of
619 * data should be pushed out. It first calls the read_chunk() function of
620 * the current audio format handler to obtain a pointer to the data to be
621 * sent out as well as its length. This information is then passed to each
622 * supported sender's send() function which does the actual sending.
624 void vss_send_chunk(void)
627 struct timeval now
, due
;
631 if (mmd
->audio_format
< 0 || !map
|| !vss_playing())
633 gettimeofday(&now
, NULL
);
634 vss_next_chunk_time(&due
);
635 if (tv_diff(&due
, &now
, NULL
) > 0)
637 if (chk_barrier("eof", &now
, &eof_barrier
, &due
, 1) < 0)
639 if (chk_barrier("data send", &now
, &data_send_barrier
,
642 mmd
->new_vss_status_flags
&= ~VSS_REPOS
;
643 if (mmd
->current_chunk
>= mmd
->afi
.chunks_total
) { /* eof */
644 mmd
->new_vss_status_flags
|= VSS_NEXT
;
648 * We call the send function also in case of empty chunks as they
649 * might have still some data queued which can be sent in this case.
651 if (!mmd
->chunks_sent
) {
653 gettimeofday(&mmd
->stream_start
, NULL
);
654 tv_scale(mmd
->current_chunk
, &mmd
->afi
.chunk_tv
, &tmp
);
655 mmd
->offset
= tv2ms(&tmp
);
658 get_chunk(mmd
->current_chunk
, &buf
, &len
);
659 for (i
= 0; senders
[i
].name
; i
++)
660 senders
[i
].send(mmd
->current_chunk
, mmd
->chunks_sent
, buf
, len
);
661 mmd
->new_vss_status_flags
|= VSS_PLAYING
;
663 mmd
->current_chunk
++;