Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Apple HTTP Live Streaming segmenter
  3.  * Copyright (c) 2012, Luca Barbato
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include "config.h"
  23. #include <float.h>
  24. #include <stdint.h>
  25. #if HAVE_UNISTD_H
  26. #include <unistd.h>
  27. #endif
  28.  
  29. #include "libavutil/avassert.h"
  30. #include "libavutil/mathematics.h"
  31. #include "libavutil/parseutils.h"
  32. #include "libavutil/avstring.h"
  33. #include "libavutil/opt.h"
  34. #include "libavutil/log.h"
  35. #include "libavutil/time_internal.h"
  36.  
  37. #include "avformat.h"
  38. #include "internal.h"
  39. #include "os_support.h"
  40.  
  41. #define KEYSIZE 16
  42. #define LINE_BUFFER_SIZE 1024
  43.  
  44. typedef struct HLSSegment {
  45.     char filename[1024];
  46.     char sub_filename[1024];
  47.     double duration; /* in seconds */
  48.     int64_t pos;
  49.     int64_t size;
  50.  
  51.     char key_uri[LINE_BUFFER_SIZE + 1];
  52.     char iv_string[KEYSIZE*2 + 1];
  53.  
  54.     struct HLSSegment *next;
  55. } HLSSegment;
  56.  
  57. typedef enum HLSFlags {
  58.     // Generate a single media file and use byte ranges in the playlist.
  59.     HLS_SINGLE_FILE = (1 << 0),
  60.     HLS_DELETE_SEGMENTS = (1 << 1),
  61.     HLS_ROUND_DURATIONS = (1 << 2),
  62.     HLS_DISCONT_START = (1 << 3),
  63.     HLS_OMIT_ENDLIST = (1 << 4),
  64. } HLSFlags;
  65.  
  66. typedef struct HLSContext {
  67.     const AVClass *class;  // Class for private options.
  68.     unsigned number;
  69.     int64_t sequence;
  70.     int64_t start_sequence;
  71.     AVOutputFormat *oformat;
  72.     AVOutputFormat *vtt_oformat;
  73.  
  74.     AVFormatContext *avf;
  75.     AVFormatContext *vtt_avf;
  76.  
  77.     float time;            // Set by a private option.
  78.     int max_nb_segments;   // Set by a private option.
  79.     int  wrap;             // Set by a private option.
  80.     uint32_t flags;        // enum HLSFlags
  81.     char *segment_filename;
  82.  
  83.     int use_localtime;      ///< flag to expand filename with localtime
  84.     int allowcache;
  85.     int64_t recording_time;
  86.     int has_video;
  87.     int has_subtitle;
  88.     int64_t start_pts;
  89.     int64_t end_pts;
  90.     double duration;      // last segment duration computed so far, in seconds
  91.     int64_t start_pos;    // last segment starting position
  92.     int64_t size;         // last segment size
  93.     int nb_entries;
  94.     int discontinuity_set;
  95.  
  96.     HLSSegment *segments;
  97.     HLSSegment *last_segment;
  98.     HLSSegment *old_segments;
  99.  
  100.     char *basename;
  101.     char *vtt_basename;
  102.     char *vtt_m3u8_name;
  103.     char *baseurl;
  104.     char *format_options_str;
  105.     char *vtt_format_options_str;
  106.     char *subtitle_filename;
  107.     AVDictionary *format_options;
  108.  
  109.     char *key_info_file;
  110.     char key_file[LINE_BUFFER_SIZE + 1];
  111.     char key_uri[LINE_BUFFER_SIZE + 1];
  112.     char key_string[KEYSIZE*2 + 1];
  113.     char iv_string[KEYSIZE*2 + 1];
  114.     AVDictionary *vtt_format_options;
  115.  
  116. } HLSContext;
  117.  
  118. static int hls_delete_old_segments(HLSContext *hls) {
  119.  
  120.     HLSSegment *segment, *previous_segment = NULL;
  121.     float playlist_duration = 0.0f;
  122.     int ret = 0, path_size, sub_path_size;
  123.     char *dirname = NULL, *p, *sub_path;
  124.     char *path = NULL;
  125.  
  126.     segment = hls->segments;
  127.     while (segment) {
  128.         playlist_duration += segment->duration;
  129.         segment = segment->next;
  130.     }
  131.  
  132.     segment = hls->old_segments;
  133.     while (segment) {
  134.         playlist_duration -= segment->duration;
  135.         previous_segment = segment;
  136.         segment = previous_segment->next;
  137.         if (playlist_duration <= -previous_segment->duration) {
  138.             previous_segment->next = NULL;
  139.             break;
  140.         }
  141.     }
  142.  
  143.     if (segment) {
  144.         if (hls->segment_filename) {
  145.             dirname = av_strdup(hls->segment_filename);
  146.         } else {
  147.             dirname = av_strdup(hls->avf->filename);
  148.         }
  149.         if (!dirname) {
  150.             ret = AVERROR(ENOMEM);
  151.             goto fail;
  152.         }
  153.         p = (char *)av_basename(dirname);
  154.         *p = '\0';
  155.     }
  156.  
  157.     while (segment) {
  158.         av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
  159.                                   segment->filename);
  160.         path_size = strlen(dirname) + strlen(segment->filename) + 1;
  161.         path = av_malloc(path_size);
  162.         if (!path) {
  163.             ret = AVERROR(ENOMEM);
  164.             goto fail;
  165.         }
  166.  
  167.         av_strlcpy(path, dirname, path_size);
  168.         av_strlcat(path, segment->filename, path_size);
  169.         if (unlink(path) < 0) {
  170.             av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
  171.                                      path, strerror(errno));
  172.         }
  173.  
  174.         if (segment->sub_filename[0] != '\0') {
  175.             sub_path_size = strlen(dirname) + strlen(segment->sub_filename) + 1;
  176.             sub_path = av_malloc(sub_path_size);
  177.             if (!sub_path) {
  178.                 ret = AVERROR(ENOMEM);
  179.                 goto fail;
  180.             }
  181.  
  182.             av_strlcpy(sub_path, dirname, sub_path_size);
  183.             av_strlcat(sub_path, segment->sub_filename, sub_path_size);
  184.             if (unlink(sub_path) < 0) {
  185.                 av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
  186.                                          sub_path, strerror(errno));
  187.             }
  188.             av_free(sub_path);
  189.         }
  190.         av_freep(&path);
  191.         previous_segment = segment;
  192.         segment = previous_segment->next;
  193.         av_free(previous_segment);
  194.     }
  195.  
  196. fail:
  197.     av_free(path);
  198.     av_free(dirname);
  199.  
  200.     return ret;
  201. }
  202.  
  203. static int hls_encryption_start(AVFormatContext *s)
  204. {
  205.     HLSContext *hls = s->priv_data;
  206.     int ret;
  207.     AVIOContext *pb;
  208.     uint8_t key[KEYSIZE];
  209.  
  210.     if ((ret = avio_open2(&pb, hls->key_info_file, AVIO_FLAG_READ,
  211.                            &s->interrupt_callback, NULL)) < 0) {
  212.         av_log(hls, AV_LOG_ERROR,
  213.                 "error opening key info file %s\n", hls->key_info_file);
  214.         return ret;
  215.     }
  216.  
  217.     ff_get_line(pb, hls->key_uri, sizeof(hls->key_uri));
  218.     hls->key_uri[strcspn(hls->key_uri, "\r\n")] = '\0';
  219.  
  220.     ff_get_line(pb, hls->key_file, sizeof(hls->key_file));
  221.     hls->key_file[strcspn(hls->key_file, "\r\n")] = '\0';
  222.  
  223.     ff_get_line(pb, hls->iv_string, sizeof(hls->iv_string));
  224.     hls->iv_string[strcspn(hls->iv_string, "\r\n")] = '\0';
  225.  
  226.     avio_close(pb);
  227.  
  228.     if (!*hls->key_uri) {
  229.         av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
  230.         return AVERROR(EINVAL);
  231.     }
  232.  
  233.     if (!*hls->key_file) {
  234.         av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
  235.         return AVERROR(EINVAL);
  236.     }
  237.  
  238.     if ((ret = avio_open2(&pb, hls->key_file, AVIO_FLAG_READ,
  239.                            &s->interrupt_callback, NULL)) < 0) {
  240.         av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file);
  241.         return ret;
  242.     }
  243.  
  244.     ret = avio_read(pb, key, sizeof(key));
  245.     avio_close(pb);
  246.     if (ret != sizeof(key)) {
  247.         av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", hls->key_file);
  248.         if (ret >= 0 || ret == AVERROR_EOF)
  249.             ret = AVERROR(EINVAL);
  250.         return ret;
  251.     }
  252.     ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
  253.  
  254.     return 0;
  255. }
  256.  
  257. static int hls_mux_init(AVFormatContext *s)
  258. {
  259.     HLSContext *hls = s->priv_data;
  260.     AVFormatContext *oc;
  261.     AVFormatContext *vtt_oc = NULL;
  262.     int i, ret;
  263.  
  264.     ret = avformat_alloc_output_context2(&hls->avf, hls->oformat, NULL, NULL);
  265.     if (ret < 0)
  266.         return ret;
  267.     oc = hls->avf;
  268.  
  269.     oc->oformat            = hls->oformat;
  270.     oc->interrupt_callback = s->interrupt_callback;
  271.     oc->max_delay          = s->max_delay;
  272.     av_dict_copy(&oc->metadata, s->metadata, 0);
  273.  
  274.     if(hls->vtt_oformat) {
  275.         ret = avformat_alloc_output_context2(&hls->vtt_avf, hls->vtt_oformat, NULL, NULL);
  276.         if (ret < 0)
  277.             return ret;
  278.         vtt_oc          = hls->vtt_avf;
  279.         vtt_oc->oformat = hls->vtt_oformat;
  280.         av_dict_copy(&vtt_oc->metadata, s->metadata, 0);
  281.     }
  282.  
  283.     for (i = 0; i < s->nb_streams; i++) {
  284.         AVStream *st;
  285.         AVFormatContext *loc;
  286.         if (s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
  287.             loc = vtt_oc;
  288.         else
  289.             loc = oc;
  290.  
  291.         if (!(st = avformat_new_stream(loc, NULL)))
  292.             return AVERROR(ENOMEM);
  293.         avcodec_copy_context(st->codec, s->streams[i]->codec);
  294.         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
  295.         st->time_base = s->streams[i]->time_base;
  296.     }
  297.     hls->start_pos = 0;
  298.  
  299.     return 0;
  300. }
  301.  
  302. /* Create a new segment and append it to the segment list */
  303. static int hls_append_segment(HLSContext *hls, double duration, int64_t pos,
  304.                               int64_t size)
  305. {
  306.     HLSSegment *en = av_malloc(sizeof(*en));
  307.     int ret;
  308.  
  309.     if (!en)
  310.         return AVERROR(ENOMEM);
  311.  
  312.     av_strlcpy(en->filename, av_basename(hls->avf->filename), sizeof(en->filename));
  313.  
  314.     if(hls->has_subtitle)
  315.         av_strlcpy(en->sub_filename, av_basename(hls->vtt_avf->filename), sizeof(en->sub_filename));
  316.     else
  317.         en->sub_filename[0] = '\0';
  318.  
  319.     en->duration = duration;
  320.     en->pos      = pos;
  321.     en->size     = size;
  322.     en->next     = NULL;
  323.  
  324.     if (hls->key_info_file) {
  325.         av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri));
  326.         av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string));
  327.     }
  328.  
  329.     if (!hls->segments)
  330.         hls->segments = en;
  331.     else
  332.         hls->last_segment->next = en;
  333.  
  334.     hls->last_segment = en;
  335.  
  336.     if (hls->max_nb_segments && hls->nb_entries >= hls->max_nb_segments) {
  337.         en = hls->segments;
  338.         hls->segments = en->next;
  339.         if (en && hls->flags & HLS_DELETE_SEGMENTS &&
  340.                 !(hls->flags & HLS_SINGLE_FILE || hls->wrap)) {
  341.             en->next = hls->old_segments;
  342.             hls->old_segments = en;
  343.             if ((ret = hls_delete_old_segments(hls)) < 0)
  344.                 return ret;
  345.         } else
  346.             av_free(en);
  347.     } else
  348.         hls->nb_entries++;
  349.  
  350.     hls->sequence++;
  351.  
  352.     return 0;
  353. }
  354.  
  355. static void hls_free_segments(HLSSegment *p)
  356. {
  357.     HLSSegment *en;
  358.  
  359.     while(p) {
  360.         en = p;
  361.         p = p->next;
  362.         av_free(en);
  363.     }
  364. }
  365.  
  366. static int hls_window(AVFormatContext *s, int last)
  367. {
  368.     HLSContext *hls = s->priv_data;
  369.     HLSSegment *en;
  370.     int target_duration = 0;
  371.     int ret = 0;
  372.     AVIOContext *out = NULL;
  373.     AVIOContext *sub_out = NULL;
  374.     char temp_filename[1024];
  375.     int64_t sequence = FFMAX(hls->start_sequence, hls->sequence - hls->nb_entries);
  376.     int version = hls->flags & HLS_SINGLE_FILE ? 4 : 3;
  377.     const char *proto = avio_find_protocol_name(s->filename);
  378.     int use_rename = proto && !strcmp(proto, "file");
  379.     static unsigned warned_non_file;
  380.     char *key_uri = NULL;
  381.     char *iv_string = NULL;
  382.  
  383.     if (!use_rename && !warned_non_file++)
  384.         av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporarly partial files\n");
  385.  
  386.     snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->filename);
  387.     if ((ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE,
  388.                           &s->interrupt_callback, NULL)) < 0)
  389.         goto fail;
  390.  
  391.     for (en = hls->segments; en; en = en->next) {
  392.         if (target_duration < en->duration)
  393.             target_duration = ceil(en->duration);
  394.     }
  395.  
  396.     hls->discontinuity_set = 0;
  397.     avio_printf(out, "#EXTM3U\n");
  398.     avio_printf(out, "#EXT-X-VERSION:%d\n", version);
  399.     if (hls->allowcache == 0 || hls->allowcache == 1) {
  400.         avio_printf(out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
  401.     }
  402.     avio_printf(out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
  403.     avio_printf(out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
  404.  
  405.     av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
  406.            sequence);
  407.     if((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && hls->discontinuity_set==0 ){
  408.         avio_printf(out, "#EXT-X-DISCONTINUITY\n");
  409.         hls->discontinuity_set = 1;
  410.     }
  411.     for (en = hls->segments; en; en = en->next) {
  412.         if (hls->key_info_file && (!key_uri || strcmp(en->key_uri, key_uri) ||
  413.                                     av_strcasecmp(en->iv_string, iv_string))) {
  414.             avio_printf(out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
  415.             if (*en->iv_string)
  416.                 avio_printf(out, ",IV=0x%s", en->iv_string);
  417.             avio_printf(out, "\n");
  418.             key_uri = en->key_uri;
  419.             iv_string = en->iv_string;
  420.         }
  421.  
  422.         if (hls->flags & HLS_ROUND_DURATIONS)
  423.             avio_printf(out, "#EXTINF:%d,\n",  (int)round(en->duration));
  424.         else
  425.             avio_printf(out, "#EXTINF:%f,\n", en->duration);
  426.         if (hls->flags & HLS_SINGLE_FILE)
  427.              avio_printf(out, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n",
  428.                          en->size, en->pos);
  429.         if (hls->baseurl)
  430.             avio_printf(out, "%s", hls->baseurl);
  431.         avio_printf(out, "%s\n", en->filename);
  432.     }
  433.  
  434.     if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
  435.         avio_printf(out, "#EXT-X-ENDLIST\n");
  436.  
  437.     if( hls->vtt_m3u8_name ) {
  438.         if ((ret = avio_open2(&sub_out, hls->vtt_m3u8_name, AVIO_FLAG_WRITE,
  439.                           &s->interrupt_callback, NULL)) < 0)
  440.             goto fail;
  441.         avio_printf(sub_out, "#EXTM3U\n");
  442.         avio_printf(sub_out, "#EXT-X-VERSION:%d\n", version);
  443.         if (hls->allowcache == 0 || hls->allowcache == 1) {
  444.             avio_printf(sub_out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
  445.         }
  446.         avio_printf(sub_out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
  447.         avio_printf(sub_out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
  448.  
  449.         av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
  450.                sequence);
  451.  
  452.         for (en = hls->segments; en; en = en->next) {
  453.             avio_printf(sub_out, "#EXTINF:%f,\n", en->duration);
  454.             if (hls->flags & HLS_SINGLE_FILE)
  455.                  avio_printf(sub_out, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n",
  456.                          en->size, en->pos);
  457.             if (hls->baseurl)
  458.                 avio_printf(sub_out, "%s", hls->baseurl);
  459.             avio_printf(sub_out, "%s\n", en->sub_filename);
  460.         }
  461.  
  462.         if (last)
  463.             avio_printf(sub_out, "#EXT-X-ENDLIST\n");
  464.  
  465.     }
  466.  
  467. fail:
  468.     avio_closep(&out);
  469.     avio_closep(&sub_out);
  470.     if (ret >= 0 && use_rename)
  471.         ff_rename(temp_filename, s->filename, s);
  472.     return ret;
  473. }
  474.  
  475. static int hls_start(AVFormatContext *s)
  476. {
  477.     HLSContext *c = s->priv_data;
  478.     AVFormatContext *oc = c->avf;
  479.     AVFormatContext *vtt_oc = c->vtt_avf;
  480.     AVDictionary *options = NULL;
  481.     char *filename, iv_string[KEYSIZE*2 + 1];
  482.     int err = 0;
  483.  
  484.     if (c->flags & HLS_SINGLE_FILE) {
  485.         av_strlcpy(oc->filename, c->basename,
  486.                    sizeof(oc->filename));
  487.         if (c->vtt_basename)
  488.             av_strlcpy(vtt_oc->filename, c->vtt_basename,
  489.                   sizeof(vtt_oc->filename));
  490.     } else {
  491.         if (c->use_localtime) {
  492.             time_t now0;
  493.             struct tm *tm, tmpbuf;
  494.             time(&now0);
  495.             tm = localtime_r(&now0, &tmpbuf);
  496.             if (!strftime(oc->filename, sizeof(oc->filename), c->basename, tm)) {
  497.                 av_log(oc, AV_LOG_ERROR, "Could not get segment filename with use_localtime\n");
  498.                 return AVERROR(EINVAL);
  499.             }
  500.        } else if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
  501.                                   c->basename, c->wrap ? c->sequence % c->wrap : c->sequence) < 0) {
  502.             av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try use -use_localtime 1 with it\n", c->basename);
  503.             return AVERROR(EINVAL);
  504.         }
  505.         if( c->vtt_basename) {
  506.             if (av_get_frame_filename(vtt_oc->filename, sizeof(vtt_oc->filename),
  507.                               c->vtt_basename, c->wrap ? c->sequence % c->wrap : c->sequence) < 0) {
  508.                 av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", c->vtt_basename);
  509.                 return AVERROR(EINVAL);
  510.             }
  511.        }
  512.     }
  513.     c->number++;
  514.  
  515.     if (c->key_info_file) {
  516.         if ((err = hls_encryption_start(s)) < 0)
  517.             return err;
  518.         if ((err = av_dict_set(&options, "encryption_key", c->key_string, 0))
  519.                 < 0)
  520.             return err;
  521.         err = av_strlcpy(iv_string, c->iv_string, sizeof(iv_string));
  522.         if (!err)
  523.             snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, c->sequence);
  524.         if ((err = av_dict_set(&options, "encryption_iv", iv_string, 0)) < 0)
  525.             return err;
  526.  
  527.         filename = av_asprintf("crypto:%s", oc->filename);
  528.         if (!filename) {
  529.             av_dict_free(&options);
  530.             return AVERROR(ENOMEM);
  531.         }
  532.         err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
  533.                          &s->interrupt_callback, &options);
  534.         av_free(filename);
  535.         av_dict_free(&options);
  536.         if (err < 0)
  537.             return err;
  538.     } else
  539.         if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
  540.                           &s->interrupt_callback, NULL)) < 0)
  541.             return err;
  542.     if (c->vtt_basename) {
  543.         if ((err = avio_open2(&vtt_oc->pb, vtt_oc->filename, AVIO_FLAG_WRITE,
  544.                          &s->interrupt_callback, NULL)) < 0)
  545.             return err;
  546.     }
  547.  
  548.     if (oc->oformat->priv_class && oc->priv_data)
  549.         av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
  550.  
  551.     if (c->vtt_basename) {
  552.         err = avformat_write_header(vtt_oc,NULL);
  553.         if (err < 0)
  554.             return err;
  555.     }
  556.  
  557.     return 0;
  558. }
  559.  
  560. static int hls_write_header(AVFormatContext *s)
  561. {
  562.     HLSContext *hls = s->priv_data;
  563.     int ret, i;
  564.     char *p;
  565.     const char *pattern = "%d.ts";
  566.     const char *pattern_localtime_fmt = "-%s.ts";
  567.     const char *vtt_pattern = "%d.vtt";
  568.     AVDictionary *options = NULL;
  569.     int basename_size;
  570.     int vtt_basename_size;
  571.  
  572.     hls->sequence       = hls->start_sequence;
  573.     hls->recording_time = hls->time * AV_TIME_BASE;
  574.     hls->start_pts      = AV_NOPTS_VALUE;
  575.  
  576.     if (hls->format_options_str) {
  577.         ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
  578.         if (ret < 0) {
  579.             av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n", hls->format_options_str);
  580.             goto fail;
  581.         }
  582.     }
  583.  
  584.     for (i = 0; i < s->nb_streams; i++) {
  585.         hls->has_video +=
  586.             s->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO;
  587.         hls->has_subtitle +=
  588.             s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE;
  589.     }
  590.  
  591.     if (hls->has_video > 1)
  592.         av_log(s, AV_LOG_WARNING,
  593.                "More than a single video stream present, "
  594.                "expect issues decoding it.\n");
  595.  
  596.     hls->oformat = av_guess_format("mpegts", NULL, NULL);
  597.  
  598.     if (!hls->oformat) {
  599.         ret = AVERROR_MUXER_NOT_FOUND;
  600.         goto fail;
  601.     }
  602.  
  603.     if(hls->has_subtitle) {
  604.         hls->vtt_oformat = av_guess_format("webvtt", NULL, NULL);
  605.         if (!hls->oformat) {
  606.             ret = AVERROR_MUXER_NOT_FOUND;
  607.             goto fail;
  608.         }
  609.     }
  610.  
  611.     if (hls->segment_filename) {
  612.         hls->basename = av_strdup(hls->segment_filename);
  613.         if (!hls->basename) {
  614.             ret = AVERROR(ENOMEM);
  615.             goto fail;
  616.         }
  617.     } else {
  618.         if (hls->flags & HLS_SINGLE_FILE)
  619.             pattern = ".ts";
  620.  
  621.         if (hls->use_localtime) {
  622.             basename_size = strlen(s->filename) + strlen(pattern_localtime_fmt) + 1;
  623.         } else {
  624.             basename_size = strlen(s->filename) + strlen(pattern) + 1;
  625.         }
  626.         hls->basename = av_malloc(basename_size);
  627.         if (!hls->basename) {
  628.             ret = AVERROR(ENOMEM);
  629.             goto fail;
  630.         }
  631.  
  632.         av_strlcpy(hls->basename, s->filename, basename_size);
  633.  
  634.         p = strrchr(hls->basename, '.');
  635.         if (p)
  636.             *p = '\0';
  637.         if (hls->use_localtime) {
  638.             av_strlcat(hls->basename, pattern_localtime_fmt, basename_size);
  639.         } else {
  640.             av_strlcat(hls->basename, pattern, basename_size);
  641.         }
  642.     }
  643.  
  644.     if(hls->has_subtitle) {
  645.  
  646.         if (hls->flags & HLS_SINGLE_FILE)
  647.             vtt_pattern = ".vtt";
  648.         vtt_basename_size = strlen(s->filename) + strlen(vtt_pattern) + 1;
  649.         hls->vtt_basename = av_malloc(vtt_basename_size);
  650.         if (!hls->vtt_basename) {
  651.             ret = AVERROR(ENOMEM);
  652.             goto fail;
  653.         }
  654.         hls->vtt_m3u8_name = av_malloc(vtt_basename_size);
  655.         if (!hls->vtt_m3u8_name ) {
  656.             ret = AVERROR(ENOMEM);
  657.             goto fail;
  658.         }
  659.         av_strlcpy(hls->vtt_basename, s->filename, vtt_basename_size);
  660.         p = strrchr(hls->vtt_basename, '.');
  661.         if (p)
  662.             *p = '\0';
  663.  
  664.         if( hls->subtitle_filename ) {
  665.             strcpy(hls->vtt_m3u8_name, hls->subtitle_filename);
  666.         } else {
  667.             strcpy(hls->vtt_m3u8_name, hls->vtt_basename);
  668.             av_strlcat(hls->vtt_m3u8_name, "_vtt.m3u8", vtt_basename_size);
  669.         }
  670.         av_strlcat(hls->vtt_basename, vtt_pattern, vtt_basename_size);
  671.     }
  672.  
  673.     if ((ret = hls_mux_init(s)) < 0)
  674.         goto fail;
  675.  
  676.     if ((ret = hls_start(s)) < 0)
  677.         goto fail;
  678.  
  679.     av_dict_copy(&options, hls->format_options, 0);
  680.     ret = avformat_write_header(hls->avf, &options);
  681.     if (av_dict_count(options)) {
  682.         av_log(s, AV_LOG_ERROR, "Some of provided format options in '%s' are not recognized\n", hls->format_options_str);
  683.         ret = AVERROR(EINVAL);
  684.         goto fail;
  685.     }
  686.     //av_assert0(s->nb_streams == hls->avf->nb_streams);
  687.     for (i = 0; i < s->nb_streams; i++) {
  688.         AVStream *inner_st;
  689.         AVStream *outer_st = s->streams[i];
  690.         if (outer_st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
  691.             inner_st = hls->avf->streams[i];
  692.         else if (hls->vtt_avf)
  693.             inner_st = hls->vtt_avf->streams[0];
  694.         else {
  695.             /* We have a subtitle stream, when the user does not want one */
  696.             inner_st = NULL;
  697.             continue;
  698.         }
  699.         avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
  700.     }
  701. fail:
  702.  
  703.     av_dict_free(&options);
  704.     if (ret < 0) {
  705.         av_freep(&hls->basename);
  706.         av_freep(&hls->vtt_basename);
  707.         if (hls->avf)
  708.             avformat_free_context(hls->avf);
  709.         if (hls->vtt_avf)
  710.             avformat_free_context(hls->vtt_avf);
  711.  
  712.     }
  713.     return ret;
  714. }
  715.  
  716. static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
  717. {
  718.     HLSContext *hls = s->priv_data;
  719.     AVFormatContext *oc = NULL;
  720.     AVStream *st = s->streams[pkt->stream_index];
  721.     int64_t end_pts = hls->recording_time * hls->number;
  722.     int is_ref_pkt = 1;
  723.     int ret, can_split = 1;
  724.     int stream_index = 0;
  725.  
  726.     if( st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
  727.         oc = hls->vtt_avf;
  728.         stream_index = 0;
  729.     } else {
  730.         oc = hls->avf;
  731.         stream_index = pkt->stream_index;
  732.     }
  733.     if (hls->start_pts == AV_NOPTS_VALUE) {
  734.         hls->start_pts = pkt->pts;
  735.         hls->end_pts   = pkt->pts;
  736.     }
  737.  
  738.     if (hls->has_video) {
  739.         can_split = st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
  740.                     pkt->flags & AV_PKT_FLAG_KEY;
  741.         is_ref_pkt = st->codec->codec_type == AVMEDIA_TYPE_VIDEO;
  742.     }
  743.     if (pkt->pts == AV_NOPTS_VALUE)
  744.         is_ref_pkt = can_split = 0;
  745.  
  746.     if (is_ref_pkt)
  747.         hls->duration = (double)(pkt->pts - hls->end_pts)
  748.                                    * st->time_base.num / st->time_base.den;
  749.  
  750.     if (can_split && av_compare_ts(pkt->pts - hls->start_pts, st->time_base,
  751.                                    end_pts, AV_TIME_BASE_Q) >= 0) {
  752.         int64_t new_start_pos;
  753.         av_write_frame(oc, NULL); /* Flush any buffered data */
  754.  
  755.         new_start_pos = avio_tell(hls->avf->pb);
  756.         hls->size = new_start_pos - hls->start_pos;
  757.         ret = hls_append_segment(hls, hls->duration, hls->start_pos, hls->size);
  758.         hls->start_pos = new_start_pos;
  759.         if (ret < 0)
  760.             return ret;
  761.  
  762.         hls->end_pts = pkt->pts;
  763.         hls->duration = 0;
  764.  
  765.         if (hls->flags & HLS_SINGLE_FILE) {
  766.             if (hls->avf->oformat->priv_class && hls->avf->priv_data)
  767.                 av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
  768.             hls->number++;
  769.         } else {
  770.             avio_closep(&oc->pb);
  771.             if (hls->vtt_avf)
  772.                 avio_close(hls->vtt_avf->pb);
  773.  
  774.             ret = hls_start(s);
  775.         }
  776.  
  777.         if (ret < 0)
  778.             return ret;
  779.  
  780.         if( st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE )
  781.             oc = hls->vtt_avf;
  782.         else
  783.         oc = hls->avf;
  784.  
  785.         if ((ret = hls_window(s, 0)) < 0)
  786.             return ret;
  787.     }
  788.  
  789.     ret = ff_write_chained(oc, stream_index, pkt, s, 0);
  790.  
  791.     return ret;
  792. }
  793.  
  794. static int hls_write_trailer(struct AVFormatContext *s)
  795. {
  796.     HLSContext *hls = s->priv_data;
  797.     AVFormatContext *oc = hls->avf;
  798.     AVFormatContext *vtt_oc = hls->vtt_avf;
  799.  
  800.     av_write_trailer(oc);
  801.     if (oc->pb) {
  802.         hls->size = avio_tell(hls->avf->pb) - hls->start_pos;
  803.         avio_closep(&oc->pb);
  804.         hls_append_segment(hls, hls->duration, hls->start_pos, hls->size);
  805.     }
  806.  
  807.     if (vtt_oc) {
  808.         if (vtt_oc->pb)
  809.             av_write_trailer(vtt_oc);
  810.         hls->size = avio_tell(hls->vtt_avf->pb) - hls->start_pos;
  811.         avio_closep(&vtt_oc->pb);
  812.     }
  813.     av_freep(&hls->basename);
  814.     avformat_free_context(oc);
  815.  
  816.     if (vtt_oc) {
  817.         av_freep(&hls->vtt_basename);
  818.         av_freep(&hls->vtt_m3u8_name);
  819.         avformat_free_context(vtt_oc);
  820.     }
  821.  
  822.     hls->avf = NULL;
  823.     hls_window(s, 1);
  824.  
  825.     hls_free_segments(hls->segments);
  826.     hls_free_segments(hls->old_segments);
  827.     return 0;
  828. }
  829.  
  830. #define OFFSET(x) offsetof(HLSContext, x)
  831. #define E AV_OPT_FLAG_ENCODING_PARAM
  832. static const AVOption options[] = {
  833.     {"start_number",  "set first number in the sequence",        OFFSET(start_sequence),AV_OPT_TYPE_INT64,  {.i64 = 0},     0, INT64_MAX, E},
  834.     {"hls_time",      "set segment length in seconds",           OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E},
  835.     {"hls_list_size", "set maximum number of playlist entries",  OFFSET(max_nb_segments),    AV_OPT_TYPE_INT,    {.i64 = 5},     0, INT_MAX, E},
  836.     {"hls_ts_options","set hls mpegts list of options for the container format used for hls", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
  837.     {"hls_vtt_options","set hls vtt list of options for the container format used for hls", OFFSET(vtt_format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
  838.     {"hls_wrap",      "set number after which the index wraps",  OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E},
  839.     {"hls_allow_cache", "explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments", OFFSET(allowcache), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, E},
  840.     {"hls_base_url",  "url to prepend to each playlist entry",   OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E},
  841.     {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename),   AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
  842.     {"hls_key_info_file",    "file with key URI and key file path", OFFSET(key_info_file),      AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
  843.     {"hls_subtitle_path",     "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
  844.     {"hls_flags",     "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
  845.     {"single_file",   "generate a single media file indexed with byte ranges", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SINGLE_FILE }, 0, UINT_MAX,   E, "flags"},
  846.     {"delete_segments", "delete segment files that are no longer part of the playlist", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DELETE_SEGMENTS }, 0, UINT_MAX,   E, "flags"},
  847.     {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX,   E, "flags"},
  848.     {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX,   E, "flags"},
  849.     {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX,   E, "flags"},
  850.     { "use_localtime",          "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, E },
  851.  
  852.     { NULL },
  853. };
  854.  
  855. static const AVClass hls_class = {
  856.     .class_name = "hls muxer",
  857.     .item_name  = av_default_item_name,
  858.     .option     = options,
  859.     .version    = LIBAVUTIL_VERSION_INT,
  860. };
  861.  
  862.  
  863. AVOutputFormat ff_hls_muxer = {
  864.     .name           = "hls",
  865.     .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
  866.     .extensions     = "m3u8",
  867.     .priv_data_size = sizeof(HLSContext),
  868.     .audio_codec    = AV_CODEC_ID_AAC,
  869.     .video_codec    = AV_CODEC_ID_H264,
  870.     .subtitle_codec = AV_CODEC_ID_WEBVTT,
  871.     .flags          = AVFMT_NOFILE | AVFMT_ALLOW_FLUSH,
  872.     .write_header   = hls_write_header,
  873.     .write_packet   = hls_write_packet,
  874.     .write_trailer  = hls_write_trailer,
  875.     .priv_class     = &hls_class,
  876. };
  877.