static bool_t
manifest_utils_is_multi_audio(media_set_t* media_set)
{
media_track_t* last_track;
media_track_t* cur_track;
vod_str_t* label = NULL;
last_track = media_set->filtered_tracks + media_set->total_track_count;
for (cur_track = media_set->filtered_tracks; cur_track < last_track; cur_track++)
{
if (cur_track->media_info.media_type != MEDIA_TYPE_AUDIO ||
cur_track->media_info.label.len == 0)
{
continue;
}
if (label == NULL)
{
label = &cur_track->media_info.label;
}
else if (!vod_str_equals(cur_track->media_info.label, *label))
{
return TRUE;
}
}
return FALSE;
}
// mpd writing code
static bool_t
dash_packager_compare_tracks(uintptr_t bitrate_threshold, const media_info_t* mi1, const media_info_t* mi2)
{
if (mi1->bitrate == 0 ||
mi2->bitrate == 0 ||
mi1->bitrate + bitrate_threshold <= mi2->bitrate ||
mi2->bitrate + bitrate_threshold <= mi1->bitrate)
{
return FALSE;
}
if (mi1->codec_name.len != mi2->codec_name.len ||
vod_memcmp(mi1->codec_name.data, mi2->codec_name.data, mi2->codec_name.len) != 0)
{
return FALSE;
}
if (mi1->media_type == MEDIA_TYPE_VIDEO)
{
return (mi1->u.video.width == mi2->u.video.width) &&
(mi1->u.video.height == mi2->u.video.height);
}
if (mi1->label.len == 0 || mi2->label.len == 0)
{
return TRUE;
}
return vod_str_equals(mi1->label, mi2->label);
}
static label_track_count_t*
manifest_utils_find_label(
vod_str_t* label,
label_track_count_array_t* labels,
size_t* index)
{
label_track_count_t* cur_label;
for (cur_label = labels->first, *index = 0; cur_label < labels->last; cur_label++, (*index)++)
{
if (vod_str_equals(cur_label->label, *label))
{
return cur_label;
}
}
return NULL;
}
static vod_status_t
manifest_utils_get_muxed_adaptation_set(
request_context_t* request_context,
media_set_t* media_set,
uint32_t flags,
vod_str_t* label,
adaptation_set_t* output)
{
media_sequence_t* cur_sequence;
media_track_t** cur_track_ptr;
media_track_t* audio_track;
media_track_t* last_track;
media_track_t* cur_track;
uint32_t main_media_type;
// allocate the tracks array
cur_track_ptr = vod_alloc(request_context->pool,
sizeof(output->first[0]) * media_set->total_track_count * MEDIA_TYPE_COUNT);
if (cur_track_ptr == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"manifest_utils_get_muxed_adaptation_set: vod_alloc failed");
return VOD_ALLOC_FAILED;
}
output->type = ADAPTATION_TYPE_MUXED;
output->first = cur_track_ptr;
output->count = 0;
for (cur_sequence = media_set->sequences; cur_sequence < media_set->sequences_end; cur_sequence++)
{
// find the main media type
if (cur_sequence->track_count[MEDIA_TYPE_VIDEO] > 0)
{
main_media_type = MEDIA_TYPE_VIDEO;
}
else if (cur_sequence->track_count[MEDIA_TYPE_AUDIO] > 0)
{
if ((flags & ADAPTATION_SETS_FLAG_AVOID_AUDIO_ONLY) != 0 &&
media_set->track_count[MEDIA_TYPE_VIDEO] > 0)
{
continue;
}
main_media_type = MEDIA_TYPE_AUDIO;
}
else
{
continue;
}
// find the audio track
audio_track = cur_sequence->filtered_clips[0].longest_track[MEDIA_TYPE_AUDIO];
if ((audio_track == NULL || (label != NULL && !vod_str_equals(*label, audio_track->media_info.label))) &&
media_set->track_count[MEDIA_TYPE_AUDIO] > 0)
{
if (cur_sequence->track_count[MEDIA_TYPE_VIDEO] <= 0)
{
continue;
}
// find some audio track from another sequence to mux with this video
last_track = media_set->filtered_tracks + media_set->total_track_count;
for (cur_track = media_set->filtered_tracks; cur_track < last_track; cur_track++)
{
if (cur_track->media_info.media_type == MEDIA_TYPE_AUDIO &&
(label == NULL || vod_str_equals(*label, cur_track->media_info.label)))
{
audio_track = cur_track;
break;
}
}
}
for (cur_track = cur_sequence->filtered_clips[0].first_track; cur_track < cur_sequence->filtered_clips[0].last_track; cur_track++)
{
if (cur_track->media_info.media_type != main_media_type)
{
continue;
}
// add the track
if (main_media_type == MEDIA_TYPE_VIDEO)
{
cur_track_ptr[MEDIA_TYPE_VIDEO] = cur_track;
cur_track_ptr[MEDIA_TYPE_AUDIO] = audio_track;
}
else
{
cur_track_ptr[MEDIA_TYPE_VIDEO] = NULL;
cur_track_ptr[MEDIA_TYPE_AUDIO] = cur_track;
}
cur_track_ptr[MEDIA_TYPE_SUBTITLE] = NULL;
cur_track_ptr += MEDIA_TYPE_COUNT;
output->count++;
}
}
output->last = cur_track_ptr;
return VOD_OK;
}
static vod_status_t
manifest_utils_get_unique_labels(
request_context_t* request_context,
media_set_t* media_set,
uint32_t media_type,
label_track_count_array_t* output)
{
vod_str_t* cur_track_label;
label_track_count_t* first_label;
label_track_count_t* last_label;
label_track_count_t* cur_label;
media_track_t* last_track;
media_track_t* cur_track;
bool_t label_found;
first_label = vod_alloc(request_context->pool,
media_set->total_track_count * sizeof(first_label[0]));
if (first_label == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"manifest_utils_get_unique_labels: vod_alloc failed");
return VOD_ALLOC_FAILED;
}
last_label = first_label;
last_track = media_set->filtered_tracks + media_set->total_track_count;
for (cur_track = media_set->filtered_tracks; cur_track < last_track; cur_track++)
{
if (cur_track->media_info.media_type != media_type ||
cur_track->media_info.label.len == 0)
{
continue;
}
cur_track_label = &cur_track->media_info.label;
label_found = FALSE;
for (cur_label = first_label; cur_label < last_label; cur_label++)
{
if (vod_str_equals(*cur_track_label, cur_label->label))
{
label_found = TRUE;
break;
}
}
if (label_found)
{
cur_label->track_count++;
continue;
}
last_label->label = *cur_track_label;
last_label->track_count = 1;
last_label++;
}
output->first = first_label;
output->last = last_label;
output->count = last_label - first_label;
return VOD_OK;
}
