avformat/hlsenc: added segment filename option
[ffmpeg.git] / libavformat / hlsenc.c
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 <float.h>
23 #include <stdint.h>
24
25 #include "libavutil/avassert.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/parseutils.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/log.h"
31
32 #include "avformat.h"
33 #include "internal.h"
34
35 typedef struct HLSSegment {
36     char filename[1024];
37     double duration; /* in seconds */
38     int64_t pos;
39     int64_t size;
40
41     struct HLSSegment *next;
42 } HLSSegment;
43
44 typedef enum HLSFlags {
45     // Generate a single media file and use byte ranges in the playlist.
46     HLS_SINGLE_FILE = (1 << 0),
47 } HLSFlags;
48
49 typedef struct HLSContext {
50     const AVClass *class;  // Class for private options.
51     unsigned number;
52     int64_t sequence;
53     int64_t start_sequence;
54     AVOutputFormat *oformat;
55
56     AVFormatContext *avf;
57
58     float time;            // Set by a private option.
59     int max_nb_segments;   // Set by a private option.
60     int  wrap;             // Set by a private option.
61     uint32_t flags;        // enum HLSFlags
62     char *segment_filename;
63
64     int allowcache;
65     int64_t recording_time;
66     int has_video;
67     int64_t start_pts;
68     int64_t end_pts;
69     double duration;      // last segment duration computed so far, in seconds
70     int64_t start_pos;    // last segment starting position
71     int64_t size;         // last segment size
72     int nb_entries;
73
74     HLSSegment *segments;
75     HLSSegment *last_segment;
76
77     char *basename;
78     char *baseurl;
79     char *format_options_str;
80     AVDictionary *format_options;
81
82     AVIOContext *pb;
83 } HLSContext;
84
85 static int hls_mux_init(AVFormatContext *s)
86 {
87     HLSContext *hls = s->priv_data;
88     AVFormatContext *oc;
89     int i, ret;
90
91     ret = avformat_alloc_output_context2(&hls->avf, hls->oformat, NULL, NULL);
92     if (ret < 0)
93         return ret;
94     oc = hls->avf;
95
96     oc->oformat            = hls->oformat;
97     oc->interrupt_callback = s->interrupt_callback;
98     oc->max_delay          = s->max_delay;
99     av_dict_copy(&oc->metadata, s->metadata, 0);
100
101     for (i = 0; i < s->nb_streams; i++) {
102         AVStream *st;
103         if (!(st = avformat_new_stream(oc, NULL)))
104             return AVERROR(ENOMEM);
105         avcodec_copy_context(st->codec, s->streams[i]->codec);
106         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
107         st->time_base = s->streams[i]->time_base;
108     }
109     hls->start_pos = 0;
110
111     return 0;
112 }
113
114 /* Create a new segment and append it to the segment list */
115 static int hls_append_segment(HLSContext *hls, double duration, int64_t pos,
116                               int64_t size)
117 {
118     HLSSegment *en = av_malloc(sizeof(*en));
119
120     if (!en)
121         return AVERROR(ENOMEM);
122
123     av_strlcpy(en->filename, av_basename(hls->avf->filename), sizeof(en->filename));
124
125     en->duration = duration;
126     en->pos      = pos;
127     en->size     = size;
128     en->next     = NULL;
129
130     if (!hls->segments)
131         hls->segments = en;
132     else
133         hls->last_segment->next = en;
134
135     hls->last_segment = en;
136
137     if (hls->max_nb_segments && hls->nb_entries >= hls->max_nb_segments) {
138         en = hls->segments;
139         hls->segments = en->next;
140         av_free(en);
141     } else
142         hls->nb_entries++;
143
144     hls->sequence++;
145
146     return 0;
147 }
148
149 static void hls_free_segments(HLSContext *hls)
150 {
151     HLSSegment *p = hls->segments, *en;
152
153     while(p) {
154         en = p;
155         p = p->next;
156         av_free(en);
157     }
158 }
159
160 static int hls_window(AVFormatContext *s, int last)
161 {
162     HLSContext *hls = s->priv_data;
163     HLSSegment *en;
164     int target_duration = 0;
165     int ret = 0;
166     int64_t sequence = FFMAX(hls->start_sequence, hls->sequence - hls->nb_entries);
167     int version = hls->flags & HLS_SINGLE_FILE ? 4 : 3;
168
169     if ((ret = avio_open2(&hls->pb, s->filename, AVIO_FLAG_WRITE,
170                           &s->interrupt_callback, NULL)) < 0)
171         goto fail;
172
173     for (en = hls->segments; en; en = en->next) {
174         if (target_duration < en->duration)
175             target_duration = ceil(en->duration);
176     }
177
178     avio_printf(hls->pb, "#EXTM3U\n");
179     avio_printf(hls->pb, "#EXT-X-VERSION:%d\n", version);
180     if (hls->allowcache == 0 || hls->allowcache == 1) {
181         avio_printf(hls->pb, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
182     }
183     avio_printf(hls->pb, "#EXT-X-TARGETDURATION:%d\n", target_duration);
184     avio_printf(hls->pb, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
185
186     av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
187            sequence);
188
189     for (en = hls->segments; en; en = en->next) {
190         avio_printf(hls->pb, "#EXTINF:%f,\n", en->duration);
191         if (hls->flags & HLS_SINGLE_FILE)
192              avio_printf(hls->pb, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n",
193                          en->size, en->pos);
194         if (hls->baseurl)
195             avio_printf(hls->pb, "%s", hls->baseurl);
196         avio_printf(hls->pb, "%s\n", en->filename);
197     }
198
199     if (last)
200         avio_printf(hls->pb, "#EXT-X-ENDLIST\n");
201
202 fail:
203     avio_closep(&hls->pb);
204     return ret;
205 }
206
207 static int hls_start(AVFormatContext *s)
208 {
209     HLSContext *c = s->priv_data;
210     AVFormatContext *oc = c->avf;
211     int err = 0;
212
213     if (c->flags & HLS_SINGLE_FILE)
214         av_strlcpy(oc->filename, c->basename,
215                    sizeof(oc->filename));
216     else
217         if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
218                                   c->basename, c->wrap ? c->sequence % c->wrap : c->sequence) < 0) {
219             av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", c->basename);
220             return AVERROR(EINVAL);
221         }
222     c->number++;
223
224     if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
225                           &s->interrupt_callback, NULL)) < 0)
226         return err;
227
228     if (oc->oformat->priv_class && oc->priv_data)
229         av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
230
231     return 0;
232 }
233
234 static int hls_write_header(AVFormatContext *s)
235 {
236     HLSContext *hls = s->priv_data;
237     int ret, i;
238     char *p;
239     const char *pattern = "%d.ts";
240     AVDictionary *options = NULL;
241     int basename_size;
242
243     hls->sequence       = hls->start_sequence;
244     hls->recording_time = hls->time * AV_TIME_BASE;
245     hls->start_pts      = AV_NOPTS_VALUE;
246
247     if (hls->format_options_str) {
248         ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
249         if (ret < 0) {
250             av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n", hls->format_options_str);
251             goto fail;
252         }
253     }
254
255     for (i = 0; i < s->nb_streams; i++)
256         hls->has_video +=
257             s->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO;
258
259     if (hls->has_video > 1)
260         av_log(s, AV_LOG_WARNING,
261                "More than a single video stream present, "
262                "expect issues decoding it.\n");
263
264     hls->oformat = av_guess_format("mpegts", NULL, NULL);
265
266     if (!hls->oformat) {
267         ret = AVERROR_MUXER_NOT_FOUND;
268         goto fail;
269     }
270
271     if (hls->segment_filename) {
272         hls->basename = av_strdup(hls->segment_filename);
273         if (!hls->basename) {
274             ret = AVERROR(ENOMEM);
275             goto fail;
276         }
277     } else {
278         if (hls->flags & HLS_SINGLE_FILE)
279             pattern = ".ts";
280
281         basename_size = strlen(s->filename) + strlen(pattern) + 1;
282         hls->basename = av_malloc(basename_size);
283         if (!hls->basename) {
284             ret = AVERROR(ENOMEM);
285             goto fail;
286         }
287
288         av_strlcpy(hls->basename, s->filename, basename_size);
289
290         p = strrchr(hls->basename, '.');
291         if (p)
292             *p = '\0';
293         av_strlcat(hls->basename, pattern, basename_size);
294     }
295
296     if ((ret = hls_mux_init(s)) < 0)
297         goto fail;
298
299     if ((ret = hls_start(s)) < 0)
300         goto fail;
301
302     av_dict_copy(&options, hls->format_options, 0);
303     ret = avformat_write_header(hls->avf, &options);
304     if (av_dict_count(options)) {
305         av_log(s, AV_LOG_ERROR, "Some of provided format options in '%s' are not recognized\n", hls->format_options_str);
306         ret = AVERROR(EINVAL);
307         goto fail;
308     }
309     av_assert0(s->nb_streams == hls->avf->nb_streams);
310     for (i = 0; i < s->nb_streams; i++) {
311         AVStream *inner_st  = hls->avf->streams[i];
312         AVStream *outer_st = s->streams[i];
313         avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
314     }
315 fail:
316
317     av_dict_free(&options);
318     if (ret) {
319         av_free(hls->basename);
320         if (hls->avf)
321             avformat_free_context(hls->avf);
322     }
323     return ret;
324 }
325
326 static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
327 {
328     HLSContext *hls = s->priv_data;
329     AVFormatContext *oc = hls->avf;
330     AVStream *st = s->streams[pkt->stream_index];
331     int64_t end_pts = hls->recording_time * hls->number;
332     int is_ref_pkt = 1;
333     int ret, can_split = 1;
334
335     if (hls->start_pts == AV_NOPTS_VALUE) {
336         hls->start_pts = pkt->pts;
337         hls->end_pts   = pkt->pts;
338     }
339
340     if (hls->has_video) {
341         can_split = st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
342                     pkt->flags & AV_PKT_FLAG_KEY;
343         is_ref_pkt = st->codec->codec_type == AVMEDIA_TYPE_VIDEO;
344     }
345     if (pkt->pts == AV_NOPTS_VALUE)
346         is_ref_pkt = can_split = 0;
347
348     if (is_ref_pkt)
349         hls->duration = (double)(pkt->pts - hls->end_pts)
350                                    * st->time_base.num / st->time_base.den;
351
352     if (can_split && av_compare_ts(pkt->pts - hls->start_pts, st->time_base,
353                                    end_pts, AV_TIME_BASE_Q) >= 0) {
354         int64_t new_start_pos;
355         av_write_frame(oc, NULL); /* Flush any buffered data */
356
357         new_start_pos = avio_tell(hls->avf->pb);
358         hls->size = new_start_pos - hls->start_pos;
359         ret = hls_append_segment(hls, hls->duration, hls->start_pos, hls->size);
360         hls->start_pos = new_start_pos;
361         if (ret)
362             return ret;
363
364         hls->end_pts = pkt->pts;
365         hls->duration = 0;
366
367         if (hls->flags & HLS_SINGLE_FILE) {
368             if (hls->avf->oformat->priv_class && hls->avf->priv_data)
369                 av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
370             hls->number++;
371         } else {
372             avio_close(oc->pb);
373
374             ret = hls_start(s);
375         }
376
377         if (ret)
378             return ret;
379
380         oc = hls->avf;
381
382         if ((ret = hls_window(s, 0)) < 0)
383             return ret;
384     }
385
386     ret = ff_write_chained(oc, pkt->stream_index, pkt, s, 0);
387
388     return ret;
389 }
390
391 static int hls_write_trailer(struct AVFormatContext *s)
392 {
393     HLSContext *hls = s->priv_data;
394     AVFormatContext *oc = hls->avf;
395
396     av_write_trailer(oc);
397     hls->size = avio_tell(hls->avf->pb) - hls->start_pos;
398     avio_closep(&oc->pb);
399     av_free(hls->basename);
400     hls_append_segment(hls, hls->duration, hls->start_pos, hls->size);
401     avformat_free_context(oc);
402     hls->avf = NULL;
403     hls_window(s, 1);
404
405     hls_free_segments(hls);
406     avio_close(hls->pb);
407     return 0;
408 }
409
410 #define OFFSET(x) offsetof(HLSContext, x)
411 #define E AV_OPT_FLAG_ENCODING_PARAM
412 static const AVOption options[] = {
413     {"start_number",  "set first number in the sequence",        OFFSET(start_sequence),AV_OPT_TYPE_INT64,  {.i64 = 0},     0, INT64_MAX, E},
414     {"hls_time",      "set segment length in seconds",           OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E},
415     {"hls_list_size", "set maximum number of playlist entries",  OFFSET(max_nb_segments),    AV_OPT_TYPE_INT,    {.i64 = 5},     0, INT_MAX, E},
416     {"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},
417     {"hls_wrap",      "set number after which the index wraps",  OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E},
418     {"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},
419     {"hls_base_url",  "url to prepend to each playlist entry",   OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E},
420     {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename),   AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
421     {"hls_flags",     "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
422     {"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"},
423
424     { NULL },
425 };
426
427 static const AVClass hls_class = {
428     .class_name = "hls muxer",
429     .item_name  = av_default_item_name,
430     .option     = options,
431     .version    = LIBAVUTIL_VERSION_INT,
432 };
433
434
435 AVOutputFormat ff_hls_muxer = {
436     .name           = "hls",
437     .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
438     .extensions     = "m3u8",
439     .priv_data_size = sizeof(HLSContext),
440     .audio_codec    = AV_CODEC_ID_AAC,
441     .video_codec    = AV_CODEC_ID_H264,
442     .flags          = AVFMT_NOFILE | AVFMT_ALLOW_FLUSH,
443     .write_header   = hls_write_header,
444     .write_packet   = hls_write_packet,
445     .write_trailer  = hls_write_trailer,
446     .priv_class     = &hls_class,
447 };