static void dash_packager_get_track_spec( vod_str_t* result, media_set_t* media_set, uint32_t sequence_index, uint32_t track_index, uint32_t media_type) { u_char* p = result->data; if (media_set->has_multi_sequences && sequence_index != INVALID_SEQUENCE_INDEX) { p = vod_sprintf(p, "f%uD-", sequence_index + 1); } switch (media_type) { case MEDIA_TYPE_VIDEO: p = vod_sprintf(p, "v%uD", track_index + 1); p = vod_copy(p, "-x3", sizeof("-x3") - 1); // TODO: remove this after deployment break; case MEDIA_TYPE_AUDIO: p = vod_sprintf(p, "a%uD", track_index + 1); p = vod_copy(p, "-x3", sizeof("-x3") - 1); // TODO: remove this after deployment break; } result->len = p - result->data; }
static u_char* mss_write_manifest_chunks_live(u_char* p, segment_durations_t* segment_durations) { segment_duration_item_t* cur_item; segment_duration_item_t* last_item = segment_durations->items + segment_durations->item_count; uint32_t repeat_count; bool_t first_time = TRUE; for (cur_item = segment_durations->items; cur_item < last_item; cur_item++) { repeat_count = cur_item->repeat_count; // output the timestamp in the first chunk if (first_time) { p = vod_sprintf(p, MSS_CHUNK_TAG_LIVE_FIRST, mss_rescale_millis(segment_durations->start_time), rescale_time(cur_item->duration, segment_durations->timescale, MSS_TIMESCALE)); repeat_count--; first_time = FALSE; } // output only the duration in subsequent chunks for (; repeat_count > 0; repeat_count--) { p = vod_sprintf(p, MSS_CHUNK_TAG_LIVE, rescale_time(cur_item->duration, segment_durations->timescale, MSS_TIMESCALE)); } } return p; }
static void dash_packager_get_track_spec( vod_str_t* result, media_set_t* media_set, uint32_t clip_index, uint32_t sequence_index, uint32_t track_index, int media_type_char) { u_char* p = result->data; if (media_set->use_discontinuity) { p = vod_sprintf(p, "c%uD-", clip_index + 1); } if (media_set->has_multi_sequences && sequence_index != INVALID_SEQUENCE_INDEX) { p = vod_sprintf(p, "f%uD-", sequence_index + 1); } p = vod_sprintf(p, "%c%uD", media_type_char, track_index + 1); result->len = p - result->data; }
static u_char* dash_packager_write_segment_list( u_char* p, write_period_context_t* context, uint32_t start_number, u_char* clip_spec, media_sequence_t* cur_sequence, media_track_t* cur_track, uint32_t segment_count) { dash_manifest_config_t* conf = context->conf; media_set_t* media_set = context->media_set; vod_str_t track_spec; vod_str_t cur_base_url; u_char track_spec_buffer[MAX_TRACK_SPEC_LENGTH]; uint32_t sequence_index = cur_sequence->index; uint32_t i; track_spec.data = track_spec_buffer; // build the base url dash_packager_get_segment_list_base_url(context, cur_track, &cur_base_url, &sequence_index); // get the track specification dash_packager_get_track_spec( &track_spec, media_set, sequence_index, cur_track->index, cur_track->media_info.media_type); // write the header p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_LIST_HEADER, media_set->segmenter_conf->segment_duration, context->clip_index == 0 ? media_set->initial_segment_clip_relative_index + 1 : 1, &cur_base_url, &conf->init_file_name_prefix, clip_spec, &track_spec, &dash_codecs[cur_track->media_info.codec_id].init_file_ext); // write the urls for (i = 0; i < segment_count; i++) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_URL, &cur_base_url, &conf->fragment_file_name_prefix, start_number + i + 1, &track_spec, &dash_codecs[cur_track->media_info.codec_id].frag_file_ext); } p = vod_copy(p, VOD_DASH_MANIFEST_SEGMENT_LIST_FOOTER, sizeof(VOD_DASH_MANIFEST_SEGMENT_LIST_FOOTER) - 1); return p; }
u_char* manifest_utils_append_tracks_spec( u_char* p, media_track_t** tracks, uint32_t track_count, bool_t write_sequence_index) { media_sequence_t* cur_sequence; media_track_t** last_track_ptr = tracks + track_count; media_track_t** cur_track_ptr; media_track_t* cur_track; uint32_t last_sequence_index; u_char media_type_letter[] = { 'v', 'a' }; // must match MEDIA_TYPE_xxx in order last_sequence_index = INVALID_SEQUENCE_INDEX; for (cur_track_ptr = tracks; cur_track_ptr < last_track_ptr; cur_track_ptr++) { cur_track = *cur_track_ptr; if (cur_track == NULL) { continue; } if (write_sequence_index) { cur_sequence = cur_track->file_info.source->sequence; if (cur_sequence->index != last_sequence_index) { last_sequence_index = cur_sequence->index; if (cur_sequence->id.len != 0 && cur_sequence->id.len < VOD_INT32_LEN) { p = vod_sprintf(p, "-s%V", &cur_sequence->id); } else { p = vod_sprintf(p, "-f%uD", last_sequence_index + 1); } } } if (cur_track->media_info.media_type <= MEDIA_TYPE_AUDIO) { *p++ = '-'; *p++ = media_type_letter[cur_track->media_info.media_type]; p = vod_sprintf(p, "%uD", cur_track->index + 1); } } return p; }
static u_char* dash_packager_write_segment_template( u_char* p, dash_manifest_config_t* conf, segmenter_conf_t* segmenter_conf, vod_str_t* base_url, segment_durations_t* segment_durations) { segment_duration_item_t* cur_item; segment_duration_item_t* last_item = segment_durations->items + segment_durations->item_count; uint32_t duration; if (!conf->segment_timeline) { return vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FIXED, base_url, &conf->fragment_file_name_prefix, base_url, &conf->init_file_name_prefix, segmenter_conf->segment_duration); } p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_HEADER, base_url, &conf->fragment_file_name_prefix, base_url, &conf->init_file_name_prefix); for (cur_item = segment_durations->items; cur_item < last_item; cur_item++) { duration = (uint32_t)rescale_time(cur_item->duration, segment_durations->timescale, 1000); if (cur_item->repeat_count == 1) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT, duration); } else if (cur_item->repeat_count > 1) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_REPEAT, duration, cur_item->repeat_count - 1); } } p = vod_copy(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FOOTER, sizeof(VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FOOTER) - 1); return p; }
static u_char* dash_packager_write_segment_timeline( u_char* p, dash_manifest_config_t* conf, segment_durations_t* segment_durations, segment_duration_item_t** cur_item_ptr, vod_str_t* base_url) { segment_duration_item_t* cur_item; segment_duration_item_t* last_item = segment_durations->items + segment_durations->item_count; uint32_t duration; bool_t first_time = TRUE; p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_HEADER, base_url, &conf->fragment_file_name_prefix, base_url, &conf->init_file_name_prefix); for (cur_item = *cur_item_ptr; cur_item < last_item; cur_item++) { // stop on discontinuity, will get called again for the next period if (cur_item->discontinuity && !first_time) { break; } first_time = FALSE; duration = (uint32_t)rescale_time(cur_item->duration, segment_durations->timescale, 1000); if (cur_item->repeat_count == 1) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT, duration); } else if (cur_item->repeat_count > 1) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_REPEAT, duration, cur_item->repeat_count - 1); } } *cur_item_ptr = cur_item; p = vod_copy(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FOOTER, sizeof(VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FOOTER) - 1); return p; }
static u_char* m3u8_builder_format_double(u_char* p, uint32_t n, uint32_t scale) { int cur_digit; int int_n = n / scale; int fraction = n % scale; p = vod_sprintf(p, "%d", int_n); if (scale == 1) { return p; } *p++ = '.'; for (;;) { scale /= 10; if (scale == 0) { break; } cur_digit = fraction / scale; *p++ = cur_digit + '0'; fraction -= cur_digit * scale; } return p; }
static vod_status_t codec_config_get_avc_codec_name(request_context_t* request_context, media_info_t* media_info) { avcc_config_t* config; u_char* p; if (media_info->extra_data_size < sizeof(avcc_config_t)) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "codec_config_get_avc_codec_name: extra data too small"); return VOD_BAD_DATA; } config = (avcc_config_t*)media_info->extra_data; p = vod_sprintf(media_info->codec_name.data, "%*s.%02uxD%02uxD%02uxD", (size_t)sizeof(uint32_t), &media_info->format, (uint32_t)config->profile, (uint32_t)config->compatibility, (uint32_t)config->level); media_info->codec_name.len = p - media_info->codec_name.data; return VOD_OK; }
static u_char* dash_packager_write_segment_template( u_char* p, dash_manifest_config_t* conf, uint32_t start_number, uint32_t clip_relative_index, u_char* clip_spec, media_set_t* media_set, media_track_t* reference_track, vod_str_t* base_url) { u_char index_shift_str[MAX_INDEX_SHIFT_LENGTH]; index_shift_str[0] = '\0'; if (media_set->use_discontinuity) { if (start_number > clip_relative_index) { vod_sprintf(index_shift_str, "i%uD-%Z", start_number - clip_relative_index); start_number = clip_relative_index; } } else { start_number = 0; } // Note: SegmentTemplate is currently printed in the adaptation set level, so it is not possible // to mix mp4 and webm representations for the same media type p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FIXED, base_url, &conf->fragment_file_name_prefix, index_shift_str, &dash_codecs[reference_track->media_info.codec_id].frag_file_ext, base_url, &conf->init_file_name_prefix, clip_spec, &dash_codecs[reference_track->media_info.codec_id].init_file_ext, media_set->segmenter_conf->segment_duration, start_number + 1); return p; }
u_char* mp4_encrypt_write_guid(u_char* p, u_char* guid) { p = vod_sprintf(p, "%02xd%02xd%02xd%02xd-%02xd%02xd-%02xd%02xd-%02xd%02xd-%02xd%02xd%02xd%02xd%02xd%02xd", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]); return p; }
static void dash_packager_write_frame_rate( uint32_t duration, uint32_t timescale, vod_str_t* result) { uint32_t gcd = dash_packager_find_gcd(duration, timescale); u_char* p = result->data; duration /= gcd; timescale /= gcd; if (duration == 1) { result->len = vod_sprintf(p, "%uD", timescale) - p; } else { result->len = vod_sprintf(p, "%uD/%uD", timescale, duration) - p; } }
static void m3u8_builder_append_iframe_string(void* context, uint32_t segment_index, uint32_t frame_duration, uint32_t frame_start, uint32_t frame_size) { write_segment_context_t* ctx = (write_segment_context_t*)context; ctx->p = m3u8_builder_append_extinf_tag(ctx->p, frame_duration, 1000); ctx->p = vod_sprintf(ctx->p, byte_range_tag_format, frame_size, frame_start); ctx->p = m3u8_builder_append_segment_name( ctx->p, ctx->base_url, ctx->segment_file_name_prefix, segment_index, &ctx->tracks_spec); }
static vod_status_t codec_config_get_hevc_codec_name(request_context_t* request_context, media_info_t* media_info) { vod_status_t rc; hevc_config_t cfg; u_char* p; uint8_t c; char profile_space[2] = { 0, 0 }; int shift; rc = codec_config_hevc_config_parse(request_context, media_info->extra_data, media_info->extra_data_size, &cfg, NULL); if (rc != VOD_OK) { return rc; } if (cfg.profile_space > 0) { profile_space[0] = 'A' + (cfg.profile_space - 1); } c = cfg.progressive_source_flag << 7; c |= cfg.interlaced_source_flag << 6; c |= cfg.non_packed_constraint_flag << 5; c |= cfg.frame_only_constraint_flag << 4; c |= (cfg.constraint_indicator_flags >> 40); p = vod_sprintf(media_info->codec_name.data, "%*s.%s%D.%xD.%c%D.%02xD", (size_t)sizeof(uint32_t), &media_info->format, profile_space, (uint32_t)cfg.profile_idc, codec_config_flip_bits_32(cfg.general_profile_compatibility_flags), (int)(cfg.tier_flag ? 'H' : 'L'), (uint32_t)cfg.level_idc, (uint32_t)c); for (shift = 32; shift >= 0; shift -= 8) { if ((cfg.constraint_indicator_flags & (((uint64_t)1 << (shift + 8)) - 1)) == 0) { break; } p = vod_sprintf(p, ".%02xD", (uint32_t)((cfg.constraint_indicator_flags >> shift) & 0xFF)); } *p = '\0'; media_info->codec_name.len = p - media_info->codec_name.data; return VOD_OK; }
u_char* manifest_utils_append_tracks_spec(u_char* p, media_track_t** tracks, bool_t write_sequence_index) { media_sequence_t* video_sequence = NULL; media_sequence_t* cur_sequence; if (tracks[MEDIA_TYPE_VIDEO] != NULL) { if (write_sequence_index) { video_sequence = tracks[MEDIA_TYPE_VIDEO]->file_info.source->sequence; p = vod_sprintf(p, "-f%uD", video_sequence->index + 1); } p = vod_sprintf(p, "-v%uD", tracks[MEDIA_TYPE_VIDEO]->index + 1); } if (tracks[MEDIA_TYPE_AUDIO] != NULL) { if (write_sequence_index) { cur_sequence = tracks[MEDIA_TYPE_AUDIO]->file_info.source->sequence; if (video_sequence == NULL || cur_sequence->index != video_sequence->index) { p = vod_sprintf(p, "-f%uD", cur_sequence->index + 1); } } p = vod_sprintf(p, "-a%uD", tracks[MEDIA_TYPE_AUDIO]->index + 1); } if (tracks[MEDIA_TYPE_SUBTITLE] != NULL && write_sequence_index) { cur_sequence = tracks[MEDIA_TYPE_SUBTITLE]->file_info.source->sequence; p = vod_sprintf(p, "-f%uD", cur_sequence->index + 1); } return p; }
static u_char* m3u8_builder_append_segment_name( u_char* p, vod_str_t* base_url, vod_str_t* segment_file_name_prefix, uint32_t segment_index, vod_str_t* tracks_spec) { p = vod_copy(p, base_url->data, base_url->len); p = vod_copy(p, segment_file_name_prefix->data, segment_file_name_prefix->len); *p++ = '-'; p = vod_sprintf(p, "%uD", segment_index + 1); p = vod_copy(p, tracks_spec->data, tracks_spec->len); p = vod_copy(p, ".ts\n", sizeof(".ts\n") - 1); return p; }
static void dash_packager_get_clip_spec( u_char* result, media_set_t* media_set, uint32_t clip_index) { if (media_set->use_discontinuity && media_set->initial_clip_index != INVALID_CLIP_INDEX) { vod_sprintf(result, "c%uD-%Z", media_set->initial_clip_index + clip_index + 1); } else { result[0] = '\0'; } }
static u_char* dash_packager_write_segment_template( u_char* p, dash_manifest_config_t* conf, segmenter_conf_t* segmenter_conf, vod_str_t* base_url) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FIXED, base_url, &conf->fragment_file_name_prefix, base_url, &conf->init_file_name_prefix, segmenter_conf->segment_duration); return p; }
static u_char* manifest_utils_write_bitmask(u_char* p, uint32_t bitmask, u_char letter) { uint32_t i; for (i = 0; i < 32; i++) { if ((bitmask & (1 << i)) == 0) { continue; } *p++ = '-'; *p++ = letter; p = vod_sprintf(p, "%uD", i + 1); } return p; }
static u_char* mss_write_manifest_chunks(u_char* p, segment_durations_t* segment_durations) { segment_duration_item_t* cur_item; segment_duration_item_t* last_item = segment_durations->items + segment_durations->item_count; uint32_t last_segment_index; uint32_t segment_index; for (cur_item = segment_durations->items; cur_item < last_item; cur_item++) { segment_index = cur_item->segment_index; last_segment_index = segment_index + cur_item->repeat_count; for (; segment_index < last_segment_index; segment_index++) { p = vod_sprintf(p, MSS_CHUNK_TAG, segment_index, rescale_time(cur_item->duration, segment_durations->timescale, MSS_TIMESCALE)); } } return p; }
static u_char* rate_filter_append_desc(u_char* p, media_clip_t* clip) { media_clip_rate_filter_t* filter = vod_container_of(clip, media_clip_rate_filter_t, base); uint32_t denom; uint32_t nom; // normalize the fraction to 100 denom nom = filter->rate.nom; denom = filter->rate.denom; while (denom < 100) { nom *= 10; denom *= 10; } return vod_sprintf( p, RATE_FILTER_DESC_PATTERN, clip->sources[0]->id, nom / 100, nom % 100, clip->id); }
static vod_status_t hls_muxer_init_id3_stream( hls_muxer_state_t* state, hls_muxer_conf_t* conf, mpegts_encoder_init_streams_state_t* init_streams_state) { hls_muxer_stream_state_t* cur_stream; hls_muxer_stream_state_t* reference_stream; id3_context_t* context; vod_status_t rc; cur_stream = state->last_stream; // init the mpeg ts encoder rc = mpegts_encoder_init( &cur_stream->mpegts_encoder_state, init_streams_state, NULL, &state->queue, conf->interleave_frames, conf->align_frames); if (rc != VOD_OK) { return rc; } if (!conf->output_id3_timestamps) { return VOD_OK; } // get the stream that has the first frame rc = hls_muxer_choose_stream(state, &reference_stream); if (rc != VOD_OK) { if (rc == VOD_NOT_FOUND) { return VOD_OK; } return rc; } // allocate the context context = vod_alloc(state->request_context->pool, sizeof(*context)); if (context == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, state->request_context->log, 0, "hls_muxer_init_id3_stream: vod_alloc failed"); return VOD_ALLOC_FAILED; } // init the memory frames source rc = frames_source_memory_init(state->request_context, &cur_stream->cur_frame_part.frames_source_context); if (rc != VOD_OK) { return rc; } cur_stream->cur_frame_part.frames_source = &frames_source_memory; // base initialization cur_stream->media_type = MEDIA_TYPE_NONE; cur_stream->segment_limit = ULLONG_MAX; cur_stream->buffer_state = NULL; // init the id3 encoder id3_encoder_init(&context->encoder, &mpegts_encoder, &cur_stream->mpegts_encoder_state); cur_stream->top_filter = &id3_encoder; cur_stream->top_filter_context = &context->encoder; // copy the time stamps cur_stream->first_frame_time_offset = reference_stream->first_frame_time_offset; cur_stream->next_frame_time_offset = reference_stream->next_frame_time_offset; cur_stream->clip_from_frame_offset = reference_stream->clip_from_frame_offset; // init the frame part cur_stream->cur_frame = &context->frame; cur_stream->first_frame_part = &cur_stream->cur_frame_part; cur_stream->cur_frame_part.next = NULL; cur_stream->cur_frame_part.first_frame = &context->frame; cur_stream->cur_frame_part.last_frame = &context->frame + 1; cur_stream->source = NULL; // init the frame context->frame.size = vod_sprintf(context->data, ID3_TEXT_JSON_FORMAT, hls_rescale_to_millis(cur_stream->first_frame_time_offset)) - context->data; context->frame.duration = 0; context->frame.key_frame = 1; context->frame.pts_delay = 0; context->frame.offset = (uintptr_t)&context->data; state->last_stream++; return VOD_OK; }
vod_status_t hds_packager_build_manifest( request_context_t* request_context, hds_manifest_config_t* conf, vod_str_t* base_url, vod_str_t* manifest_id, media_set_t* media_set, bool_t drm_enabled, vod_str_t* result) { hds_segment_durations_t* segment_durations; adaptation_sets_t adaptation_sets; adaptation_set_t* adaptation_set; segmenter_conf_t* segmenter_conf = media_set->segmenter_conf; media_sequence_t* cur_sequence; media_track_t** tracks; media_track_t** cur_track_ptr; media_track_t* tracks_array[MEDIA_TYPE_COUNT]; media_track_t* track; vod_str_t* drm_metadata; uint32_t initial_muxed_tracks; uint32_t muxed_tracks; uint32_t media_count; uint32_t bitrate; uint32_t index; uint32_t abst_atom_size; uint32_t max_abst_atom_size = 0; size_t result_size; vod_status_t rc; u_char* temp_buffer; u_char* p; // get the adaptations sets rc = manifest_utils_get_adaptation_sets( request_context, media_set, ADAPTATION_SETS_FLAG_FORCE_MUXED | ADAPTATION_SETS_FLAG_SINGLE_LANG_TRACK | ADAPTATION_SETS_FLAG_AVOID_AUDIO_ONLY, &adaptation_sets); if (rc != VOD_OK) { return rc; } // allocate the segment durations media_count = adaptation_sets.first->count + adaptation_sets.total_count - 1; segment_durations = vod_alloc(request_context->pool, sizeof(segment_durations[0]) * media_count); if (segment_durations == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "hds_packager_build_manifest: vod_alloc failed (1)"); return VOD_ALLOC_FAILED; } // calculate the result size result_size = sizeof(HDS_MANIFEST_HEADER) - 1 + manifest_id->len + sizeof(HDS_MANIFEST_HEADER_BASE_URL) - 1 + base_url->len + sizeof(HDS_MANIFEST_HEADER_LANG) - 1 + LANG_ISO639_2_LEN + sizeof(HDS_MANIFEST_FOOTER); switch (media_set->type) { case MEDIA_SET_VOD: result_size += sizeof(HDS_MANIFEST_HEADER_VOD) - 1 + 2 * VOD_INT32_LEN + (sizeof(HDS_BOOTSTRAP_VOD_HEADER) - 1 + VOD_INT32_LEN + sizeof(HDS_BOOTSTRAP_VOD_FOOTER) - 1) * media_count; break; case MEDIA_SET_LIVE: result_size += sizeof(HDS_MANIFEST_HEADER_LIVE) - 1 + (sizeof(HDS_BOOTSTRAP_LIVE_PREFIX) - 1 + VOD_INT32_LEN + conf->bootstrap_file_name_prefix.len + MANIFEST_UTILS_TRACKS_SPEC_MAX_SIZE + sizeof(HDS_BOOTSTRAP_LIVE_SUFFIX) - 1) * media_count; break; } if (drm_enabled) { result_size += (sizeof(HDS_DRM_ADDITIONAL_HEADER_PREFIX) - 1 + VOD_INT32_LEN + sizeof(HDS_DRM_ADDITIONAL_HEADER_SUFFIX) - 1) * media_count; } result_size += (vod_max(sizeof(HDS_MEDIA_HEADER_PREFIX_VIDEO) - 1 + 3 * VOD_INT32_LEN, sizeof(HDS_MEDIA_HEADER_PREFIX_AUDIO_LANG) - 1 + VOD_INT32_LEN + LANG_ISO639_2_LEN) + conf->fragment_file_name_prefix.len + MANIFEST_UTILS_TRACKS_SPEC_MAX_SIZE + 1 + // 1 = - sizeof(HDS_MEDIA_HEADER_SUFFIX_DRM) - 1 + 2 * VOD_INT32_LEN + vod_base64_encoded_length(amf0_max_total_size) + sizeof(HDS_MEDIA_FOOTER) - 1) * media_count; initial_muxed_tracks = adaptation_sets.first->type == ADAPTATION_TYPE_MUXED ? MEDIA_TYPE_COUNT : 1; muxed_tracks = initial_muxed_tracks; index = 0; for (adaptation_set = adaptation_sets.first; adaptation_set < adaptation_sets.last; adaptation_set++) { if (adaptation_set->type == ADAPTATION_TYPE_MUXED) { if (adaptation_set->first[MEDIA_TYPE_AUDIO] != NULL) { result_size += adaptation_set->first[MEDIA_TYPE_AUDIO]->media_info.label.len; } } else { result_size += adaptation_set->first[0]->media_info.label.len; } for (cur_track_ptr = adaptation_set->first; cur_track_ptr < adaptation_set->last; cur_track_ptr += muxed_tracks) { if (cur_track_ptr[0] != NULL) { cur_sequence = cur_track_ptr[0]->file_info.source->sequence; } else { cur_sequence = cur_track_ptr[1]->file_info.source->sequence; } switch (media_set->type) { case MEDIA_SET_VOD: rc = segmenter_conf->get_segment_durations( request_context, segmenter_conf, media_set, cur_sequence, // XXXXX change to work with tracks instead of sequence MEDIA_TYPE_NONE, &segment_durations[index].durations); if (rc != VOD_OK) { return rc; } hds_scale_segment_durations(&segment_durations[index]); abst_atom_size = hds_get_abst_atom_size(media_set, &segment_durations[index]); if (abst_atom_size > max_abst_atom_size) { max_abst_atom_size = abst_atom_size; } result_size += vod_base64_encoded_length(abst_atom_size); index++; break; } if (drm_enabled) { drm_metadata = &((drm_info_t*)cur_sequence->drm_info)->pssh_array.first->data; result_size += drm_metadata->len; } } muxed_tracks = 1; } // allocate the buffers result->data = vod_alloc(request_context->pool, result_size); if (result->data == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "hds_packager_build_manifest: vod_alloc failed (2)"); return VOD_ALLOC_FAILED; } temp_buffer = vod_alloc(request_context->pool, vod_max(amf0_max_total_size, max_abst_atom_size)); if (temp_buffer == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "hds_packager_build_manifest: vod_alloc failed (3)"); return VOD_ALLOC_FAILED; } // print the manifest header p = vod_sprintf(result->data, HDS_MANIFEST_HEADER, manifest_id); if (base_url->len != 0) { p = vod_sprintf(p, HDS_MANIFEST_HEADER_BASE_URL, base_url); } switch (media_set->type) { case MEDIA_SET_VOD: p = vod_sprintf(p, HDS_MANIFEST_HEADER_VOD, (uint32_t)(media_set->timing.total_duration / 1000), (uint32_t)(media_set->timing.total_duration % 1000)); break; case MEDIA_SET_LIVE: p = vod_copy(p, HDS_MANIFEST_HEADER_LIVE, sizeof(HDS_MANIFEST_HEADER_LIVE) - 1); break; } if (adaptation_sets.total_count > 1) { if (adaptation_sets.first->type == ADAPTATION_TYPE_MUXED) { track = adaptation_sets.first->first[MEDIA_TYPE_AUDIO]; } else { track = adaptation_sets.first->first[0]; } p = vod_sprintf(p, HDS_MANIFEST_HEADER_LANG, &track->media_info.label, lang_get_iso639_2t_name(track->media_info.language)); } // bootstrap tags muxed_tracks = initial_muxed_tracks; tracks_array[MEDIA_TYPE_SUBTITLE] = NULL; index = 0; for (adaptation_set = adaptation_sets.first; adaptation_set < adaptation_sets.last; adaptation_set++) { for (cur_track_ptr = adaptation_set->first; cur_track_ptr < adaptation_set->last; cur_track_ptr += muxed_tracks) { switch (media_set->type) { case MEDIA_SET_VOD: p = vod_sprintf(p, HDS_BOOTSTRAP_VOD_HEADER, index); p = hds_write_base64_abst_atom(p, temp_buffer, media_set, &segment_durations[index]); p = vod_copy(p, HDS_BOOTSTRAP_VOD_FOOTER, sizeof(HDS_BOOTSTRAP_VOD_FOOTER) - 1); break; case MEDIA_SET_LIVE: // get the tracks if (muxed_tracks == 1) { if (cur_track_ptr[0]->media_info.media_type == MEDIA_TYPE_VIDEO) { tracks_array[MEDIA_TYPE_VIDEO] = cur_track_ptr[0]; tracks_array[MEDIA_TYPE_AUDIO] = NULL; } else { tracks_array[MEDIA_TYPE_VIDEO] = NULL; tracks_array[MEDIA_TYPE_AUDIO] = cur_track_ptr[0]; } tracks = tracks_array; } else { tracks = cur_track_ptr; } p = vod_sprintf(p, HDS_BOOTSTRAP_LIVE_PREFIX, index); p = vod_copy(p, conf->bootstrap_file_name_prefix.data, conf->bootstrap_file_name_prefix.len); p = manifest_utils_append_tracks_spec(p, tracks, MEDIA_TYPE_COUNT, media_set->has_multi_sequences); p = vod_copy(p, HDS_BOOTSTRAP_LIVE_SUFFIX, sizeof(HDS_BOOTSTRAP_LIVE_SUFFIX) - 1); break; } index++; } muxed_tracks = 1; } if (drm_enabled) { muxed_tracks = initial_muxed_tracks; index = 0; for (adaptation_set = adaptation_sets.first; adaptation_set < adaptation_sets.last; adaptation_set++) { for (cur_track_ptr = adaptation_set->first; cur_track_ptr < adaptation_set->last; cur_track_ptr += muxed_tracks) { if (cur_track_ptr[0] != NULL) { cur_sequence = cur_track_ptr[0]->file_info.source->sequence; } else { cur_sequence = cur_track_ptr[1]->file_info.source->sequence; } drm_metadata = &((drm_info_t*)cur_sequence->drm_info)->pssh_array.first->data; p = vod_sprintf(p, HDS_DRM_ADDITIONAL_HEADER_PREFIX, index); p = vod_copy(p, drm_metadata->data, drm_metadata->len); p = vod_copy(p, HDS_DRM_ADDITIONAL_HEADER_SUFFIX, sizeof(HDS_DRM_ADDITIONAL_HEADER_SUFFIX) - 1); index++; } muxed_tracks = 1; } } // media tags muxed_tracks = initial_muxed_tracks; index = 0; for (adaptation_set = adaptation_sets.first; adaptation_set < adaptation_sets.last; adaptation_set++) { for (cur_track_ptr = adaptation_set->first; cur_track_ptr < adaptation_set->last; cur_track_ptr += muxed_tracks) { // get the tracks if (muxed_tracks == 1) { if (cur_track_ptr[0]->media_info.media_type == MEDIA_TYPE_VIDEO) { tracks_array[MEDIA_TYPE_VIDEO] = cur_track_ptr[0]; tracks_array[MEDIA_TYPE_AUDIO] = NULL; } else { tracks_array[MEDIA_TYPE_VIDEO] = NULL; tracks_array[MEDIA_TYPE_AUDIO] = cur_track_ptr[0]; } tracks = tracks_array; } else { tracks = cur_track_ptr; } if (tracks[MEDIA_TYPE_VIDEO] != NULL) { bitrate = tracks[MEDIA_TYPE_VIDEO]->media_info.bitrate; if (tracks[MEDIA_TYPE_AUDIO] != NULL) { bitrate += tracks[MEDIA_TYPE_AUDIO]->media_info.bitrate; } p = vod_sprintf(p, HDS_MEDIA_HEADER_PREFIX_VIDEO, bitrate / 1000, (uint32_t)tracks[MEDIA_TYPE_VIDEO]->media_info.u.video.width, (uint32_t)tracks[MEDIA_TYPE_VIDEO]->media_info.u.video.height); } else { bitrate = tracks[MEDIA_TYPE_AUDIO]->media_info.bitrate; if (adaptation_sets.total_count > 1 && adaptation_set > adaptation_sets.first) { p = vod_sprintf(p, HDS_MEDIA_HEADER_PREFIX_AUDIO_LANG, bitrate / 1000, &tracks[MEDIA_TYPE_AUDIO]->media_info.label, lang_get_iso639_2t_name(tracks[MEDIA_TYPE_AUDIO]->media_info.language)); } else { p = vod_sprintf(p, HDS_MEDIA_HEADER_PREFIX_AUDIO, bitrate / 1000); } } // url p = vod_copy(p, conf->fragment_file_name_prefix.data, conf->fragment_file_name_prefix.len); p = manifest_utils_append_tracks_spec(p, tracks, MEDIA_TYPE_COUNT, media_set->has_multi_sequences); *p++ = '-'; if (drm_enabled) { p = vod_sprintf(p, HDS_MEDIA_HEADER_SUFFIX_DRM, index, index); } else { p = vod_sprintf(p, HDS_MEDIA_HEADER_SUFFIX, index); } p = hds_amf0_write_base64_metadata(p, temp_buffer, media_set, tracks); p = vod_copy(p, HDS_MEDIA_FOOTER, sizeof(HDS_MEDIA_FOOTER) - 1); index++; } muxed_tracks = 1; } // manifest footer p = vod_copy(p, HDS_MANIFEST_FOOTER, sizeof(HDS_MANIFEST_FOOTER) - 1); result->len = p - result->data; if (result->len > result_size) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "hds_packager_build_manifest: result length %uz exceeded allocated length %uz", result->len, result_size); return VOD_UNEXPECTED; } vod_free(request_context->pool, temp_buffer); return VOD_OK; }
vod_status_t hds_packager_build_manifest( request_context_t* request_context, hds_manifest_config_t* conf, vod_str_t* manifest_id, segmenter_conf_t* segmenter_conf, media_set_t* media_set, vod_str_t* result) { media_track_t** cur_sequence_tracks; media_sequence_t* cur_sequence; media_track_t* track; segment_durations_t* segment_durations; uint32_t bitrate; uint32_t index; uint32_t abst_atom_size; uint32_t max_abst_atom_size = 0; size_t result_size; vod_status_t rc; u_char* temp_buffer; u_char* p; segment_durations = vod_alloc( request_context->pool, media_set->sequence_count * sizeof(*segment_durations)); if (segment_durations == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "hds_packager_build_manifest: vod_alloc failed (1)"); return VOD_ALLOC_FAILED; } // calculate the result size result_size = sizeof(HDS_MANIFEST_HEADER) - 1 + 2 * VOD_INT32_LEN + manifest_id->len + sizeof(HDS_MANIFEST_FOOTER); index = 0; for (cur_sequence = media_set->sequences; cur_sequence < media_set->sequences_end; cur_sequence++) { cur_sequence_tracks = cur_sequence->filtered_clips[0].longest_track; rc = segmenter_conf->get_segment_durations( request_context, segmenter_conf, media_set, cur_sequence, MEDIA_TYPE_NONE, &segment_durations[index]); if (rc != VOD_OK) { return rc; } abst_atom_size = ABST_BASE_ATOM_SIZE + (segment_durations[index].item_count + 1) * sizeof(afrt_entry_t); if (abst_atom_size > max_abst_atom_size) { max_abst_atom_size = abst_atom_size; } result_size += sizeof(HDS_BOOTSTRAP_HEADER) - 1 + VOD_INT32_LEN + vod_base64_encoded_length(abst_atom_size) + sizeof(HDS_BOOTSTRAP_FOOTER) - 1; result_size += sizeof(HDS_MEDIA_HEADER_PREFIX_VIDEO) - 1 + 3 * VOD_INT32_LEN + conf->fragment_file_name_prefix.len + sizeof("-f-v-a-") - 1 + 3 * VOD_INT32_LEN + sizeof(HDS_MEDIA_HEADER_SUFFIX) - 1 + VOD_INT32_LEN + vod_base64_encoded_length(amf0_max_total_size) + sizeof(HDS_MEDIA_FOOTER) - 1; index++; } // allocate the buffers result->data = vod_alloc(request_context->pool, result_size); if (result->data == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "hds_packager_build_manifest: vod_alloc failed (2)"); return VOD_ALLOC_FAILED; } temp_buffer = vod_alloc(request_context->pool, vod_max(amf0_max_total_size, max_abst_atom_size)); if (temp_buffer == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "hds_packager_build_manifest: vod_alloc failed (1)"); return VOD_ALLOC_FAILED; } // print the manifest header p = vod_sprintf(result->data, HDS_MANIFEST_HEADER, manifest_id, (uint32_t)(media_set->total_duration / 1000), (uint32_t)(media_set->total_duration % 1000)); // bootstrap tags index = 0; for (cur_sequence = media_set->sequences; cur_sequence < media_set->sequences_end; cur_sequence++) { cur_sequence_tracks = cur_sequence->filtered_clips[0].longest_track; p = vod_sprintf(p, HDS_BOOTSTRAP_HEADER, index); p = hds_write_base64_abst_atom(p, temp_buffer, &segment_durations[index]); p = vod_copy(p, HDS_BOOTSTRAP_FOOTER, sizeof(HDS_BOOTSTRAP_FOOTER) - 1); index++; } // media tags index = 0; for (cur_sequence = media_set->sequences; cur_sequence < media_set->sequences_end; cur_sequence++) { cur_sequence_tracks = cur_sequence->filtered_clips[0].longest_track; if (cur_sequence_tracks[MEDIA_TYPE_VIDEO] != NULL) { track = cur_sequence_tracks[MEDIA_TYPE_VIDEO]; bitrate = track->media_info.bitrate; if (cur_sequence_tracks[MEDIA_TYPE_AUDIO] != NULL) { bitrate += cur_sequence_tracks[MEDIA_TYPE_AUDIO]->media_info.bitrate; } p = vod_sprintf(p, HDS_MEDIA_HEADER_PREFIX_VIDEO, bitrate / 1000, (uint32_t)track->media_info.u.video.width, (uint32_t)track->media_info.u.video.height); } else { track = cur_sequence_tracks[MEDIA_TYPE_AUDIO]; p = vod_sprintf(p, HDS_MEDIA_HEADER_PREFIX_AUDIO, track->media_info.bitrate / 1000); } // url p = vod_copy(p, conf->fragment_file_name_prefix.data, conf->fragment_file_name_prefix.len); if (media_set->has_multi_sequences) { p = vod_sprintf(p, "-f%uD", cur_sequence->index + 1); } if (cur_sequence_tracks[MEDIA_TYPE_VIDEO] != NULL) { p = vod_sprintf(p, "-v%uD", cur_sequence_tracks[MEDIA_TYPE_VIDEO]->index + 1); } if (cur_sequence_tracks[MEDIA_TYPE_AUDIO] != NULL) { p = vod_sprintf(p, "-a%uD", cur_sequence_tracks[MEDIA_TYPE_AUDIO]->index + 1); } *p++ = '-'; p = vod_sprintf(p, HDS_MEDIA_HEADER_SUFFIX, index++); p = hds_amf0_write_base64_metadata(p, temp_buffer, cur_sequence_tracks); p = vod_copy(p, HDS_MEDIA_FOOTER, sizeof(HDS_MEDIA_FOOTER) - 1); } // manifest footer p = vod_copy(p, HDS_MANIFEST_FOOTER, sizeof(HDS_MANIFEST_FOOTER) - 1); result->len = p - result->data; if (result->len > result_size) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "hds_packager_build_manifest: result length %uz exceeded allocated length %uz", result->len, result_size); return VOD_UNEXPECTED; } vod_free(request_context->pool, temp_buffer); return VOD_OK; }
vod_status_t mss_packager_build_manifest( request_context_t* request_context, segmenter_conf_t* segmenter_conf, mpeg_metadata_t* mpeg_metadata, size_t extra_tags_size, mss_write_tags_callback_t write_extra_tags, void* extra_tags_writer_context, vod_str_t* result) { mpeg_stream_metadata_t* cur_stream; segment_durations_t segment_durations[MEDIA_TYPE_COUNT]; uint64_t duration_100ns; uint32_t media_type; uint32_t stream_index; uint32_t bitrate; vod_status_t rc; size_t result_size; u_char* p; // calculate the result size result_size = sizeof(MSS_MANIFEST_HEADER) - 1 + VOD_INT64_LEN + extra_tags_size + sizeof(MSS_MANIFEST_FOOTER); for (media_type = 0; media_type < MEDIA_TYPE_COUNT; media_type++) { if (mpeg_metadata->longest_stream[media_type] == NULL) { continue; } rc = segmenter_conf->get_segment_durations( request_context, segmenter_conf, &mpeg_metadata->longest_stream[media_type], 1, &segment_durations[media_type]); if (rc != VOD_OK) { return rc; } result_size += sizeof(MSS_STREAM_INDEX_HEADER) - 1 + 2 * sizeof(MSS_STREAM_TYPE_VIDEO) + 2 * VOD_INT32_LEN + sizeof(MSS_STREAM_INDEX_FOOTER); result_size += segment_durations[media_type].segment_count * (sizeof(MSS_CHUNK_TAG) + VOD_INT32_LEN + VOD_INT64_LEN); } for (cur_stream = mpeg_metadata->first_stream; cur_stream < mpeg_metadata->last_stream; cur_stream++) { switch (cur_stream->media_info.media_type) { case MEDIA_TYPE_VIDEO: result_size += sizeof(MSS_VIDEO_QUALITY_LEVEL_HEADER) - 1 + 4 * VOD_INT32_LEN + cur_stream->media_info.extra_data_size * 2 + sizeof(MSS_QUALITY_LEVEL_FOOTER) - 1; break; case MEDIA_TYPE_AUDIO: result_size += sizeof(MSS_AUDIO_QUALITY_LEVEL_HEADER) - 1 + 6 * VOD_INT32_LEN + cur_stream->media_info.extra_data_size * 2 + sizeof(MSS_QUALITY_LEVEL_FOOTER) - 1; break; } } // allocate the result result->data = vod_alloc(request_context->pool, result_size); if (result->data == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "mss_packager_build_manifest: vod_alloc failed"); return VOD_ALLOC_FAILED; } duration_100ns = rescale_time(mpeg_metadata->duration, mpeg_metadata->timescale, MSS_TIMESCALE); p = vod_sprintf(result->data, MSS_MANIFEST_HEADER, duration_100ns); if (mpeg_metadata->longest_stream[MEDIA_TYPE_VIDEO] != NULL) { p = vod_sprintf(p, MSS_STREAM_INDEX_HEADER, MSS_STREAM_TYPE_VIDEO, mpeg_metadata->stream_count[MEDIA_TYPE_VIDEO], segment_durations[MEDIA_TYPE_VIDEO].segment_count, MSS_STREAM_TYPE_VIDEO); stream_index = 0; for (cur_stream = mpeg_metadata->first_stream; cur_stream < mpeg_metadata->last_stream; cur_stream++) { if (cur_stream->media_info.media_type != MEDIA_TYPE_VIDEO) { continue; } bitrate = cur_stream->media_info.bitrate; bitrate = mss_encode_indexes(bitrate, cur_stream->file_info.file_index, cur_stream->track_index); p = vod_sprintf(p, MSS_VIDEO_QUALITY_LEVEL_HEADER, stream_index++, bitrate, (uint32_t)cur_stream->media_info.u.video.width, (uint32_t)cur_stream->media_info.u.video.height); p = mss_append_hex_string(p, cur_stream->media_info.extra_data, cur_stream->media_info.extra_data_size); p = vod_copy(p, MSS_QUALITY_LEVEL_FOOTER, sizeof(MSS_QUALITY_LEVEL_FOOTER) - 1); } p = mss_write_manifest_chunks(p, &segment_durations[MEDIA_TYPE_VIDEO]); p = vod_copy(p, MSS_STREAM_INDEX_FOOTER, sizeof(MSS_STREAM_INDEX_FOOTER) - 1); } if (mpeg_metadata->longest_stream[MEDIA_TYPE_AUDIO] != NULL) { p = vod_sprintf(p, MSS_STREAM_INDEX_HEADER, MSS_STREAM_TYPE_AUDIO, mpeg_metadata->stream_count[MEDIA_TYPE_AUDIO], segment_durations[MEDIA_TYPE_AUDIO].segment_count, MSS_STREAM_TYPE_AUDIO); stream_index = 0; for (cur_stream = mpeg_metadata->first_stream; cur_stream < mpeg_metadata->last_stream; cur_stream++) { if (cur_stream->media_info.media_type != MEDIA_TYPE_AUDIO) { continue; } bitrate = cur_stream->media_info.bitrate; bitrate = mss_encode_indexes(bitrate, cur_stream->file_info.file_index, cur_stream->track_index); p = vod_sprintf(p, MSS_AUDIO_QUALITY_LEVEL_HEADER, stream_index++, bitrate, cur_stream->media_info.u.audio.sample_rate, (uint32_t)cur_stream->media_info.u.audio.channels, (uint32_t)cur_stream->media_info.u.audio.bits_per_sample, (uint32_t)cur_stream->media_info.u.audio.packet_size); p = mss_append_hex_string(p, cur_stream->media_info.extra_data, cur_stream->media_info.extra_data_size); p = vod_copy(p, MSS_QUALITY_LEVEL_FOOTER, sizeof(MSS_QUALITY_LEVEL_FOOTER) - 1); } p = mss_write_manifest_chunks(p, &segment_durations[MEDIA_TYPE_AUDIO]); p = vod_copy(p, MSS_STREAM_INDEX_FOOTER, sizeof(MSS_STREAM_INDEX_FOOTER) - 1); } if (write_extra_tags != NULL) { p = write_extra_tags(extra_tags_writer_context, p, mpeg_metadata); } p = vod_copy(p, MSS_MANIFEST_FOOTER, sizeof(MSS_MANIFEST_FOOTER) - 1); result->len = p - result->data; if (result->len > result_size) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "mss_packager_build_manifest: result length %uz exceeded allocated length %uz", result->len, result_size); return VOD_UNEXPECTED; } return VOD_OK; }
static u_char* dash_packager_write_segment_list( u_char* p, dash_manifest_config_t* conf, media_set_t* media_set, segmenter_conf_t* segmenter_conf, vod_str_t* base_url, u_char* base_url_temp_buffer, uint32_t clip_index, media_sequence_t* cur_sequence, media_track_t* cur_track, uint32_t segment_count) { int media_type_char = cur_track->media_info.media_type == MEDIA_TYPE_VIDEO ? 'v' : 'a'; vod_str_t track_spec; vod_str_t cur_base_url; u_char track_spec_buffer[MAX_TRACK_SPEC_LENGTH]; uint32_t sequence_index = cur_sequence->index; uint32_t i; track_spec.data = track_spec_buffer; // build the base url if (base_url->len != 0) { cur_base_url.data = base_url_temp_buffer; base_url_temp_buffer = vod_copy(base_url_temp_buffer, base_url->data, base_url->len); if (cur_track->file_info.uri.len != 0) { base_url_temp_buffer = vod_copy(base_url_temp_buffer, cur_track->file_info.uri.data, cur_track->file_info.uri.len); sequence_index = INVALID_SEQUENCE_INDEX; // no need to pass the sequence index since we have a direct uri } else { base_url_temp_buffer = vod_copy(base_url_temp_buffer, media_set->uri.data, media_set->uri.len); } *base_url_temp_buffer++ = '/'; cur_base_url.len = base_url_temp_buffer - cur_base_url.data; } else { cur_base_url.data = NULL; cur_base_url.len = 0; } // get the track specification dash_packager_get_track_spec( &track_spec, media_set, clip_index, sequence_index, cur_track->index, media_type_char); // write the header p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_LIST_HEADER, segmenter_conf->segment_duration, &cur_base_url, &conf->init_file_name_prefix, &track_spec); // write the urls for (i = 0; i < segment_count; i++) { p = vod_sprintf(p, VOD_DASH_MANIFEST_SEGMENT_URL, &cur_base_url, &conf->fragment_file_name_prefix, i + 1, &track_spec); } p = vod_copy(p, VOD_DASH_MANIFEST_SEGMENT_LIST_FOOTER, sizeof(VOD_DASH_MANIFEST_SEGMENT_LIST_FOOTER) - 1); return p; }
vod_status_t manifest_utils_build_request_params_string( request_context_t* request_context, uint32_t* has_tracks, uint32_t segment_index, uint32_t sequences_mask, uint32_t* sequence_tracks_mask, uint32_t* tracks_mask, vod_str_t* suffix, vod_str_t* args_str, vod_str_t* result) { u_char* p; size_t result_size; bool_t newline_shift = FALSE; if (sequence_tracks_mask != NULL) { return manifest_utils_build_request_params_string_per_sequence_tracks( request_context, segment_index, sequences_mask, sequence_tracks_mask, result); } result_size = suffix->len + args_str->len; if (suffix->data[suffix->len - 1] == '\n') { newline_shift = TRUE; } // segment index if (segment_index != INVALID_SEGMENT_INDEX) { result_size += 1 + vod_get_int_print_len(segment_index + 1); } // sequence mask if (sequences_mask != 0xffffffff) { result_size += vod_get_number_of_set_bits(sequences_mask) * (sizeof("-f32") - 1); } // video tracks if (tracks_mask[MEDIA_TYPE_VIDEO] == 0xffffffff) { result_size += sizeof("-v0") - 1; } else { result_size += vod_get_number_of_set_bits(tracks_mask[MEDIA_TYPE_VIDEO]) * (sizeof("-v32") - 1); } // audio tracks if (tracks_mask[MEDIA_TYPE_AUDIO] == 0xffffffff) { result_size += sizeof("-a0") - 1; } else { result_size += vod_get_number_of_set_bits(tracks_mask[MEDIA_TYPE_AUDIO]) * (sizeof("-a32") - 1); } p = vod_alloc(request_context->pool, result_size + 1); if (p == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "manifest_utils_build_request_params_string: vod_alloc failed"); return VOD_ALLOC_FAILED; } result->data = p; // segment index if (segment_index != INVALID_SEGMENT_INDEX) { p = vod_sprintf(p, "-%uD", segment_index + 1); } // sequence mask if (sequences_mask != 0xffffffff) { p = manifest_utils_write_bitmask(p, sequences_mask, 'f'); } // video tracks if (has_tracks[MEDIA_TYPE_VIDEO]) { if (tracks_mask[MEDIA_TYPE_VIDEO] == 0xffffffff) { p = vod_copy(p, "-v0", sizeof("-v0") - 1); } else { p = manifest_utils_write_bitmask(p, tracks_mask[MEDIA_TYPE_VIDEO], 'v'); } } // audio tracks if (has_tracks[MEDIA_TYPE_AUDIO]) { if (tracks_mask[MEDIA_TYPE_AUDIO] == 0xffffffff) { p = vod_copy(p, "-a0", sizeof("-a0") - 1); } else { p = manifest_utils_write_bitmask(p, tracks_mask[MEDIA_TYPE_AUDIO], 'a'); } } p = vod_copy(p, suffix->data, newline_shift ? suffix->len - 1 : suffix->len); p = vod_copy(p, args_str->data, args_str->len); if (newline_shift) { *p++ = '\n'; } result->len = p - result->data; if (result->len > result_size) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "manifest_utils_build_request_params_string: result length %uz exceeded allocated length %uz", result->len, result_size); return VOD_UNEXPECTED; } return VOD_OK; }
static u_char* dash_packager_write_mpd_period( u_char* p, u_char* base_url_temp_buffer, segment_durations_t* segment_durations, segment_duration_item_t** cur_duration_items, uint32_t clip_index, dash_manifest_config_t* conf, vod_str_t* base_url, segmenter_conf_t* segmenter_conf, media_set_t* media_set, write_tags_callback_t write_representation_tags, void* representation_tags_writer_context) { media_clip_filtered_t* cur_clip; media_sequence_t* cur_sequence; media_track_t* last_track; media_track_t* cur_track; vod_str_t representation_id; u_char representation_id_buffer[MAX_TRACK_SPEC_LENGTH]; uint32_t filtered_clip_index; uint32_t max_width = 0; uint32_t max_height = 0; uint32_t max_framerate_duration = 0; uint32_t max_framerate_timescale = 0; uint32_t segment_count = 0; representation_id.data = representation_id_buffer; if (media_set->use_discontinuity) { p = vod_sprintf(p, VOD_DASH_MANIFEST_PERIOD_DURATION_HEADER, clip_index, media_set->durations[clip_index] / 1000, media_set->durations[clip_index] % 1000); } else { p = vod_copy(p, VOD_DASH_MANIFEST_PERIOD_HEADER, sizeof(VOD_DASH_MANIFEST_PERIOD_HEADER) - 1); } // Note: clip_index can be greater than clip count when consistentSequenceMediaInfo is true filtered_clip_index = clip_index < media_set->clip_count ? clip_index : 0; // video adaptation set if (media_set->track_count[MEDIA_TYPE_VIDEO] != 0) { // get the max width, height and frame rate cur_track = media_set->filtered_tracks + filtered_clip_index * media_set->total_track_count; last_track = cur_track + media_set->total_track_count; for (; cur_track < last_track; cur_track++) { if (cur_track->media_info.media_type != MEDIA_TYPE_VIDEO) { continue; } if (cur_track->media_info.u.video.width > max_width) { max_width = cur_track->media_info.u.video.width; } if (cur_track->media_info.u.video.height > max_height) { max_height = cur_track->media_info.u.video.height; } if (max_framerate_duration == 0 || cur_track->media_info.timescale * max_framerate_duration > max_framerate_timescale * cur_track->media_info.min_frame_duration) { max_framerate_duration = cur_track->media_info.min_frame_duration; max_framerate_timescale = cur_track->media_info.timescale; } } // print the header p = vod_sprintf(p, VOD_DASH_MANIFEST_VIDEO_HEADER, max_width, max_height, (uint32_t)max_framerate_timescale / max_framerate_duration, (uint32_t)(((uint64_t)max_framerate_timescale * 1000) / max_framerate_duration % 1000)); // print the segment template switch (conf->manifest_format) { case FORMAT_SEGMENT_TEMPLATE: p = dash_packager_write_segment_template( p, conf, segmenter_conf, base_url); break; case FORMAT_SEGMENT_TIMELINE: p = dash_packager_write_segment_timeline( p, conf, &segment_durations[MEDIA_TYPE_VIDEO], &cur_duration_items[MEDIA_TYPE_VIDEO], base_url); break; case FORMAT_SEGMENT_LIST: if (media_set->use_discontinuity) { segment_count = dash_packager_get_cur_clip_segment_count( &segment_durations[MEDIA_TYPE_VIDEO], &cur_duration_items[MEDIA_TYPE_VIDEO]); } else { segment_count = segment_durations[MEDIA_TYPE_VIDEO].segment_count; } break; } // print the representations for (cur_sequence = media_set->sequences; cur_sequence < media_set->sequences_end; cur_sequence++) { cur_clip = &cur_sequence->filtered_clips[filtered_clip_index]; last_track = cur_clip->last_track; for (cur_track = cur_clip->first_track; cur_track < last_track; cur_track++) { if (cur_track->media_info.media_type != MEDIA_TYPE_VIDEO) { continue; } dash_packager_get_track_spec( &representation_id, media_set, clip_index, cur_sequence->index, cur_track->index, 'v'); p = vod_sprintf(p, VOD_DASH_MANIFEST_VIDEO_PREFIX, &representation_id, &cur_track->media_info.codec_name, (uint32_t)cur_track->media_info.u.video.width, (uint32_t)cur_track->media_info.u.video.height, (uint32_t)(cur_track->media_info.timescale / cur_track->media_info.min_frame_duration), (uint32_t)(((uint64_t)cur_track->media_info.timescale * 1000) / cur_track->media_info.min_frame_duration % 1000), cur_track->media_info.bitrate ); if (conf->manifest_format == FORMAT_SEGMENT_LIST) { p = dash_packager_write_segment_list( p, conf, media_set, segmenter_conf, base_url, base_url_temp_buffer, clip_index, cur_sequence, cur_track, segment_count); } // write any additional tags if (write_representation_tags != NULL) { p = write_representation_tags(representation_tags_writer_context, p, cur_track); } p = vod_copy(p, VOD_DASH_MANIFEST_VIDEO_SUFFIX, sizeof(VOD_DASH_MANIFEST_VIDEO_SUFFIX) - 1); } } // print the footer p = vod_copy(p, VOD_DASH_MANIFEST_VIDEO_FOOTER, sizeof(VOD_DASH_MANIFEST_VIDEO_FOOTER) - 1); } // audio adaptation set if (media_set->track_count[MEDIA_TYPE_AUDIO] != 0) { // print the header p = vod_copy(p, VOD_DASH_MANIFEST_AUDIO_HEADER, sizeof(VOD_DASH_MANIFEST_AUDIO_HEADER) - 1); // print the segment template switch (conf->manifest_format) { case FORMAT_SEGMENT_TEMPLATE: p = dash_packager_write_segment_template( p, conf, segmenter_conf, base_url); break; case FORMAT_SEGMENT_TIMELINE: p = dash_packager_write_segment_timeline( p, conf, &segment_durations[MEDIA_TYPE_AUDIO], &cur_duration_items[MEDIA_TYPE_AUDIO], base_url); break; case FORMAT_SEGMENT_LIST: if (media_set->use_discontinuity) { segment_count = dash_packager_get_cur_clip_segment_count( &segment_durations[MEDIA_TYPE_AUDIO], &cur_duration_items[MEDIA_TYPE_AUDIO]); } else { segment_count = segment_durations[MEDIA_TYPE_AUDIO].segment_count; } break; } // print the representations for (cur_sequence = media_set->sequences; cur_sequence < media_set->sequences_end; cur_sequence++) { cur_clip = &cur_sequence->filtered_clips[filtered_clip_index]; last_track = cur_clip->last_track; for (cur_track = cur_clip->first_track; cur_track < last_track; cur_track++) { if (cur_track->media_info.media_type != MEDIA_TYPE_AUDIO) { continue; } dash_packager_get_track_spec( &representation_id, media_set, clip_index, cur_sequence->index, cur_track->index, 'a'); p = vod_sprintf(p, VOD_DASH_MANIFEST_AUDIO_PREFIX, &representation_id, &cur_track->media_info.codec_name, cur_track->media_info.u.audio.sample_rate, cur_track->media_info.bitrate); if (conf->manifest_format == FORMAT_SEGMENT_LIST) { p = dash_packager_write_segment_list( p, conf, media_set, segmenter_conf, base_url, base_url_temp_buffer, clip_index, cur_sequence, cur_track, segment_count); } // write any additional tags if (write_representation_tags != NULL) { p = write_representation_tags(representation_tags_writer_context, p, cur_track); } p = vod_copy(p, VOD_DASH_MANIFEST_AUDIO_SUFFIX, sizeof(VOD_DASH_MANIFEST_AUDIO_SUFFIX) - 1); } } // print the footer p = vod_copy(p, VOD_DASH_MANIFEST_AUDIO_FOOTER, sizeof(VOD_DASH_MANIFEST_AUDIO_FOOTER) - 1); } p = vod_copy(p, VOD_DASH_MANIFEST_PERIOD_FOOTER, sizeof(VOD_DASH_MANIFEST_PERIOD_FOOTER) - 1); return p; }
static vod_status_t manifest_utils_build_request_params_string_per_sequence_tracks( request_context_t* request_context, uint32_t segment_index, uint32_t sequences_mask, uint32_t* sequence_tracks_mask, vod_str_t* result) { u_char* p; size_t result_size; uint32_t* tracks_mask; uint32_t i; result_size = 0; // segment index if (segment_index != INVALID_SEGMENT_INDEX) { result_size += 1 + vod_get_int_print_len(segment_index + 1); } for (i = 0, tracks_mask = sequence_tracks_mask; i < MAX_SEQUENCES; i++, tracks_mask += MEDIA_TYPE_COUNT) { if ((sequences_mask & (1 << i)) == 0) { continue; } // sequence result_size += sizeof("-f32") - 1; // video tracks if (tracks_mask[MEDIA_TYPE_VIDEO] == 0xffffffff) { result_size += sizeof("-v0") - 1; } else { result_size += vod_get_number_of_set_bits(tracks_mask[MEDIA_TYPE_VIDEO]) * (sizeof("-v32") - 1); } // audio tracks if (tracks_mask[MEDIA_TYPE_AUDIO] == 0xffffffff) { result_size += sizeof("-a0") - 1; } else { result_size += vod_get_number_of_set_bits(tracks_mask[MEDIA_TYPE_AUDIO]) * (sizeof("-a32") - 1); } } p = vod_alloc(request_context->pool, result_size + 1); if (p == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "manifest_utils_build_request_params_string_per_sequence_tracks: vod_alloc failed"); return VOD_ALLOC_FAILED; } result->data = p; // segment index if (segment_index != INVALID_SEGMENT_INDEX) { p = vod_sprintf(p, "-%uD", segment_index + 1); } for (i = 0, tracks_mask = sequence_tracks_mask; i < MAX_SEQUENCES; i++, tracks_mask += MEDIA_TYPE_COUNT) { if ((sequences_mask & (1 << i)) == 0) { continue; } // sequence p = vod_sprintf(p, "-f%uD", i + 1); // video tracks switch (tracks_mask[MEDIA_TYPE_VIDEO]) { case 0xffffffff: p = vod_copy(p, "-v0", sizeof("-v0") - 1); break; case 0: break; default: p = manifest_utils_write_bitmask(p, tracks_mask[MEDIA_TYPE_VIDEO], 'v'); break; } // audio tracks switch (tracks_mask[MEDIA_TYPE_AUDIO]) { case 0xffffffff: p = vod_copy(p, "-a0", sizeof("-a0") - 1); break; case 0: break; default: p = manifest_utils_write_bitmask(p, tracks_mask[MEDIA_TYPE_AUDIO], 'a'); break; } } result->len = p - result->data; if (result->len > result_size) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "manifest_utils_build_request_params_string_per_sequence_tracks: result length %uz exceeded allocated length %uz", result->len, result_size); return VOD_UNEXPECTED; } return VOD_OK; }
vod_status_t dash_packager_build_mpd( request_context_t* request_context, dash_manifest_config_t* conf, vod_str_t* base_url, segmenter_conf_t* segmenter_conf, media_set_t* media_set, size_t representation_tags_size, write_tags_callback_t write_representation_tags, void* representation_tags_writer_context, vod_str_t* result) { segment_durations_t segment_durations[MEDIA_TYPE_COUNT]; segment_duration_item_t* cur_duration_items[MEDIA_TYPE_COUNT]; size_t base_url_temp_buffer_size = 0; size_t base_period_size; size_t result_size; size_t urls_length; uint32_t period_count = media_set->use_discontinuity ? media_set->total_clip_count : 1; uint32_t clip_index; uint32_t media_type; vod_status_t rc; u_char* base_url_temp_buffer = NULL; u_char* p; // get segment durations and count for each media type for (media_type = 0; media_type < MEDIA_TYPE_COUNT; media_type++) { if (media_set->track_count[media_type] == 0) { continue; } rc = segmenter_conf->get_segment_durations( request_context, segmenter_conf, media_set, NULL, media_type, &segment_durations[media_type]); if (rc != VOD_OK) { return rc; } } // remove redundant tracks dash_packager_remove_redundant_tracks( conf->duplicate_bitrate_threshold, media_set); // calculate the total size urls_length = 2 * base_url->len + conf->init_file_name_prefix.len + conf->fragment_file_name_prefix.len; base_period_size = sizeof(VOD_DASH_MANIFEST_PERIOD_DURATION_HEADER) - 1 + 3 * VOD_INT32_LEN + sizeof(VOD_DASH_MANIFEST_VIDEO_HEADER) - 1 + 4 * VOD_INT32_LEN + media_set->track_count[MEDIA_TYPE_VIDEO] * ( sizeof(VOD_DASH_MANIFEST_VIDEO_PREFIX) - 1 + MAX_TRACK_SPEC_LENGTH + MAX_CODEC_NAME_SIZE + 5 * VOD_INT32_LEN + sizeof(VOD_DASH_MANIFEST_VIDEO_SUFFIX) - 1) + sizeof(VOD_DASH_MANIFEST_VIDEO_FOOTER) - 1 + sizeof(VOD_DASH_MANIFEST_AUDIO_HEADER) - 1 + media_set->track_count[MEDIA_TYPE_AUDIO] * ( sizeof(VOD_DASH_MANIFEST_AUDIO_PREFIX) - 1 + MAX_TRACK_SPEC_LENGTH + MAX_CODEC_NAME_SIZE + 2 * VOD_INT32_LEN + sizeof(VOD_DASH_MANIFEST_AUDIO_SUFFIX) - 1) + sizeof(VOD_DASH_MANIFEST_AUDIO_FOOTER) - 1 + sizeof(VOD_DASH_MANIFEST_PERIOD_FOOTER) - 1 + representation_tags_size; result_size = sizeof(VOD_DASH_MANIFEST_HEADER) - 1 + 3 * VOD_INT32_LEN + base_period_size * period_count + sizeof(VOD_DASH_MANIFEST_FOOTER); switch (conf->manifest_format) { case FORMAT_SEGMENT_TEMPLATE: result_size += (sizeof(VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FIXED) - 1 + urls_length + VOD_INT64_LEN) * MEDIA_TYPE_COUNT * period_count; break; case FORMAT_SEGMENT_TIMELINE: for (media_type = 0; media_type < MEDIA_TYPE_COUNT; media_type++) { if (media_set->track_count[media_type] == 0) { continue; } result_size += (sizeof(VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_HEADER) - 1 + urls_length + sizeof(VOD_DASH_MANIFEST_SEGMENT_TEMPLATE_FOOTER) - 1) * period_count + (sizeof(VOD_DASH_MANIFEST_SEGMENT_REPEAT) - 1 + 2 * VOD_INT32_LEN) * segment_durations[media_type].item_count; } break; case FORMAT_SEGMENT_LIST: result_size += dash_packager_get_segment_list_total_size( conf, media_set, segment_durations, base_url, &base_url_temp_buffer_size); break; } // allocate the buffer result->data = vod_alloc(request_context->pool, result_size); if (result->data == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "dash_packager_build_mpd: vod_alloc failed (1)"); return VOD_ALLOC_FAILED; } if (base_url_temp_buffer_size != 0) { base_url_temp_buffer = vod_alloc(request_context->pool, base_url_temp_buffer_size); if (base_url_temp_buffer == NULL) { vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0, "dash_packager_build_mpd: vod_alloc failed (2)"); return VOD_ALLOC_FAILED; } } // print the manifest header p = vod_sprintf(result->data, VOD_DASH_MANIFEST_HEADER, (uint32_t)(media_set->total_duration / 1000), (uint32_t)(media_set->total_duration % 1000), (uint32_t)(segmenter_conf->max_segment_duration / 1000)); cur_duration_items[MEDIA_TYPE_VIDEO] = segment_durations[MEDIA_TYPE_VIDEO].items; cur_duration_items[MEDIA_TYPE_AUDIO] = segment_durations[MEDIA_TYPE_AUDIO].items; for (clip_index = 0; clip_index < period_count; clip_index++) { p = dash_packager_write_mpd_period( p, base_url_temp_buffer, segment_durations, cur_duration_items, clip_index, conf, base_url, segmenter_conf, media_set, write_representation_tags, representation_tags_writer_context); } p = vod_copy(p, VOD_DASH_MANIFEST_FOOTER, sizeof(VOD_DASH_MANIFEST_FOOTER) - 1); result->len = p - result->data; if (result->len > result_size) { vod_log_error(VOD_LOG_ERR, request_context->log, 0, "dash_packager_build_mpd: result length %uz exceeded allocated length %uz", result->len, result_size); return VOD_UNEXPECTED; } return VOD_OK; }