added extra segment when custom tags are lingering at the end of the playlist

frejoel99 · frejoel99 · commit d3583baaacda · 2019-06-26T12:32:44.000-07:00
diff --git a/src/hlsparse.c b/src/hlsparse.c
@@ -1,5 +1,6 @@
 #include "parse.h"
 #include <memory.h>
+#include <stdio.h>
 
 hlsparse_malloc_callback hls_malloc = (hlsparse_malloc_callback) malloc;
 hlsparse_free_callback hls_free = (hlsparse_free_callback) free;
@@ -138,5 +139,49 @@ int hlsparse_media_playlist(const char *src, size_t size, media_playlist_t *dest
         res = pt - src;
     }
 
+    // custom tags can exist after the last segment for things like pre-roll ad insertion
+    // create a zero length segment and attach these custom tags to that segment
+    string_list_t *tag_media = &(dest->custom_tags);
+    if(tag_media && tag_media->data)
+    {
+        // create a new segment
+        segment_t *segment = hls_malloc(sizeof(segment_t));
+        hlsparse_segment_init(segment);
+
+        // add the new segment to the playlist
+        segment_list_t *next = &dest->segments;
+        while(next) {
+            if(!next->data) {
+                next->data = segment;
+                break;
+            } else if(!next->next) {
+                next->next = hls_malloc(sizeof(segment_list_t));
+                hlsparse_segment_list_init(next->next);
+                next->next->data = segment;
+                break;
+            }
+            next = next->next;
+        };
+
+        dest->last_segment = segment;
+        ++(dest->nb_segments);
+
+        segment->key_index = dest->nb_keys - 1;
+        segment->map_index = dest->nb_maps - 1;
+        segment->daterange_index = dest->nb_dateranges - 1;
+
+        segment->pdt = segment->pdt_end = dest->next_segment_pdt;
+        segment->sequence_num = dest->next_segment_media_sequence;
+
+        segment->custom_tags.data = dest->custom_tags.data;
+        segment->custom_tags.next = dest->custom_tags.next;
+        dest->custom_tags.data = NULL;
+        dest->custom_tags.next = NULL;
+
+        segment->discontinuity = dest->next_segment_discontinuity;
+        // reset the discontinuity flag
+        dest->next_segment_discontinuity = HLS_FALSE;
+    }
+
     return res;
 }
