Merge commit '79fd186a5035cf16fc0ab288d8f59da8b1ba2c0e'
[ffmpeg.git] / libavformat / hdsenc.c
1 /*
2  * Live HDS fragmenter
3  * Copyright (c) 2013 Martin Storsjo
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 #if HAVE_UNISTD_H
25 #include <unistd.h>
26 #endif
27
28 #include "avformat.h"
29 #include "internal.h"
30 #include "os_support.h"
31
32 #include "libavutil/avstring.h"
33 #include "libavutil/base64.h"
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/opt.h"
37
38 typedef struct Fragment {
39     char file[1024];
40     int64_t start_time, duration;
41     int n;
42 } Fragment;
43
44 typedef struct OutputStream {
45     int bitrate;
46     int first_stream;
47     AVFormatContext *ctx;
48     int ctx_inited;
49     uint8_t iobuf[32768];
50     char temp_filename[1024];
51     int64_t frag_start_ts, last_ts;
52     AVIOContext *out;
53     int packets_written;
54     int nb_fragments, fragments_size, fragment_index;
55     Fragment **fragments;
56
57     int has_audio, has_video;
58
59     uint8_t *metadata;
60     int metadata_size;
61
62     uint8_t *extra_packets[2];
63     int extra_packet_sizes[2];
64     int nb_extra_packets;
65 } OutputStream;
66
67 typedef struct HDSContext {
68     const AVClass *class;  /* Class for private options. */
69     int window_size;
70     int extra_window_size;
71     int min_frag_duration;
72     int remove_at_exit;
73
74     OutputStream *streams;
75     int nb_streams;
76 } HDSContext;
77
78 static int parse_header(OutputStream *os, const uint8_t *buf, int buf_size)
79 {
80     if (buf_size < 13)
81         return AVERROR_INVALIDDATA;
82     if (memcmp(buf, "FLV", 3))
83         return AVERROR_INVALIDDATA;
84     buf      += 13;
85     buf_size -= 13;
86     while (buf_size >= 11 + 4) {
87         int type = buf[0];
88         int size = AV_RB24(&buf[1]) + 11 + 4;
89         if (size > buf_size)
90             return AVERROR_INVALIDDATA;
91         if (type == 8 || type == 9) {
92             if (os->nb_extra_packets >= FF_ARRAY_ELEMS(os->extra_packets))
93                 return AVERROR_INVALIDDATA;
94             os->extra_packet_sizes[os->nb_extra_packets] = size;
95             os->extra_packets[os->nb_extra_packets] = av_malloc(size);
96             if (!os->extra_packets[os->nb_extra_packets])
97                 return AVERROR(ENOMEM);
98             memcpy(os->extra_packets[os->nb_extra_packets], buf, size);
99             os->nb_extra_packets++;
100         } else if (type == 0x12) {
101             if (os->metadata)
102                 return AVERROR_INVALIDDATA;
103             os->metadata_size = size - 11 - 4;
104             os->metadata      = av_malloc(os->metadata_size);
105             if (!os->metadata)
106                 return AVERROR(ENOMEM);
107             memcpy(os->metadata, buf + 11, os->metadata_size);
108         }
109         buf      += size;
110         buf_size -= size;
111     }
112     if (!os->metadata)
113         return AVERROR_INVALIDDATA;
114     return 0;
115 }
116
117 static int hds_write(void *opaque, uint8_t *buf, int buf_size)
118 {
119     OutputStream *os = opaque;
120     if (os->out) {
121         avio_write(os->out, buf, buf_size);
122     } else {
123         if (!os->metadata_size) {
124             int ret;
125             // Assuming the IO buffer is large enough to fit the
126             // FLV header and all metadata and extradata packets
127             if ((ret = parse_header(os, buf, buf_size)) < 0)
128                 return ret;
129         }
130     }
131     return buf_size;
132 }
133
134 static void hds_free(AVFormatContext *s)
135 {
136     HDSContext *c = s->priv_data;
137     int i, j;
138     if (!c->streams)
139         return;
140     for (i = 0; i < s->nb_streams; i++) {
141         OutputStream *os = &c->streams[i];
142         if (os->out)
143             avio_close(os->out);
144         os->out = NULL;
145         if (os->ctx && os->ctx_inited)
146             av_write_trailer(os->ctx);
147         if (os->ctx && os->ctx->pb)
148             av_free(os->ctx->pb);
149         if (os->ctx)
150             avformat_free_context(os->ctx);
151         av_free(os->metadata);
152         for (j = 0; j < os->nb_extra_packets; j++)
153             av_free(os->extra_packets[j]);
154         for (j = 0; j < os->nb_fragments; j++)
155             av_free(os->fragments[j]);
156         av_free(os->fragments);
157     }
158     av_freep(&c->streams);
159 }
160
161 static int write_manifest(AVFormatContext *s, int final)
162 {
163     HDSContext *c = s->priv_data;
164     AVIOContext *out;
165     char filename[1024], temp_filename[1024];
166     const char *write_filename;
167     int ret, i;
168     float duration = 0;
169
170     if (c->nb_streams > 0)
171         duration = c->streams[0].last_ts * av_q2d(s->streams[0]->time_base);
172
173     snprintf(filename, sizeof(filename), "%s/index.f4m", s->filename);
174     snprintf(temp_filename, sizeof(temp_filename), "%s/index.f4m.tmp", s->filename);
175     write_filename = USE_RENAME_REPLACE ? temp_filename : filename;
176     ret = avio_open2(&out, write_filename, AVIO_FLAG_WRITE,
177                      &s->interrupt_callback, NULL);
178     if (ret < 0) {
179         av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", write_filename);
180         return ret;
181     }
182     avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
183     avio_printf(out, "<manifest xmlns=\"http://ns.adobe.com/f4m/1.0\">\n");
184     avio_printf(out, "\t<id>%s</id>\n", av_basename(s->filename));
185     avio_printf(out, "\t<streamType>%s</streamType>\n",
186                      final ? "recorded" : "live");
187     avio_printf(out, "\t<deliveryType>streaming</deliveryType>\n");
188     if (final)
189         avio_printf(out, "\t<duration>%f</duration>\n", duration);
190     for (i = 0; i < c->nb_streams; i++) {
191         OutputStream *os = &c->streams[i];
192         int b64_size = AV_BASE64_SIZE(os->metadata_size);
193         char *base64 = av_malloc(b64_size);
194         if (!base64) {
195             avio_close(out);
196             return AVERROR(ENOMEM);
197         }
198         av_base64_encode(base64, b64_size, os->metadata, os->metadata_size);
199
200         avio_printf(out, "\t<bootstrapInfo profile=\"named\" url=\"stream%d.abst\" id=\"bootstrap%d\" />\n", i, i);
201         avio_printf(out, "\t<media bitrate=\"%d\" url=\"stream%d\" bootstrapInfoId=\"bootstrap%d\">\n", os->bitrate/1000, i, i);
202         avio_printf(out, "\t\t<metadata>%s</metadata>\n", base64);
203         avio_printf(out, "\t</media>\n");
204         av_free(base64);
205     }
206     avio_printf(out, "</manifest>\n");
207     avio_flush(out);
208     avio_close(out);
209     return USE_RENAME_REPLACE ? ff_rename(temp_filename, filename, s) : 0;
210 }
211
212 static void update_size(AVIOContext *out, int64_t pos)
213 {
214     int64_t end = avio_tell(out);
215     avio_seek(out, pos, SEEK_SET);
216     avio_wb32(out, end - pos);
217     avio_seek(out, end, SEEK_SET);
218 }
219
220 /* Note, the .abst files need to be served with the "binary/octet"
221  * mime type, otherwise at least the OSMF player can easily fail
222  * with "stream not found" when polling for the next fragment. */
223 static int write_abst(AVFormatContext *s, OutputStream *os, int final)
224 {
225     HDSContext *c = s->priv_data;
226     AVIOContext *out;
227     char filename[1024], temp_filename[1024];
228     const char *write_filename;
229     int i, ret;
230     int64_t asrt_pos, afrt_pos;
231     int start = 0, fragments;
232     int index = s->streams[os->first_stream]->id;
233     int64_t cur_media_time = 0;
234     if (c->window_size)
235         start = FFMAX(os->nb_fragments - c->window_size, 0);
236     fragments = os->nb_fragments - start;
237     if (final)
238         cur_media_time = os->last_ts;
239     else if (os->nb_fragments)
240         cur_media_time = os->fragments[os->nb_fragments - 1]->start_time;
241
242     snprintf(filename, sizeof(filename),
243              "%s/stream%d.abst", s->filename, index);
244     snprintf(temp_filename, sizeof(temp_filename),
245              "%s/stream%d.abst.tmp", s->filename, index);
246     write_filename = USE_RENAME_REPLACE ? temp_filename : filename;
247     ret = avio_open2(&out, write_filename, AVIO_FLAG_WRITE,
248                      &s->interrupt_callback, NULL);
249     if (ret < 0) {
250         av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", write_filename);
251         return ret;
252     }
253     avio_wb32(out, 0); // abst size
254     avio_wl32(out, MKTAG('a','b','s','t'));
255     avio_wb32(out, 0); // version + flags
256     avio_wb32(out, os->fragment_index - 1); // BootstrapinfoVersion
257     avio_w8(out, final ? 0 : 0x20); // profile, live, update
258     avio_wb32(out, 1000); // timescale
259     avio_wb64(out, cur_media_time);
260     avio_wb64(out, 0); // SmpteTimeCodeOffset
261     avio_w8(out, 0); // MovieIdentifer (null string)
262     avio_w8(out, 0); // ServerEntryCount
263     avio_w8(out, 0); // QualityEntryCount
264     avio_w8(out, 0); // DrmData (null string)
265     avio_w8(out, 0); // MetaData (null string)
266     avio_w8(out, 1); // SegmentRunTableCount
267     asrt_pos = avio_tell(out);
268     avio_wb32(out, 0); // asrt size
269     avio_wl32(out, MKTAG('a','s','r','t'));
270     avio_wb32(out, 0); // version + flags
271     avio_w8(out, 0); // QualityEntryCount
272     avio_wb32(out, 1); // SegmentRunEntryCount
273     avio_wb32(out, 1); // FirstSegment
274     avio_wb32(out, final ? (os->fragment_index - 1) : 0xffffffff); // FragmentsPerSegment
275     update_size(out, asrt_pos);
276     avio_w8(out, 1); // FragmentRunTableCount
277     afrt_pos = avio_tell(out);
278     avio_wb32(out, 0); // afrt size
279     avio_wl32(out, MKTAG('a','f','r','t'));
280     avio_wb32(out, 0); // version + flags
281     avio_wb32(out, 1000); // timescale
282     avio_w8(out, 0); // QualityEntryCount
283     avio_wb32(out, fragments); // FragmentRunEntryCount
284     for (i = start; i < os->nb_fragments; i++) {
285         avio_wb32(out, os->fragments[i]->n);
286         avio_wb64(out, os->fragments[i]->start_time);
287         avio_wb32(out, os->fragments[i]->duration);
288     }
289     update_size(out, afrt_pos);
290     update_size(out, 0);
291     avio_close(out);
292     return USE_RENAME_REPLACE ? ff_rename(temp_filename, filename, s) : 0;
293 }
294
295 static int init_file(AVFormatContext *s, OutputStream *os, int64_t start_ts)
296 {
297     int ret, i;
298     ret = avio_open2(&os->out, os->temp_filename, AVIO_FLAG_WRITE,
299                      &s->interrupt_callback, NULL);
300     if (ret < 0)
301         return ret;
302     avio_wb32(os->out, 0);
303     avio_wl32(os->out, MKTAG('m','d','a','t'));
304     for (i = 0; i < os->nb_extra_packets; i++) {
305         AV_WB24(os->extra_packets[i] + 4, start_ts);
306         os->extra_packets[i][7] = (start_ts >> 24) & 0x7f;
307         avio_write(os->out, os->extra_packets[i], os->extra_packet_sizes[i]);
308     }
309     return 0;
310 }
311
312 static void close_file(OutputStream *os)
313 {
314     int64_t pos = avio_tell(os->out);
315     avio_seek(os->out, 0, SEEK_SET);
316     avio_wb32(os->out, pos);
317     avio_flush(os->out);
318     avio_close(os->out);
319     os->out = NULL;
320 }
321
322 static int hds_write_header(AVFormatContext *s)
323 {
324     HDSContext *c = s->priv_data;
325     int ret = 0, i;
326     AVOutputFormat *oformat;
327
328     if (mkdir(s->filename, 0777) == -1 && errno != EEXIST) {
329         ret = AVERROR(errno);
330         av_log(s, AV_LOG_ERROR , "Failed to create directory %s\n", s->filename);
331         goto fail;
332     }
333
334     oformat = av_guess_format("flv", NULL, NULL);
335     if (!oformat) {
336         ret = AVERROR_MUXER_NOT_FOUND;
337         goto fail;
338     }
339
340     c->streams = av_mallocz_array(s->nb_streams, sizeof(*c->streams));
341     if (!c->streams) {
342         ret = AVERROR(ENOMEM);
343         goto fail;
344     }
345
346     for (i = 0; i < s->nb_streams; i++) {
347         OutputStream *os = &c->streams[c->nb_streams];
348         AVFormatContext *ctx;
349         AVStream *st = s->streams[i];
350
351         if (!st->codec->bit_rate) {
352             av_log(s, AV_LOG_ERROR, "No bit rate set for stream %d\n", i);
353             ret = AVERROR(EINVAL);
354             goto fail;
355         }
356         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
357             if (os->has_video) {
358                 c->nb_streams++;
359                 os++;
360             }
361             os->has_video = 1;
362         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
363             if (os->has_audio) {
364                 c->nb_streams++;
365                 os++;
366             }
367             os->has_audio = 1;
368         } else {
369             av_log(s, AV_LOG_ERROR, "Unsupported stream type in stream %d\n", i);
370             ret = AVERROR(EINVAL);
371             goto fail;
372         }
373         os->bitrate += s->streams[i]->codec->bit_rate;
374
375         if (!os->ctx) {
376             os->first_stream = i;
377             ctx = avformat_alloc_context();
378             if (!ctx) {
379                 ret = AVERROR(ENOMEM);
380                 goto fail;
381             }
382             os->ctx = ctx;
383             ctx->oformat = oformat;
384             ctx->interrupt_callback = s->interrupt_callback;
385
386             ctx->pb = avio_alloc_context(os->iobuf, sizeof(os->iobuf),
387                                          AVIO_FLAG_WRITE, os,
388                                          NULL, hds_write, NULL);
389             if (!ctx->pb) {
390                 ret = AVERROR(ENOMEM);
391                 goto fail;
392             }
393         } else {
394             ctx = os->ctx;
395         }
396         s->streams[i]->id = c->nb_streams;
397
398         if (!(st = avformat_new_stream(ctx, NULL))) {
399             ret = AVERROR(ENOMEM);
400             goto fail;
401         }
402         avcodec_copy_context(st->codec, s->streams[i]->codec);
403         st->codec->codec_tag = 0;
404         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
405         st->time_base = s->streams[i]->time_base;
406     }
407     if (c->streams[c->nb_streams].ctx)
408         c->nb_streams++;
409
410     for (i = 0; i < c->nb_streams; i++) {
411         OutputStream *os = &c->streams[i];
412         int j;
413         if ((ret = avformat_write_header(os->ctx, NULL)) < 0) {
414              goto fail;
415         }
416         os->ctx_inited = 1;
417         avio_flush(os->ctx->pb);
418         for (j = 0; j < os->ctx->nb_streams; j++)
419             s->streams[os->first_stream + j]->time_base = os->ctx->streams[j]->time_base;
420
421         snprintf(os->temp_filename, sizeof(os->temp_filename),
422                  "%s/stream%d_temp", s->filename, i);
423         ret = init_file(s, os, 0);
424         if (ret < 0)
425             goto fail;
426
427         if (!os->has_video && c->min_frag_duration <= 0) {
428             av_log(s, AV_LOG_WARNING,
429                    "No video stream in output stream %d and no min frag duration set\n", i);
430             ret = AVERROR(EINVAL);
431         }
432         os->fragment_index = 1;
433         write_abst(s, os, 0);
434     }
435     ret = write_manifest(s, 0);
436
437 fail:
438     if (ret)
439         hds_free(s);
440     return ret;
441 }
442
443 static int add_fragment(OutputStream *os, const char *file,
444                         int64_t start_time, int64_t duration)
445 {
446     Fragment *frag;
447     if (duration == 0)
448         duration = 1;
449     if (os->nb_fragments >= os->fragments_size) {
450         int ret;
451         os->fragments_size = (os->fragments_size + 1) * 2;
452         if ((ret = av_reallocp_array(&os->fragments, os->fragments_size,
453                                      sizeof(*os->fragments))) < 0) {
454             os->fragments_size = 0;
455             os->nb_fragments   = 0;
456             return ret;
457         }
458     }
459     frag = av_mallocz(sizeof(*frag));
460     if (!frag)
461         return AVERROR(ENOMEM);
462     av_strlcpy(frag->file, file, sizeof(frag->file));
463     frag->start_time = start_time;
464     frag->duration   = duration;
465     frag->n          = os->fragment_index;
466     os->fragments[os->nb_fragments++] = frag;
467     os->fragment_index++;
468     return 0;
469 }
470
471 static int hds_flush(AVFormatContext *s, OutputStream *os, int final,
472                      int64_t end_ts)
473 {
474     HDSContext *c = s->priv_data;
475     int i, ret = 0;
476     char target_filename[1024];
477     int index = s->streams[os->first_stream]->id;
478
479     if (!os->packets_written)
480         return 0;
481
482     avio_flush(os->ctx->pb);
483     os->packets_written = 0;
484     close_file(os);
485
486     snprintf(target_filename, sizeof(target_filename),
487              "%s/stream%dSeg1-Frag%d", s->filename, index, os->fragment_index);
488     ret = ff_rename(os->temp_filename, target_filename, s);
489     if (ret < 0)
490         return ret;
491     add_fragment(os, target_filename, os->frag_start_ts, end_ts - os->frag_start_ts);
492
493     if (!final) {
494         ret = init_file(s, os, end_ts);
495         if (ret < 0)
496             return ret;
497     }
498
499     if (c->window_size || (final && c->remove_at_exit)) {
500         int remove = os->nb_fragments - c->window_size - c->extra_window_size;
501         if (final && c->remove_at_exit)
502             remove = os->nb_fragments;
503         if (remove > 0) {
504             for (i = 0; i < remove; i++) {
505                 unlink(os->fragments[i]->file);
506                 av_free(os->fragments[i]);
507             }
508             os->nb_fragments -= remove;
509             memmove(os->fragments, os->fragments + remove,
510                     os->nb_fragments * sizeof(*os->fragments));
511         }
512     }
513
514     if (ret >= 0)
515         ret = write_abst(s, os, final);
516     return ret;
517 }
518
519 static int hds_write_packet(AVFormatContext *s, AVPacket *pkt)
520 {
521     HDSContext *c = s->priv_data;
522     AVStream *st = s->streams[pkt->stream_index];
523     OutputStream *os = &c->streams[s->streams[pkt->stream_index]->id];
524     int64_t end_dts = os->fragment_index * (int64_t)c->min_frag_duration;
525     int ret;
526
527     if (st->first_dts == AV_NOPTS_VALUE)
528         st->first_dts = pkt->dts;
529
530     if ((!os->has_video || st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
531         av_compare_ts(pkt->dts - st->first_dts, st->time_base,
532                       end_dts, AV_TIME_BASE_Q) >= 0 &&
533         pkt->flags & AV_PKT_FLAG_KEY && os->packets_written) {
534
535         if ((ret = hds_flush(s, os, 0, pkt->dts)) < 0)
536             return ret;
537     }
538
539     // Note, these fragment start timestamps, that represent a whole
540     // OutputStream, assume all streams in it have the same time base.
541     if (!os->packets_written)
542         os->frag_start_ts = pkt->dts;
543     os->last_ts = pkt->dts;
544
545     os->packets_written++;
546     return ff_write_chained(os->ctx, pkt->stream_index - os->first_stream, pkt, s, 0);
547 }
548
549 static int hds_write_trailer(AVFormatContext *s)
550 {
551     HDSContext *c = s->priv_data;
552     int i;
553
554     for (i = 0; i < c->nb_streams; i++)
555         hds_flush(s, &c->streams[i], 1, c->streams[i].last_ts);
556     write_manifest(s, 1);
557
558     if (c->remove_at_exit) {
559         char filename[1024];
560         snprintf(filename, sizeof(filename), "%s/index.f4m", s->filename);
561         unlink(filename);
562         for (i = 0; i < c->nb_streams; i++) {
563             snprintf(filename, sizeof(filename), "%s/stream%d.abst", s->filename, i);
564             unlink(filename);
565         }
566         rmdir(s->filename);
567     }
568
569     hds_free(s);
570     return 0;
571 }
572
573 #define OFFSET(x) offsetof(HDSContext, x)
574 #define E AV_OPT_FLAG_ENCODING_PARAM
575 static const AVOption options[] = {
576     { "window_size", "number of fragments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
577     { "extra_window_size", "number of fragments kept outside of the manifest before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64 = 5 }, 0, INT_MAX, E },
578     { "min_frag_duration", "minimum fragment duration (in microseconds)", OFFSET(min_frag_duration), AV_OPT_TYPE_INT64, { .i64 = 10000000 }, 0, INT_MAX, E },
579     { "remove_at_exit", "remove all fragments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
580     { NULL },
581 };
582
583 static const AVClass hds_class = {
584     .class_name = "HDS muxer",
585     .item_name  = av_default_item_name,
586     .option     = options,
587     .version    = LIBAVUTIL_VERSION_INT,
588 };
589
590 AVOutputFormat ff_hds_muxer = {
591     .name           = "hds",
592     .long_name      = NULL_IF_CONFIG_SMALL("HDS Muxer"),
593     .priv_data_size = sizeof(HDSContext),
594     .audio_codec    = AV_CODEC_ID_AAC,
595     .video_codec    = AV_CODEC_ID_H264,
596     .flags          = AVFMT_GLOBALHEADER | AVFMT_NOFILE,
597     .write_header   = hds_write_header,
598     .write_packet   = hds_write_packet,
599     .write_trailer  = hds_write_trailer,
600     .priv_class     = &hds_class,
601 };