add support key frame positions in mapping json

make is possible to align the segments to keyframes while having accurate
segment durations in the manifest.

Author: erankor

README.md

@@ -420,6 +420,14 @@ Optional fields:
 * `label` - a friendly string that identifies the sequence. if a language is specified,
 	a default label will be automatically derived by it - e.g. if language is `ita`, 
 	by default `italiano` will be used as the label.
+* `keyFrameDurations` - array of integers, containing the durations of the video key frames
+	in the sequence. Supplying the key frame durations enables the module to both:
+	1. align the segments to key frames 
+	2. report the correct segment durations in the manifest - providing an alternative to setting
+		`vod_manifest_segment_durations_mode` to `accurate`, which is not supported for multi clip
+		media sets (for performance reasons).
+* `firstKeyFrameOffset` - integer, offset of the first video key frame in the sequence, 
+	measured in milliseconds relative to `firstClipTime`. Defaults to 0 if not supplied.
 
 #### Clip (abstract)
 

ngx_http_vod_module.c

@@ -986,6 +986,7 @@ ngx_http_vod_parse_metadata(
 	ngx_http_vod_ctx_t *ctx, 
 	ngx_flag_t fetched_from_cache)
 {
+	get_clip_ranges_params_t get_ranges_params;
 	media_parse_params_t parse_params;
 	const ngx_http_vod_request_t* request = ctx->request;
 	media_clip_source_t* cur_source = ctx->cur_source;
@@ -1143,15 +1144,18 @@ ngx_http_vod_parse_metadata(
 			// get the start/end offsets
 			duration_millis = rescale_time(ctx->base_metadata->duration * rate.denom, ctx->base_metadata->timescale * rate.nom, 1000);
 
+			get_ranges_params.request_context = &ctx->submodule_context.request_context,
+			get_ranges_params.conf = segmenter,
+			get_ranges_params.segment_index = ctx->submodule_context.request_params.segment_index,
+			get_ranges_params.clip_durations = &duration_millis,
+			get_ranges_params.total_clip_count = 1,
+			get_ranges_params.start_time = 0,
+			get_ranges_params.end_time = duration_millis,
+			get_ranges_params.last_segment_end = last_segment_end,
+			get_ranges_params.key_frame_durations = NULL;
+
 			rc = segmenter_get_start_end_ranges_no_discontinuity(
-				&ctx->submodule_context.request_context,
-				segmenter,
-				ctx->submodule_context.request_params.segment_index,
-				&duration_millis,
-				1,
-				0,
-				duration_millis,
-				last_segment_end,
+				&get_ranges_params,
 				&clip_ranges);
 			if (rc != VOD_OK)
 			{

ngx_http_vod_request_parse.c

@@ -909,6 +909,8 @@ ngx_http_vod_parse_uri_path(
 		cur_sequence->id.len = 0;
 		cur_sequence->language = 0;
 		cur_sequence->label.len = 0;
+		cur_sequence->first_key_frame_offset = 0;
+		cur_sequence->key_frame_durations = NULL;
 
 		cur_source++;
 		cur_sequence++;

test/playlist.php

@@ -8,15 +8,43 @@
 	exactly the same encoding parameters (in the case of h264, the SPS/PPS have to be the same).
 */
 
+function getRequestParams()
+{
+        $scriptParts = explode('/', $_SERVER['SCRIPT_NAME']);
+        $pathParts = array();
+        if (isset($_SERVER['PHP_SELF']))
+                $pathParts = explode('/', $_SERVER['PHP_SELF']);
+        $pathParts = array_diff($pathParts, $scriptParts);
+
+        $params = array();
+        reset($pathParts);
+        while(current($pathParts))
+        {
+                $key = each($pathParts);
+                $value = each($pathParts);
+                if (!array_key_exists($key['value'], $params))
+                {
+                        $params[$key['value']] = $value['value'];
+                }
+        }
+        return $params;
+}
+
+$params = getRequestParams();
+$discontinuity = (isset($params['disc']) && $params['disc']) ? true : false;
+$playlistType = isset($params['type']) ? $params['type'] : "live";
+
 // input params
-$playlistType = "live";			// live / vod
-$discontinuity = true;
 $filePaths = array(
 	"/path/to/video1.mp4",
 	"/path/to/video2.mp4",
 	"/path/to/video3.mp4",
 	);
-$ffprobeBin = '/path/to/ffprobe.sh';
+if (!$discontinuity)
+{
+	$filePaths = array($filePaths[0], $filePaths[0]);
+}
+$ffprobeBin = '/web/content/shared/bin/ffmpeg-2.7.2-bin/ffprobe.sh';
 $timeMargin = 10000;		// a safety margin to compensate for clock differences
 
 // nginx conf params
@@ -86,18 +114,19 @@ function getDurationMillis($filePath)
 
 	// start the playlist from now() - <dvr window size>
 	$currentTime = time() * 1000 - $timeMargin - $dvrWindowSize;
-	
-	// set the first clip time to now() rounded down to cycle duration
-	$result["firstClipTime"] = floor($currentTime / $cycleDuration) * $cycleDuration;
-	
-	// get the reference time (the first clip time of the first run)
+
+	// get the reference time (the time of the first run)
 	$referenceTime = apc_fetch('reference_time');
 	if (!$referenceTime)
 	{
-		$referenceTime = $result["firstClipTime"];
+		$referenceTime = $currentTime;
 		apc_store('reference_time', $referenceTime);
 	}
-
+	
+	// set the first clip time to now() rounded down to cycle duration
+	$cycleIndex = floor(($currentTime - $referenceTime) / $cycleDuration);
+	$result["firstClipTime"] = $referenceTime + $cycleIndex * $cycleDuration;
+	
 	if ($discontinuity)
 	{
 		// find the total number of segments in each cycle
@@ -108,7 +137,6 @@ function getDurationMillis($filePath)
 		}
 
 		// find the initial clip index and initial segment index
-		$cycleIndex = floor(($currentTime - $referenceTime) / $cycleDuration);
 		$result["initialClipIndex"] = $cycleIndex * count($durations) + 1;
 		$result["initialSegmentIndex"] = $cycleIndex * $totalSegmentCount + 1;
 	}

vod/common.h

@@ -264,6 +264,13 @@ enum {
 	VOD_ERROR_LAST,
 };
 
+typedef struct vod_array_part_s {
+	void* first;
+	void* last;
+	size_t count;
+	struct vod_array_part_s* next;
+} vod_array_part_t;
+
 typedef vod_status_t(*write_callback_t)(void* context, u_char* buffer, uint32_t size);
 
 typedef struct {

vod/filters/concat_clip.c

@@ -43,8 +43,8 @@ concat_clip_parse(
 	void** result)
 {
 	media_filter_parse_context_t* context = ctx;
-	vod_json_array_part_t* first_part = NULL;
-	vod_json_array_part_t* part;
+	vod_array_part_t* first_part = NULL;
+	vod_array_part_t* part;
 	media_clip_source_t* sources_list_head;
 	media_clip_source_t* cur_source;
 	media_clip_source_t* sources_end;

vod/json_parser.c

@@ -321,7 +321,7 @@ vod_json_parse_fraction(vod_json_parser_state_t* state, vod_json_fraction_t* res
 static vod_json_status_t
 vod_json_parse_array(vod_json_parser_state_t* state, vod_json_array_t* result)
 {
-	vod_json_array_part_t* part;
+	vod_array_part_t* part;
 	vod_json_type_t* type;
 	size_t initial_part_count;
 	size_t part_size;

vod/json_parser.h

@@ -31,17 +31,10 @@ typedef struct {
 	uint64_t denom;
 } vod_json_fraction_t;
 
-typedef struct vod_json_array_part_s {
-	void* first;
-	void* last;
-	size_t count;
-	struct vod_json_array_part_s* next;
-} vod_json_array_part_t;
-
 typedef struct {
 	int type;
 	size_t count;
-	vod_json_array_part_t part;
+	vod_array_part_t part;
 } vod_json_array_t;
 
 typedef vod_array_t vod_json_object_t;

vod/media_format.h

@@ -16,6 +16,8 @@
 #define MAX_FRAME_SIZE (10 * 1024 * 1024)
 #define MAX_TRACK_COUNT (1024)
 #define MAX_DURATION_SEC (1000000)
+#define MAX_CLIP_DURATION (86400000)		// 1 day
+#define MAX_SEQUENCE_DURATION (864000000)		// 10 days
 
 // parse flags
 

vod/media_set.h

@@ -44,11 +44,14 @@ typedef struct {
 struct media_sequence_s {
 	// initialized during parsing
 	uint32_t index;
+	vod_array_part_t* unparsed_clips;
 	media_clip_t** clips;						// [clip_count]
 	vod_str_t stripped_uri;
 	vod_str_t id;
 	vod_str_t label;
 	language_id_t language;
+	int64_t first_key_frame_offset;
+	vod_array_part_t* key_frame_durations;
 
 	// initialized after mapping
 	vod_str_t mapped_uri;