X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=vss.c;h=1a038f060bd1f0e2ecfd842e9f08fd7f704f70e2;hp=d0e1cf53242a52bbdcef4b486136747239784734;hb=d96c06ff93493c125b9f4d36655e77d7029ca309;hpb=132ab6b63568104d28af23a9682c770a0aaedf03 diff --git a/vss.c b/vss.c index d0e1cf53..1a038f06 100644 --- a/vss.c +++ b/vss.c @@ -11,7 +11,9 @@ * senders. */ +#include #include +#include #include "para.h" #include "error.h" @@ -87,6 +89,8 @@ struct vss_task { const char *header_buf; /** Length of the audio file header. */ size_t header_len; + /** Time between audio file headers are sent. */ + struct timeval header_interval; }; /** @@ -96,27 +100,17 @@ struct vss_task { */ static struct list_head fec_client_list; -/** - * Describes one slice of a FEC group. - * - * FEC slices directly correspond to the data packages sent by the paraslash - * senders that use FEC. Each slice is identified by its group number and its - * number within the group. All slices have the same size, but the last slice - * of the group may not be filled entirely. - */ -struct fec_slice { - /** The slice number within the FEC group. */ - uint8_t num; - /** The number of used bytes in this slice. */ - uint16_t bytes; -}; - /** * Data associated with one FEC group. * * A FEC group consists of a fixed number of slices and this number is given by * the \a slices_per_group parameter of struct \ref fec_client_parms. Each FEC * group contains a number of chunks of the current audio file. + * + * FEC slices directly correspond to the data packages sent by the paraslash + * senders that use FEC. Each slice is identified by its group number and its + * number within the group. All slices have the same size, but the last slice + * of the group may not be filled entirely. */ struct fec_group { /** The number of the FEC group. */ @@ -127,18 +121,22 @@ struct fec_group { uint32_t first_chunk; /** The number of chunks contained in this group. */ uint32_t num_chunks; - /** The time needed to play all chunks of the group. */ - struct timeval duration; /** When the first chunk was sent. */ struct timeval start; - /** \a The group duration divided by \a slices_per_group. */ + /** The duration of the full group. */ + struct timeval duration; + /** The group duration divided by the number of slices. */ struct timeval slice_duration; + /** Group contains the audio file header that occupies that many slices. */ + uint8_t num_header_slices; }; /** * Describes one connected FEC client. */ struct fec_client { + /** If negative, this client is temporarily disabled. */ + int error; /** Parameters requested by the client. */ struct fec_client_parms *fcp; /** Used by the core FEC code. */ @@ -151,18 +149,18 @@ struct fec_client { int first_stream_chunk; /** Describes the current group. */ struct fec_group group; - /** Describes the current slice. */ - struct fec_slice slice; + /** The current slice. */ + uint8_t current_slice_num; /** The data to be FEC-encoded (point to a region within the mapped audio file). */ const unsigned char **src_data; - /** Used for the last source pointer of the last group. */ + /** Last time an audio header was sent. */ + struct timeval next_header_time; + /** Used for the last source pointer of an audio file. */ unsigned char *extra_src_buf; - /** The size of the buffer for the extra source pointer. */ - size_t extra_src_buf_size; - /** Contains FEC-encoded data. */ + /** Extra slices needed to store largest chunk + header. */ + int num_extra_slices; + /** Contains the FEC-encoded data. */ unsigned char *enc_buf; - /** Size of \a enc_buf. */ - size_t enc_buf_size; }; /** @@ -185,114 +183,208 @@ struct timeval *vss_chunk_time(void) * \param buf The buffer to write to. * \param h The fec header to write. */ -static void write_fec_header(struct fec_client *fc) +static void write_fec_header(struct fec_client *fc, struct vss_task *vsst) { char *buf = (char *)fc->enc_buf; + struct fec_group *g = &fc->group; + struct fec_client_parms *p = fc->fcp; write_u32(buf, FEC_MAGIC); - write_u8(buf + 4, fc->fcp->slices_per_group); - write_u8(buf + 5, fc->fcp->data_slices_per_group); - write_u32(buf + 6, (uint32_t)0); /* audio header len */ + write_u8(buf + 4, p->slices_per_group + fc->num_extra_slices); + write_u8(buf + 5, p->data_slices_per_group + fc->num_extra_slices); + write_u32(buf + 6, g->num_header_slices? vsst->header_len : 0); - write_u32(buf + 10, fc->group.num); - write_u32(buf + 14, fc->group.bytes); + write_u32(buf + 10, g->num); + write_u32(buf + 14, g->bytes); - write_u8(buf + 18, fc->slice.num); - write_u16(buf + 20, fc->slice.bytes); - memset(buf + 22, 0, 11); + write_u8(buf + 18, fc->current_slice_num); + write_u16(buf + 20, p->max_slice_bytes - FEC_HEADER_SIZE); + write_u8(buf + 22, g->first_chunk? 0 : 1); + write_u8(buf + 23, vsst->header_len? 1 : 0); + memset(buf + 24, 0, 7); +} + +static int need_audio_header(struct fec_client *fc, struct vss_task *vsst) +{ + if (!mmd->current_chunk) { + tv_add(now, &vsst->header_interval, &fc->next_header_time); + return 0; + } + if (!vsst->header_buf) + return 0; + if (!vsst->header_len) + return 0; + if (fc->group.num && tv_diff(&fc->next_header_time, now, NULL) > 0) + return 0; + tv_add(now, &vsst->header_interval, &fc->next_header_time); + return 1; +} + +static int num_slices(long unsigned bytes, struct fec_client *fc, uint8_t *result) +{ + unsigned long m = fc->fcp->max_slice_bytes - FEC_HEADER_SIZE; + unsigned rv, redundant_slices = fc->fcp->slices_per_group + - fc->fcp->data_slices_per_group; + + if (!m) + return -E_BAD_CT; + rv = (bytes + m - 1) / m; + if (rv + redundant_slices > 255) + return -E_BAD_CT; + *result = rv; + return 1; +} + +/* set group start and group duration */ +static void set_group_timing(struct fec_client *fc, struct fec_group *g) +{ + struct timeval *chunk_tv = vss_chunk_time(); + + tv_scale(g->num_chunks, chunk_tv, &g->duration); + tv_divide(fc->fcp->slices_per_group + fc->num_extra_slices, + &g->duration, &g->slice_duration); + PARA_DEBUG_LOG("durations (group/chunk/slice): %lu/%lu/%lu\n", + tv2ms(&g->duration), tv2ms(chunk_tv), tv2ms(&g->slice_duration)); } static int setup_next_fec_group(struct fec_client *fc, struct vss_task *vsst) { - uint32_t max_group_size, last_payload_size; - int i, k = fc->fcp->data_slices_per_group; + int ret, i, k, data_slices; size_t len; - const char *start_buf; - struct timeval tmp, *chunk_tv = vss_chunk_time(); + const char *buf, *start_buf; + struct fec_group *g = &fc->group; + unsigned slice_bytes = fc->fcp->max_slice_bytes - FEC_HEADER_SIZE; + uint32_t max_data_size; - assert(chunk_tv); if (fc->first_stream_chunk < 0) { + uint8_t hs, ds; /* needed header/data slices */ + uint8_t rs = fc->fcp->slices_per_group + - fc->fcp->data_slices_per_group; /* redundant slices */ + int n; + + ret = num_slices(vsst->header_len, fc, &hs); + if (ret < 0) + return ret; + ret = num_slices(afh_get_largest_chunk_size(&mmd->afd.afhi), + fc, &ds); + if (ret < 0) + return ret; + k = (int)hs + ds; + if (k > 255) + return -E_BAD_CT; + if (k < fc->fcp->data_slices_per_group) + k = fc->fcp->data_slices_per_group; + n = k + rs; + fc->num_extra_slices = k - fc->fcp->data_slices_per_group; + PARA_NOTICE_LOG("fec parms %d:%d:%d (%d extra slices)\n", + slice_bytes, k, n, fc->num_extra_slices); + fec_free(fc->parms); + fc->src_data = para_realloc(fc->src_data, k * sizeof(char *)); + ret = fec_new(k, n, &fc->parms); + if (ret < 0) + return ret; fc->stream_start = *now; fc->first_stream_chunk = mmd->current_chunk; - fc->group.first_chunk = mmd->current_chunk; - fc->group.num = 0; + g->first_chunk = mmd->current_chunk; + g->num = 0; + g->start = *now; } else { - fc->group.first_chunk += fc->group.num_chunks; - fc->group.num++; + /* + * Start and duration of this group depend only on the previous + * group. Compute the new group start as g->start += g->duration. + */ + struct timeval tmp = g->start; + tv_add(&tmp, &g->duration, &g->start); + k = fc->fcp->data_slices_per_group + fc->num_extra_slices; + set_group_timing(fc, g); + g->first_chunk += g->num_chunks; + g->num++; } - if (fc->group.first_chunk >= mmd->afd.afhi.chunks_total) + if (g->first_chunk >= mmd->afd.afhi.chunks_total) return 0; - max_group_size = (fc->fcp->max_slice_bytes - FEC_HEADER_SIZE) * k; - afh_get_chunk(fc->group.first_chunk, &mmd->afd.afhi, vsst->map, - &start_buf, &len); - for (i = fc->group.first_chunk, fc->group.bytes = 0; - i < mmd->afd.afhi.chunks_total; i++) { - const char *buf; - + if (need_audio_header(fc, vsst)) { + ret = num_slices(vsst->header_len, fc, &g->num_header_slices); + if (ret < 0) + return ret; + } else + g->num_header_slices = 0; + afh_get_chunk(g->first_chunk, &mmd->afd.afhi, vsst->map, &start_buf, + &len); + data_slices = k - g->num_header_slices; + assert(data_slices); + max_data_size = slice_bytes * data_slices; + g->bytes = 0; + for (i = g->first_chunk; i < mmd->afd.afhi.chunks_total; i++) { afh_get_chunk(i, &mmd->afd.afhi, vsst->map, &buf, &len); - if (fc->group.bytes + len > max_group_size) + if (g->bytes + len > max_data_size) break; - fc->group.bytes += len; + g->bytes += len; + } + g->num_chunks = i - g->first_chunk; + assert(g->num_chunks); + fc->current_slice_num = 0; + if (g->num == 0) + set_group_timing(fc, g); + + /* setup header slices */ + buf = vsst->header_buf; + for (i = 0; i < g->num_header_slices; i++) { + fc->src_data[i] = (const unsigned char *)buf; + buf += slice_bytes; } - fc->group.num_chunks = i - fc->group.first_chunk; - fc->slice.num = 0; - fc->slice.bytes = ROUND_UP(fc->group.bytes, k) / k; - /* FIXME: Avoid division by zero in a better way */ - if (!fc->slice.bytes) - return 0; - /* The last slice will not be fully used */ - last_payload_size = fc->group.bytes % fc->slice.bytes; - if (!last_payload_size) - last_payload_size = fc->slice.bytes; - - tv_scale(fc->group.first_chunk - fc->first_stream_chunk, chunk_tv, - &tmp); - tv_add(&fc->stream_start, &tmp, &fc->group.start); - if (fc->group.num) /* quick hack to avoid buffer underruns */ - fc->group.start.tv_sec--; - tv_scale(fc->group.num_chunks, chunk_tv, &fc->group.duration); - tv_divide(fc->fcp->slices_per_group, &fc->group.duration, - &fc->group.slice_duration); - - for (i = 0; i < k; i++) - fc->src_data[i] = (const unsigned char *)start_buf - + i * fc->slice.bytes; - - if (start_buf + k * fc->slice.bytes > vsst->map + mmd->size) { - /* can not use last slice as it goes beyond the map */ - if (fc->extra_src_buf_size < fc->slice.bytes) { - fc->extra_src_buf = para_realloc(fc->extra_src_buf, fc->slice.bytes); - fc->extra_src_buf_size = fc->slice.bytes; - } - memcpy(fc->extra_src_buf, start_buf + (k - 1) * fc->slice.bytes, - last_payload_size); - memset(fc->extra_src_buf + last_payload_size, 0, - fc->slice.bytes - last_payload_size); - fc->src_data[k - 1] = fc->extra_src_buf; + /* setup data slices */ + buf = start_buf; + for (i = g->num_header_slices; i < k; i++) { + if (buf + slice_bytes > vsst->map + mmd->size) + /* + * Can not use the memory mapped audio file for this + * slice as it goes beyond the map. This slice will not + * be fully used. + */ + break; + fc->src_data[i] = (const unsigned char *)buf; + buf += slice_bytes; } - if (fc->enc_buf_size < fc->slice.bytes + FEC_HEADER_SIZE) { - fc->enc_buf_size = fc->slice.bytes + FEC_HEADER_SIZE; - fc->enc_buf = para_realloc(fc->enc_buf, fc->enc_buf_size); + if (i < k) { + uint32_t payload_size = vsst->map + mmd->size - buf; + memcpy(fc->extra_src_buf, buf, payload_size); + fc->src_data[i] = fc->extra_src_buf; + i++; + /* use arbitrary data for all remaining slices */ + buf = vsst->map; + for (; i < k; i++) + fc->src_data[i] = (const unsigned char *)buf; } - PARA_INFO_LOG("FEC group %d: %d chunks (%d - %d), duration: %lums\n", - fc->group.num, fc->group.num_chunks, fc->group.first_chunk, - fc->group.first_chunk + fc->group.num_chunks - 1, - tv2ms(&fc->group.duration)); + PARA_DEBUG_LOG("FEC group %d: %d chunks (%d - %d), " + "%d header slices, %d data slices\n", + g->num, g->num_chunks, g->first_chunk, + g->first_chunk + g->num_chunks - 1, + g->num_header_slices, data_slices + ); return 1; } static int compute_next_fec_slice(struct fec_client *fc, struct vss_task *vsst) { - if (fc->first_stream_chunk < 0 || fc->slice.num - == fc->fcp->slices_per_group) { - if (!setup_next_fec_group(fc, vsst)) + assert(fc->error >= 0); + if (fc->first_stream_chunk < 0 || fc->current_slice_num + == fc->fcp->slices_per_group + fc->num_extra_slices) { + int ret = setup_next_fec_group(fc, vsst); + if (ret == 0) return 0; + if (ret < 0) { + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + PARA_ERROR_LOG("FEC client temporarily disabled\n"); + fc->error = ret; + return fc->error; + } } - write_fec_header(fc); + write_fec_header(fc, vsst); fec_encode(fc->parms, fc->src_data, fc->enc_buf + FEC_HEADER_SIZE, - fc->slice.num, fc->slice.bytes); + fc->current_slice_num, + fc->fcp->max_slice_bytes - FEC_HEADER_SIZE); return 1; } @@ -335,6 +427,10 @@ int vss_add_fec_client(struct fec_client_parms *fcp, struct fec_client **result) goto err; fc->first_stream_chunk = -1; /* stream not yet started */ fc->src_data = para_malloc(fc->fcp->slices_per_group * sizeof(char *)); + fc->enc_buf = para_calloc(fc->fcp->max_slice_bytes); + fc->num_extra_slices = 0; + fc->extra_src_buf = para_calloc(fc->fcp->max_slice_bytes); + fc->next_header_time.tv_sec = 0; para_list_add(&fc->node, &fec_client_list); *result = fc; return 1; @@ -374,7 +470,7 @@ static int next_slice_is_due(struct fec_client *fc, struct timeval *diff) if (fc->first_stream_chunk < 0) return 1; - tv_scale(fc->slice.num, &fc->group.slice_duration, &tmp); + tv_scale(fc->current_slice_num, &fc->group.slice_duration, &tmp); tv_add(&tmp, &fc->group.start, &next); ret = tv_diff(&next, now, diff); return ret < 0? 1 : 0; @@ -388,6 +484,8 @@ static void compute_slice_timeout(struct timeval *timeout) list_for_each_entry(fc, &fec_client_list, node) { struct timeval diff; + if (fc->error < 0) + continue; if (next_slice_is_due(fc, &diff)) { timeout->tv_sec = 0; timeout->tv_usec = 0; @@ -399,6 +497,26 @@ static void compute_slice_timeout(struct timeval *timeout) } } +static void set_eof_barrier(struct vss_task *vsst) +{ + struct fec_client *fc; + struct timeval timeout = {1, 0}, *chunk_tv = vss_chunk_time(); + + if (!chunk_tv) + goto out; + list_for_each_entry(fc, &fec_client_list, node) { + struct timeval group_duration; + + if (fc->error < 0) + continue; + tv_scale(fc->group.num_chunks, chunk_tv, &group_duration); + if (tv_diff(&timeout, &group_duration, NULL) < 0) + timeout = group_duration; + } +out: + tv_add(now, &timeout, &vsst->eof_barrier); +} + /** * Check if vss status flag \a P (playing) is set. * @@ -510,25 +628,20 @@ static struct timeval *vss_compute_timeout(struct vss_task *vsst) static void vss_eof(struct vss_task *vsst) { - mmd->stream_start = *now; if (!vsst->map) return; if (mmd->new_vss_status_flags & VSS_NOMORE) mmd->new_vss_status_flags = VSS_NEXT; - tv_add(&mmd->afd.afhi.eof_tv, now, &vsst->eof_barrier); + set_eof_barrier(vsst); para_munmap(vsst->map, mmd->size); vsst->map = NULL; mmd->chunks_sent = 0; - mmd->offset = 0; + //mmd->offset = 0; mmd->afd.afhi.seconds_total = 0; mmd->afd.afhi.chunk_tv.tv_sec = 0; mmd->afd.afhi.chunk_tv.tv_usec = 0; free(mmd->afd.afhi.chunk_table); mmd->afd.afhi.chunk_table = NULL; - free(mmd->afd.afhi.info_string); - mmd->afd.afhi.info_string = make_message("%s:\n%s:\n%s:\n", status_item_list[SI_AUDIO_FILE_INFO], - status_item_list[SI_TAGINFO1], status_item_list[SI_TAGINFO2]); - make_empty_status_items(mmd->afd.verbose_ls_output); mmd->mtime = 0; mmd->size = 0; mmd->events++; @@ -564,13 +677,15 @@ static int need_to_request_new_audio_file(struct vss_task *vsst) return 1; } - +static void set_mmd_offset(void) +{ + struct timeval offset; + tv_scale(mmd->current_chunk, &mmd->afd.afhi.chunk_tv, &offset); + mmd->offset = tv2ms(&offset); +} /** - * Compute the timeout for para_server's main select-loop. - * - * This function gets called from para_server to determine the timeout value - * for its main select loop. + * Compute the timeout for the main select-loop of the scheduler. * * \param s Pointer to the server scheduler. * \param t Pointer to the vss task structure. @@ -594,21 +709,26 @@ static void vss_pre_select(struct sched *s, struct task *t) for (i = 0; senders[i].name; i++) if (senders[i].shutdown_clients) senders[i].shutdown_clients(); - list_for_each_entry_safe(fc, tmp, &fec_client_list, node) + list_for_each_entry_safe(fc, tmp, &fec_client_list, node) { fc->first_stream_chunk = -1; + fc->error = 0; + } + mmd->stream_start.tv_sec = 0; + mmd->stream_start.tv_usec = 0; } if (vss_next()) vss_eof(vsst); else if (vss_paused()) { if (mmd->chunks_sent) - tv_add(&mmd->afd.afhi.eof_tv, now, &vsst->eof_barrier); + set_eof_barrier(vsst); mmd->chunks_sent = 0; } else if (vss_repos()) { tv_add(now, &vsst->announce_tv, &vsst->data_send_barrier); - tv_add(&mmd->afd.afhi.eof_tv, now, &vsst->eof_barrier); + set_eof_barrier(vsst); mmd->chunks_sent = 0; mmd->current_chunk = mmd->repos_request; mmd->new_vss_status_flags &= ~VSS_REPOS; + set_mmd_offset(); } if (need_to_request_new_audio_file(vsst)) { PARA_DEBUG_LOG("ready and playing, but no audio file\n"); @@ -652,9 +772,9 @@ static int recv_afs_msg(int afs_socket, int *fd, uint32_t *code, uint32_t *data) for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) - continue; + continue; if ((cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int) != 1) - continue; + continue; *fd = *(int *)CMSG_DATA(cmsg); } return 1; @@ -667,7 +787,6 @@ static void recv_afs_result(struct vss_task *vsst) struct stat statbuf; vsst->afsss = AFS_SOCKET_READY; - mmd->afd.afhi.chunk_table = NULL; ret = recv_afs_msg(vsst->afs_socket, &passed_fd, &afs_code, &afs_data); if (ret < 0) goto err; @@ -724,7 +843,7 @@ err: */ static void vss_send(struct vss_task *vsst) { - int i; + int i, fec_active = 0; struct timeval due; struct fec_client *fc, *tmp_fc; @@ -735,22 +854,39 @@ static void vss_send(struct vss_task *vsst) if (chk_barrier("data send", &vsst->data_send_barrier, &due, 1) < 0) return; + list_for_each_entry_safe(fc, tmp_fc, &fec_client_list, node) { + if (fc->error < 0) + continue; + if (!next_slice_is_due(fc, NULL)) { + fec_active = 1; + continue; + } + if (compute_next_fec_slice(fc, vsst) <= 0) + continue; + PARA_DEBUG_LOG("sending %d:%d (%u bytes)\n", fc->group.num, + fc->current_slice_num, fc->fcp->max_slice_bytes); + fc->fcp->send((char *)fc->enc_buf, + fc->fcp->max_slice_bytes, + fc->fcp->private_data); + fc->current_slice_num++; + fec_active = 1; + } if (mmd->current_chunk >= mmd->afd.afhi.chunks_total) { /* eof */ - mmd->new_vss_status_flags |= VSS_NEXT; + if (!fec_active) + mmd->new_vss_status_flags |= VSS_NEXT; return; } - if (!mmd->chunks_sent) { - struct timeval tmp; - mmd->stream_start = *now; - tv_scale(mmd->current_chunk, &mmd->afd.afhi.chunk_tv, &tmp); - mmd->offset = tv2ms(&tmp); - mmd->events++; - } compute_chunk_time(mmd->chunks_sent, &mmd->afd.afhi.chunk_tv, &mmd->stream_start, &due); if (tv_diff(&due, now, NULL) <= 0) { const char *buf; size_t len; + + if (!mmd->chunks_sent) { + mmd->stream_start = *now; + mmd->events++; + set_mmd_offset(); + } /* * We call the send function also in case of empty chunks as * they might have still some data queued which can be sent in @@ -764,22 +900,9 @@ static void vss_send(struct vss_task *vsst) senders[i].send(mmd->current_chunk, mmd->chunks_sent, buf, len, vsst->header_buf, vsst->header_len); } + mmd->chunks_sent++; + mmd->current_chunk++; } - list_for_each_entry_safe(fc, tmp_fc, &fec_client_list, node) { - if (!next_slice_is_due(fc, NULL)) - continue; - if (!compute_next_fec_slice(fc, vsst)) - continue; - PARA_DEBUG_LOG("sending %d:%d (%u bytes)\n", fc->group.num, - fc->slice.num, fc->slice.bytes); - fc->fcp->send((char *)fc->enc_buf, - fc->slice.bytes + FEC_HEADER_SIZE, - fc->fcp->private_data); - fc->slice.num++; - } - mmd->new_vss_status_flags |= VSS_PLAYING; - mmd->chunks_sent++; - mmd->current_chunk++; } static void vss_post_select(struct sched *s, struct task *t) @@ -787,6 +910,7 @@ static void vss_post_select(struct sched *s, struct task *t) int ret, i; struct vss_task *vsst = container_of(t, struct vss_task, task); + if (mmd->sender_cmd_data.cmd_num >= 0) { int num = mmd->sender_cmd_data.cmd_num, sender_num = mmd->sender_cmd_data.sender_num; @@ -801,7 +925,10 @@ static void vss_post_select(struct sched *s, struct task *t) } else if (FD_ISSET(vsst->afs_socket, &s->wfds)) { PARA_NOTICE_LOG("requesting new fd from afs\n"); ret = send_buffer(vsst->afs_socket, "new"); - vsst->afsss = AFS_SOCKET_AFD_PENDING; + if (ret < 0) + PARA_CRIT_LOG("%s\n", para_strerror(-ret)); + else + vsst->afsss = AFS_SOCKET_AFD_PENDING; } for (i = 0; senders[i].name; i++) { if (!senders[i].post_select) @@ -831,7 +958,7 @@ void init_vss_task(int afs_socket) conf.announce_time_arg : 300, autoplay_delay = conf.autoplay_delay_arg > 0? conf.autoplay_delay_arg : 0; - + vsst->header_interval.tv_sec = 5; /* should this be configurable? */ vsst->afs_socket = afs_socket; vsst->task.pre_select = vss_pre_select; vsst->task.post_select = vss_post_select; @@ -845,7 +972,6 @@ void init_vss_task(int afs_socket) free(hn); free(home); mmd->sender_cmd_data.cmd_num = -1; - make_empty_status_items(mmd->afd.verbose_ls_output); if (conf.autoplay_given) { struct timeval tmp; mmd->vss_status_flags |= VSS_PLAYING;