diff --git a/src/parse_playlist.c b/src/parse_playlist.c
@@ -305,7 +305,7 @@ int parse_media_playlist_tag(const char *src, size_t size, media_playlist_t *des
                 next->data = segment;
                 break;
             } else if(!next->next) {
-                next->next = hls_malloc(sizeof(segment_t));
+                next->next = hls_malloc(sizeof(segment_list_t));
                 hlsparse_segment_list_init(next->next);
                 next->next->data = segment;
                 break;
diff --git a/src/write.c b/src/write.c
@@ -260,68 +260,75 @@ HLSCode hlswrite_media(char **dest, int *dest_size, media_playlist_t *playlist)
 
     for(i=0; i<playlist->nb_segments; ++i)
     {
-        // write custom tags first
+        // write custom tags first even if the segment uri isn't available
+        // because we could have custom tags indicating actions here e.g. ad post-roll injection
         string_list_t *ctags = &seg->data->custom_tags;
         while(ctags && ctags->data) {
             ADD_TAG(ctags->data);
             ctags = ctags->next;
         }
-        
-        // new Key index?
-        if(seg->data->key_index > key_idx) {
-            key_idx = seg->data->key_index;
-            // find the key
-            int j=0;
-            key_list_t *key_list = &playlist->keys;
-            hls_key_t *key = NULL;  
-            while(key_list && key_list->data && j++ <= key_idx) {
-                key = key_list->data;
-                key_list = key_list->next;
-            }
 
-            // add key tag
-            if(key) {
-                switch(key->method) {
-                    case KEY_METHOD_NONE: START_TAG_ENUM(EXTXKEY, METHOD, NONE); break;
-                    case KEY_METHOD_AES128: START_TAG_ENUM(EXTXKEY, METHOD, AES128); break;
-                    case KEY_METHOD_SAMPLEAES: START_TAG_ENUM(EXTXKEY, METHOD, SAMPLEAES); break;
+        // only write the other tags if the uri exists
+        if(seg->data->uri) {
+            
+            // new Key index?
+            if(seg->data->key_index > key_idx) {
+                key_idx = seg->data->key_index;
+                // find the key
+                int j=0;
+                key_list_t *key_list = &playlist->keys;
+                hls_key_t *key = NULL;  
+                while(key_list && key_list->data && j++ <= key_idx) {
+                    key = key_list->data;
+                    key_list = key_list->next;
                 }
-                if(playlist->uri) {
-                    const char *uri = find_relative_path(key->uri, playlist->uri);
-                    ADD_PARAM_STR_OPTL(URI, uri);
-                }else{
-                    ADD_PARAM_STR_OPTL(URI, key->uri);
+
+                // add key tag
+                if(key) {
+                    switch(key->method) {
+                        case KEY_METHOD_NONE: START_TAG_ENUM(EXTXKEY, METHOD, NONE); break;
+                        case KEY_METHOD_AES128: START_TAG_ENUM(EXTXKEY, METHOD, AES128); break;
+                        case KEY_METHOD_SAMPLEAES: START_TAG_ENUM(EXTXKEY, METHOD, SAMPLEAES); break;
+                    }
+                    if(playlist->uri) {
+                        const char *uri = find_relative_path(key->uri, playlist->uri);
+                        ADD_PARAM_STR_OPTL(URI, uri);
+                    }else{
+                        ADD_PARAM_STR_OPTL(URI, key->uri);
+                    }
+                    ADD_PARAM_HEX_OPTL(KEY_IV, key->iv, 16);
+                    ADD_PARAM_STR_OPTL(KEYFORMAT, key->key_format);
+                    ADD_PARAM_STR_OPTL(KEYFORMATVERSIONS, key->key_format_versions);
+                    END_TAG();
                 }
-                ADD_PARAM_HEX_OPTL(KEY_IV, key->iv, 16);
-                ADD_PARAM_STR_OPTL(KEYFORMAT, key->key_format);
-                ADD_PARAM_STR_OPTL(KEYFORMATVERSIONS, key->key_format_versions);
-                END_TAG();
             }
-        }
 
-        if(seg->data->discontinuity == HLS_TRUE) {
-            ADD_TAG(EXTXDISCONTINUITY);
-            char buf[30];
-            timestamp_to_iso_date(seg->data->pdt, buf, 30);
-            ADD_TAG_ENUM(EXTXPROGRAMDATETIME, buf);
-        }
-        if(seg->data->byte_range.n > 0) {
-            if(seg->data->byte_range.o != 0) {
-                latest = pgprintf(latest, "#%s:%d@%d\n", EXTXBYTERANGE, seg->data->byte_range.n, seg->data->byte_range.o);
+            if(seg->data->discontinuity == HLS_TRUE) {
+                ADD_TAG(EXTXDISCONTINUITY);
+                char buf[30];
+                timestamp_to_iso_date(seg->data->pdt, buf, 30);
+                ADD_TAG_ENUM(EXTXPROGRAMDATETIME, buf);
+            }
+
+            if(seg->data->byte_range.n > 0) {
+                if(seg->data->byte_range.o != 0) {
+                    latest = pgprintf(latest, "#%s:%d@%d\n", EXTXBYTERANGE, seg->data->byte_range.n, seg->data->byte_range.o);
+                }else{
+                    latest = pgprintf(latest, "#%s:%d\n", EXTXBYTERANGE, seg->data->byte_range.n);
+                }
+            }
+        
+            if(seg->data->title) {
+                latest = pgprintf(latest, "#%s:%.3f,%s\n", EXTINF, seg->data->duration, seg->data->title);
             }else{
-                latest = pgprintf(latest, "#%s:%d\n", EXTXBYTERANGE, seg->data->byte_range.n);
+                latest = pgprintf(latest, "#%s:%.3f,\n", EXTINF, seg->data->duration);
+            }
+            if(playlist->uri) {
+                const char *uri = find_relative_path(seg->data->uri, playlist->uri);
+                ADD_URI(uri);
+            }else{
+                ADD_URI(seg->data->uri);
             }
-        }
-        if(seg->data->title) {
-            latest = pgprintf(latest, "#%s:%.3f,%s\n", EXTINF, seg->data->duration, seg->data->title);
-        }else{
-            latest = pgprintf(latest, "#%s:%.3f,\n", EXTINF, seg->data->duration);
-        }
-        if(playlist->uri) {
-            const char *uri = find_relative_path(seg->data->uri, playlist->uri);
-            ADD_URI(uri);
-        }else{
-            ADD_URI(seg->data->uri);
         }
         seg = seg->next;
     }
diff --git a/test/parserPlaylistTests.c b/test/parserPlaylistTests.c
@@ -546,6 +546,156 @@ void media_playlist_parse_test2(void)
 
     hlsparse_media_playlist_term(&playlist);
 }
+
+void media_playlist_parse_test3(void)
+{
+    media_playlist_t playlist;
+    hlsparse_media_playlist_init(&playlist);
+
+    const char *src = "#EXTM3U\n\
+#EXT-X-VERSION:3\n\
+#EXT-X-TARGETDURATION:6\n\
+#EXT-X-MEDIA-SEQUENCE:1\n\
+#EXT-X-PLAYLIST-TYPE:VOD\n\
+#EXT-X-PROGRAM-DATE-TIME:2018-08-11T21:42:39.900Z\n\
+#EXT-X-ASSET-START:id=987,pop=\n\
+#EXT-X-KEY:METHOD=AES-128,URI=\"https://key-service.com/key?id=123\",IV=0x3CEA3CC17B919213B8E7CFB5D10D4CAE\n\
+#EXTINF:0.033,\n\
+ADAP/00060/1001_ADAP_00001.ts\n\
+#EXT-X-KEY:METHOD=NONE\n\
+#EXT-X-CUE-OUT:_params=\"abc=d&efg=MIDROLL&pop=1\"\n\
+#EXT-X-CUE-IN\n\
+#EXT-X-KEY:METHOD=AES-128,URI=\"https://key-service.com/key?id=124\",IV=0x3CEA3CC17B919213B8E7CFB5D10D4CAF\n\
+#EXTINF:4.972,\n\
+ADAP/00060/1001_ADAP_00002.ts\n\
+#EXTINF:5.005,\n\
+ADAP/00060/1001_ADAP_00003.ts\n\
+#EXTINF:4.605,\n\
+ADAP/00060/1001_ADAP_00004.ts\n\
+#EXT-X-KEY:METHOD=NONE\n\
+#EXT-X-CUE-OUT:_fw_params=\"abc=a&efg=POSTROLL&pop=4\"\n\
+#EXT-X-CUE-IN\n\
+#EXT-X-ENDLIST\n";
+
+    int res = hlsparse_media_playlist(src, strlen(src), &playlist);
+    CU_ASSERT_EQUAL(res, strlen(src))
+    CU_ASSERT_EQUAL(playlist.m3u, HLS_TRUE);
+    CU_ASSERT_EQUAL(playlist.target_duration, 6);
+    CU_ASSERT_EQUAL(playlist.media_sequence, 1);
+    CU_ASSERT_EQUAL(playlist.discontinuity_sequence, 0);
+    CU_ASSERT_EQUAL(playlist.playlist_type, PLAYLIST_TYPE_VOD);
+    CU_ASSERT_EQUAL(playlist.independent_segments, HLS_FALSE);
+    CU_ASSERT_EQUAL(playlist.iframes_only, HLS_FALSE);
+    CU_ASSERT_EQUAL(playlist.start.time_offset, 0.f);
+    CU_ASSERT_EQUAL(playlist.start.precise, HLS_FALSE);
+    CU_ASSERT_EQUAL(playlist.nb_segments, 5);
+    CU_ASSERT_EQUAL(playlist.nb_maps, 0);
+    CU_ASSERT_EQUAL(playlist.nb_dateranges, 0);
+    CU_ASSERT_EQUAL(playlist.end_list, HLS_TRUE);
+
+    segment_list_t *seg = &playlist.segments;
+    CU_ASSERT_NOT_EQUAL(seg->data, NULL);
+    assert_string_equal(seg->data->uri, "ADAP/00060/1001_ADAP_00001.ts", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->sequence_num, 0);
+    CU_ASSERT_EQUAL(seg->data->key_index, 0);
+    CU_ASSERT_EQUAL(seg->data->map_index, -1);
+    CU_ASSERT_EQUAL(seg->data->daterange_index, -1);
+    CU_ASSERT_EQUAL(seg->data->title, NULL);
+    CU_ASSERT_EQUAL(seg->data->discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt_discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt, 1534023759900);
+    CU_ASSERT_EQUAL(seg->data->pdt_end, 1534023759933);
+    CU_ASSERT_EQUAL(seg->data->duration, 0.033f);
+    CU_ASSERT_EQUAL(seg->data->byte_range.n, 0);
+    CU_ASSERT_EQUAL(seg->data->byte_range.o, 0);
+    CU_ASSERT_EQUAL(seg->data->byte_range.o, 0);
+    CU_ASSERT_NOT_EQUAL(seg->data->custom_tags.data, NULL);
+    assert_string_equal(seg->data->custom_tags.data, "EXT-X-ASSET-START:id=987,pop=", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.next, NULL);
+    
+    seg = seg->next;
+    CU_ASSERT_NOT_EQUAL(seg->data, NULL);
+    assert_string_equal(seg->data->uri, "ADAP/00060/1001_ADAP_00002.ts", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->sequence_num, 1);
+    CU_ASSERT_EQUAL(seg->data->key_index, 2);
+    CU_ASSERT_EQUAL(seg->data->map_index, -1);
+    CU_ASSERT_EQUAL(seg->data->daterange_index, -1);
+    CU_ASSERT_EQUAL(seg->data->title, NULL);
+    CU_ASSERT_EQUAL(seg->data->discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt_discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt, 1534023759933);
+    CU_ASSERT_EQUAL(seg->data->pdt_end, 1534023764905);
+    CU_ASSERT_EQUAL(seg->data->duration, 4.972f);
+    CU_ASSERT_EQUAL(seg->data->byte_range.n, 0);
+    CU_ASSERT_EQUAL(seg->data->byte_range.o, 0);
+    CU_ASSERT_NOT_EQUAL(seg->data->custom_tags.data, NULL);
+    assert_string_equal(seg->data->custom_tags.data, "EXT-X-CUE-OUT:_params=\"abc=d&efg=MIDROLL&pop=1\"", __func__, __LINE__);
+    CU_ASSERT_NOT_EQUAL(seg->data->custom_tags.next, NULL);
+    assert_string_equal(seg->data->custom_tags.next->data, "EXT-X-CUE-IN", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.next->next, NULL);
+
+    seg = seg->next;
+    CU_ASSERT_NOT_EQUAL(seg->data, NULL);
+    assert_string_equal(seg->data->uri, "ADAP/00060/1001_ADAP_00003.ts", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->sequence_num, 2);
+    CU_ASSERT_EQUAL(seg->data->key_index, 2);
+    CU_ASSERT_EQUAL(seg->data->map_index, -1);
+    CU_ASSERT_EQUAL(seg->data->daterange_index, -1);
+    CU_ASSERT_EQUAL(seg->data->title, NULL);
+    CU_ASSERT_EQUAL(seg->data->discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt_discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt, 1534023764905);
+    CU_ASSERT_EQUAL(seg->data->pdt_end, 1534023769910);
+    CU_ASSERT_EQUAL(seg->data->duration, 5.005f);
+    CU_ASSERT_EQUAL(seg->data->byte_range.n, 0);
+    CU_ASSERT_EQUAL(seg->data->byte_range.o, 0);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.data, NULL);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.next, NULL);
+
+    seg = seg->next;
+    CU_ASSERT_NOT_EQUAL(seg->data, NULL);
+    assert_string_equal(seg->data->uri, "ADAP/00060/1001_ADAP_00004.ts", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->sequence_num, 3);
+    CU_ASSERT_EQUAL(seg->data->key_index, 2);
+    CU_ASSERT_EQUAL(seg->data->map_index, -1);
+    CU_ASSERT_EQUAL(seg->data->daterange_index, -1);
+    CU_ASSERT_EQUAL(seg->data->title, NULL);
+    CU_ASSERT_EQUAL(seg->data->discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt_discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt, 1534023769910);
+    CU_ASSERT_EQUAL(seg->data->pdt_end, 1534023774515);
+    CU_ASSERT_EQUAL(seg->data->duration, 4.605f);
+    CU_ASSERT_EQUAL(seg->data->byte_range.n, 0);
+    CU_ASSERT_EQUAL(seg->data->byte_range.o, 0);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.data, NULL);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.next, NULL);
+
+    seg = seg->next;
+    CU_ASSERT_NOT_EQUAL(seg->data, NULL);
+    CU_ASSERT_EQUAL(seg->data->uri, NULL);
+    CU_ASSERT_EQUAL(seg->data->sequence_num, 4);
+    CU_ASSERT_EQUAL(seg->data->key_index, 3);
+    CU_ASSERT_EQUAL(seg->data->map_index, -1);
+    CU_ASSERT_EQUAL(seg->data->daterange_index, -1);
+    CU_ASSERT_EQUAL(seg->data->title, NULL);
+    CU_ASSERT_EQUAL(seg->data->discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt_discontinuity, HLS_FALSE);
+    CU_ASSERT_EQUAL(seg->data->pdt, 1534023774515);
+    CU_ASSERT_EQUAL(seg->data->pdt_end, 1534023774515);
+    CU_ASSERT_EQUAL(seg->data->duration, 0.f);
+    CU_ASSERT_EQUAL(seg->data->byte_range.n, 0);
+    CU_ASSERT_EQUAL(seg->data->byte_range.o, 0);
+    CU_ASSERT_NOT_EQUAL(seg->data->custom_tags.data, NULL);
+    assert_string_equal(seg->data->custom_tags.data, "EXT-X-CUE-OUT:_fw_params=\"abc=a&efg=POSTROLL&pop=4\"", __func__, __LINE__);
+    CU_ASSERT_NOT_EQUAL(seg->data->custom_tags.next, NULL);
+    assert_string_equal(seg->data->custom_tags.next->data, "EXT-X-CUE-IN", __func__, __LINE__);
+    CU_ASSERT_EQUAL(seg->data->custom_tags.next->next, NULL);
+
+    seg = seg->next;
+    CU_ASSERT_EQUAL(seg, NULL);
+
+    hlsparse_media_playlist_term(&playlist);
+}
 void setup(void)
 {
     hlsparse_global_init();
@@ -558,5 +708,6 @@ void setup(void)
     test("media_playlist_term", media_playlist_term_test);
     test("media_playlist_parse", media_playlist_parse_test);
     test("media_playlist_parse2", media_playlist_parse_test2);
+    test("media_playlist_parse3", media_playlist_parse_test3);
 }
 
diff --git a/test/writeMaster.c b/test/writeMaster.c
