X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=vss.c;h=ba6f7c4c655134d11d79e6411ab92d63b4efd160;hp=8c16c9582f376750ec17218354790aefda4cb12b;hb=e4db7671a91a7552c642acc979f0eb278f8d467f;hpb=b15735ae7de59e0d9db43f23388d8ac47a6d2def diff --git a/vss.c b/vss.c index 8c16c958..ba6f7c4c 100644 --- a/vss.c +++ b/vss.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1997-2010 Andre Noll + * Copyright (C) 1997-2011 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -86,7 +86,7 @@ struct vss_task { /** Used by the scheduler. */ struct task task; /** Pointer to the header of the mapped audio file. */ - const char *header_buf; + char *header_buf; /** Length of the audio file header. */ size_t header_len; /** Time between audio file headers are sent. */ @@ -167,6 +167,8 @@ struct fec_client { struct timeval next_header_time; /** Used for the last source pointer of an audio file. */ unsigned char *extra_src_buf; + /** Needed for the last slice of the audio file header. */ + unsigned char *extra_header_buf; /** Extra slices needed to store largest chunk + header. */ int num_extra_slices; /** Contains the FEC-encoded data. */ @@ -211,10 +213,11 @@ static void write_fec_header(struct fec_client *fc, struct vss_task *vsst) write_u32(buf + 14, g->bytes); write_u8(buf + 18, fc->current_slice_num); + write_u8(buf + 19, 0); /* unused */ write_u16(buf + 20, g->slice_bytes); write_u8(buf + 22, g->first_chunk? 0 : 1); write_u8(buf + 23, vsst->header_len? 1 : 0); - memset(buf + 24, 0, 7); + memset(buf + 24, 0, 8); } static bool need_audio_header(struct fec_client *fc, struct vss_task *vsst) @@ -237,6 +240,19 @@ static bool need_audio_header(struct fec_client *fc, struct vss_task *vsst) return true; } +static bool need_data_slices(struct fec_client *fc, struct vss_task *vsst) +{ + if (fc->group.num > 0) + return true; + if (!vsst->header_buf) + return true; + if (vsst->header_len == 0) + return true; + if (fc->fcp->need_periodic_header) + return true; + return false; +} + static int num_slices(long unsigned bytes, int max_payload, int rs) { int ret; @@ -250,11 +266,15 @@ static int num_slices(long unsigned bytes, int max_payload, int rs) } /* set group start and group duration */ -static void set_group_timing(struct fec_client *fc, struct fec_group *g) +static void set_group_timing(struct fec_client *fc, struct vss_task *vsst) { + struct fec_group *g = &fc->group; struct timeval *chunk_tv = vss_chunk_time(); - tv_scale(g->num_chunks, chunk_tv, &g->duration); + if (!need_data_slices(fc, vsst)) + ms2tv(200, &g->duration); + else + 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", @@ -292,7 +312,10 @@ static int initialize_fec_client(struct fec_client *fc, struct vss_task *vsst) if (ret < 0) return ret; ds = ret; - k = hs + ds; + if (fc->fcp->need_periodic_header) + k = hs + ds; + else + k = PARA_MAX(hs, ds); if (k < fc->fcp->data_slices_per_group) k = fc->fcp->data_slices_per_group; fc->num_extra_slices = k - fc->fcp->data_slices_per_group; @@ -306,6 +329,7 @@ static int initialize_fec_client(struct fec_client *fc, struct vss_task *vsst) fc->src_data = para_realloc(fc->src_data, k * sizeof(char *)); fc->enc_buf = para_realloc(fc->enc_buf, fc->mps); fc->extra_src_buf = para_realloc(fc->extra_src_buf, fc->mps); + fc->extra_header_buf = para_realloc(fc->extra_header_buf, fc->mps); fc->state = FEC_STATE_READY_TO_RUN; fc->next_header_time.tv_sec = 0; @@ -314,6 +338,26 @@ static int initialize_fec_client(struct fec_client *fc, struct vss_task *vsst) return 1; } +static void vss_get_chunk(int chunk_num, struct vss_task *vsst, + char **buf, size_t *sz) +{ + /* + * Chunk zero is special for header streams: It is the first portion of + * the audio file which consists of the audio file header. It may be + * arbitrary large due to embedded meta data. Audio format handlers may + * replace the header by a stripped one with meta data omitted which is + * of bounded size. We always use the stripped header for streaming + * rather than the unmodified header (chunk zero). + */ + if (chunk_num == 0 && vsst->header_len > 0) { + *buf = vsst->header_buf; /* stripped header */ + *sz = vsst->header_len; + return; + } + afh_get_chunk(chunk_num, &mmd->afd.afhi, vsst->map, (const char **)buf, + sz); +} + static void compute_group_size(struct vss_task *vsst, struct fec_group *g, int max_bytes) { @@ -328,7 +372,7 @@ static void compute_group_size(struct vss_task *vsst, struct fec_group *g, * of exactly one chunk for these audio formats. */ for (i = 0;; i++) { - const char *buf; + char *buf; size_t len; int chunk_num = g->first_chunk + i; @@ -336,7 +380,7 @@ static void compute_group_size(struct vss_task *vsst, struct fec_group *g, break; if (chunk_num >= mmd->afd.afhi.chunks_total) /* eof */ break; - afh_get_chunk(chunk_num, &mmd->afd.afhi, vsst->map, &buf, &len); + vss_get_chunk(chunk_num, vsst, &buf, &len); if (g->bytes + len > max_bytes) break; /* Include this chunk */ @@ -411,6 +455,13 @@ static int compute_slice_size(struct fec_client *fc, struct vss_task *vsst) g->slice_bytes = 1; return 1; } + if (!need_data_slices(fc, vsst)) { + g->bytes = 0; + g->num_chunks = 0; + g->slice_bytes = DIV_ROUND_UP(vsst->header_len, k); + g->num_header_slices = k; + return 1; + } h = vsst->header_len; max_group_bytes = (k - num_slices(h, max_slice_bytes, n - k)) * max_slice_bytes; @@ -451,7 +502,7 @@ static int setup_next_fec_group(struct fec_client *fc, struct vss_task *vsst) { int ret, i, k, n, data_slices; size_t len; - const char *buf; + char *buf; struct fec_group *g = &fc->group; if (fc->state == FEC_STATE_NONE) { @@ -471,7 +522,7 @@ static int setup_next_fec_group(struct fec_client *fc, struct vss_task *vsst) */ tmp = g->start; tv_add(&tmp, &g->duration, &g->start); - set_group_timing(fc, g); + set_group_timing(fc, vsst); g->first_chunk += g->num_chunks; g->num++; } @@ -487,23 +538,37 @@ static int setup_next_fec_group(struct fec_client *fc, struct vss_task *vsst) assert(g->num_header_slices + data_slices <= k); fc->current_slice_num = 0; if (g->num == 0) - set_group_timing(fc, g); - + set_group_timing(fc, vsst); /* 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 += g->slice_bytes; + if (buf + g->slice_bytes <= vsst->header_buf + vsst->header_len) { + fc->src_data[i] = (const unsigned char *)buf; + buf += g->slice_bytes; + continue; + } + /* + * Can not use vss->header_buf for this slice as it + * goes beyond the buffer. This slice will not be fully + * used. + */ + uint32_t payload_size = vsst->header_buf + + vsst->header_len - buf; + memcpy(fc->extra_header_buf, buf, payload_size); + if (payload_size < g->slice_bytes) + memset(fc->extra_header_buf + payload_size, 0, + g->slice_bytes - payload_size); + fc->src_data[i] = fc->extra_header_buf; + assert(i == g->num_header_slices - 1); } /* setup data slices */ - afh_get_chunk(g->first_chunk, &mmd->afd.afhi, vsst->map, &buf, &len); + vss_get_chunk(g->first_chunk, vsst, &buf, &len); for (; i < g->num_header_slices + data_slices; i++) { if (buf + g->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. + * slice as it goes beyond the map. */ uint32_t payload_size = vsst->map + mmd->size - buf; memcpy(fc->extra_src_buf, buf, payload_size); @@ -599,6 +664,7 @@ void vss_del_fec_client(struct fec_client *fc) free(fc->src_data); free(fc->enc_buf); free(fc->extra_src_buf); + free(fc->extra_header_buf); fec_free(fc->parms); free(fc); } @@ -779,6 +845,8 @@ static void vss_eof(struct vss_task *vsst) if (mmd->new_vss_status_flags & VSS_NOMORE) mmd->new_vss_status_flags = VSS_NEXT; set_eof_barrier(vsst); + afh_free_header(vsst->header_buf, mmd->afd.audio_format_id); + vsst->header_buf = NULL; para_munmap(vsst->map, mmd->size); vsst->map = NULL; mmd->chunks_sent = 0; @@ -957,8 +1025,8 @@ static void recv_afs_result(struct vss_task *vsst, fd_set *rfds) mmd->events++; mmd->num_played++; mmd->new_vss_status_flags &= (~VSS_NEXT); - afh_get_header(&mmd->afd.afhi, vsst->map, &vsst->header_buf, - &vsst->header_len); + afh_get_header(&mmd->afd.afhi, mmd->afd.audio_format_id, + vsst->map, mmd->size, &vsst->header_buf, &vsst->header_len); return; err: free(mmd->afd.afhi.chunk_table); @@ -1014,7 +1082,7 @@ static void vss_send(struct vss_task *vsst) 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; + char *buf; size_t len; if (!mmd->chunks_sent) { @@ -1027,8 +1095,7 @@ static void vss_send(struct vss_task *vsst) * they might have still some data queued which can be sent in * this case. */ - afh_get_chunk(mmd->current_chunk, &mmd->afd.afhi, vsst->map, - &buf, &len); + vss_get_chunk(mmd->current_chunk, vsst, &buf, &len); for (i = 0; senders[i].name; i++) { if (!senders[i].send) continue; @@ -1119,5 +1186,6 @@ void init_vss_task(int afs_socket) tv_add(&vsst->autoplay_barrier, &vsst->announce_tv, &vsst->data_send_barrier); } + sprintf(vsst->task.status, "vss task"); register_task(&vsst->task); }