Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavformat / segment.c
1 /*
2  * Generic segmenter
3  * Copyright (c) 2011, Luca Barbato
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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
24 #include "avformat.h"
25 #include "internal.h"
26
27 #include "libavutil/avassert.h"
28 #include "libavutil/log.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/parseutils.h"
32 #include "libavutil/mathematics.h"
33
34 typedef enum {
35     LIST_TYPE_FLAT = 0,
36     LIST_TYPE_EXT,
37     LIST_TYPE_NB,
38 } ListType;
39
40 typedef struct {
41     const AVClass *class;  /**< Class for private options. */
42     int number;
43     AVFormatContext *avf;
44     char *format;          ///< format to use for output segment files
45     char *list;            ///< filename for the segment list file
46     int   list_size;       ///< number of entries for the segment list file
47     ListType list_type;    ///< set the list type
48     AVIOContext *list_pb;  ///< list file put-byte context
49     int  wrap;             ///< number after which the index wraps
50     char *time_str;        ///< segment duration specification string
51     int64_t time;          ///< segment duration
52     char *times_str;       ///< segment times specification string
53     int64_t *times;        ///< list of segment interval specification
54     int nb_times;          ///< number of elments in the times array
55     char *time_delta_str;  ///< approximation value duration used for the segment times
56     int64_t time_delta;
57     int has_video;
58     double start_time, end_time;
59 } SegmentContext;
60
61 static int segment_start(AVFormatContext *s)
62 {
63     SegmentContext *seg = s->priv_data;
64     AVFormatContext *oc = seg->avf;
65     int err = 0;
66
67     if (seg->wrap)
68         seg->number %= seg->wrap;
69
70     if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
71                               s->filename, seg->number++) < 0) {
72         av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", s->filename);
73         return AVERROR(EINVAL);
74     }
75
76     if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
77                           &s->interrupt_callback, NULL)) < 0)
78         return err;
79
80     if (!oc->priv_data && oc->oformat->priv_data_size > 0) {
81         oc->priv_data = av_mallocz(oc->oformat->priv_data_size);
82         if (!oc->priv_data) {
83             avio_close(oc->pb);
84             return AVERROR(ENOMEM);
85         }
86         if (oc->oformat->priv_class) {
87             *(const AVClass**)oc->priv_data = oc->oformat->priv_class;
88             av_opt_set_defaults(oc->priv_data);
89         }
90     }
91
92     if ((err = oc->oformat->write_header(oc)) < 0) {
93         goto fail;
94     }
95
96     return 0;
97
98 fail:
99     av_log(oc, AV_LOG_ERROR, "Failure occurred when starting segment '%s'\n",
100            oc->filename);
101     avio_close(oc->pb);
102     av_freep(&oc->priv_data);
103
104     return err;
105 }
106
107 static int segment_end(AVFormatContext *s)
108 {
109     SegmentContext *seg = s->priv_data;
110     AVFormatContext *oc = seg->avf;
111     int ret = 0;
112
113     if (oc->oformat->write_trailer)
114         ret = oc->oformat->write_trailer(oc);
115
116     if (ret < 0)
117         av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n",
118                oc->filename);
119
120     if (seg->list) {
121         if (seg->list_size && !(seg->number % seg->list_size)) {
122             avio_close(seg->list_pb);
123             if ((ret = avio_open2(&seg->list_pb, seg->list, AVIO_FLAG_WRITE,
124                                   &s->interrupt_callback, NULL)) < 0)
125                 goto end;
126         }
127
128         if (seg->list_type == LIST_TYPE_FLAT) {
129             avio_printf(seg->list_pb, "%s\n", oc->filename);
130         } else if (seg->list_type == LIST_TYPE_EXT) {
131             avio_printf(seg->list_pb, "%s,%f,%f\n", oc->filename, seg->start_time, seg->end_time);
132         }
133         avio_flush(seg->list_pb);
134     }
135
136 end:
137     avio_close(oc->pb);
138     if (oc->oformat->priv_class)
139         av_opt_free(oc->priv_data);
140     av_freep(&oc->priv_data);
141
142     return ret;
143 }
144
145 static int parse_times(void *log_ctx, int64_t **times, int *nb_times,
146                        const char *times_str)
147 {
148     char *p;
149     int i, ret = 0;
150     char *times_str1 = av_strdup(times_str);
151     char *saveptr = NULL;
152
153     if (!times_str1)
154         return AVERROR(ENOMEM);
155
156 #define FAIL(err) ret = err; goto end
157
158     *nb_times = 1;
159     for (p = times_str1; *p; p++)
160         if (*p == ',')
161             (*nb_times)++;
162
163     *times = av_malloc(sizeof(**times) * *nb_times);
164     if (!*times) {
165         av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced times array\n");
166         FAIL(AVERROR(ENOMEM));
167     }
168
169     p = times_str1;
170     for (i = 0; i < *nb_times; i++) {
171         int64_t t;
172         char *tstr = av_strtok(p, ",", &saveptr);
173         av_assert0(tstr);
174         p = NULL;
175
176         ret = av_parse_time(&t, tstr, 1);
177         if (ret < 0) {
178             av_log(log_ctx, AV_LOG_ERROR,
179                    "Invalid time duration specification in %s\n", p);
180             FAIL(AVERROR(EINVAL));
181         }
182         (*times)[i] = t;
183
184         /* check on monotonicity */
185         if (i && (*times)[i-1] > (*times)[i]) {
186             av_log(log_ctx, AV_LOG_ERROR,
187                    "Specified time %f is greater than the following time %f\n",
188                    (float)((*times)[i])/1000000, (float)((*times)[i-1])/1000000);
189             FAIL(AVERROR(EINVAL));
190         }
191     }
192
193 end:
194     av_free(times_str1);
195     return ret;
196 }
197
198 static int seg_write_header(AVFormatContext *s)
199 {
200     SegmentContext *seg = s->priv_data;
201     AVFormatContext *oc;
202     int ret, i;
203
204     seg->number = 0;
205
206     if (seg->time_str && seg->times_str) {
207         av_log(s, AV_LOG_ERROR,
208                "segment_time and segment_times options are mutually exclusive, select just one of them\n");
209         return AVERROR(EINVAL);
210     }
211
212     if (seg->times_str) {
213         if ((ret = parse_times(s, &seg->times, &seg->nb_times, seg->times_str)) < 0)
214             return ret;
215     } else {
216         /* set default value if not specified */
217         if (!seg->time_str)
218             seg->time_str = av_strdup("2");
219         if ((ret = av_parse_time(&seg->time, seg->time_str, 1)) < 0) {
220             av_log(s, AV_LOG_ERROR,
221                    "Invalid time duration specification '%s' for segment_time option\n",
222                    seg->time_str);
223             return ret;
224         }
225     }
226
227     if (seg->time_delta_str) {
228         if ((ret = av_parse_time(&seg->time_delta, seg->time_delta_str, 1)) < 0) {
229             av_log(s, AV_LOG_ERROR,
230                    "Invalid time duration specification '%s' for delta option\n",
231                    seg->time_delta_str);
232             return ret;
233         }
234     }
235
236     oc = avformat_alloc_context();
237
238     if (!oc)
239         return AVERROR(ENOMEM);
240
241     if (seg->list)
242         if ((ret = avio_open2(&seg->list_pb, seg->list, AVIO_FLAG_WRITE,
243                               &s->interrupt_callback, NULL)) < 0)
244             goto fail;
245
246     for (i = 0; i< s->nb_streams; i++)
247         seg->has_video +=
248             (s->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO);
249
250     if (seg->has_video > 1)
251         av_log(s, AV_LOG_WARNING,
252                "More than a single video stream present, "
253                "expect issues decoding it.\n");
254
255     oc->oformat = av_guess_format(seg->format, s->filename, NULL);
256
257     if (!oc->oformat) {
258         ret = AVERROR_MUXER_NOT_FOUND;
259         goto fail;
260     }
261     if (oc->oformat->flags & AVFMT_NOFILE) {
262         av_log(s, AV_LOG_ERROR, "format %s not supported.\n",
263                oc->oformat->name);
264         ret = AVERROR(EINVAL);
265         goto fail;
266     }
267
268     seg->avf = oc;
269
270     oc->streams = s->streams;
271     oc->nb_streams = s->nb_streams;
272
273     if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
274                               s->filename, seg->number++) < 0) {
275         ret = AVERROR(EINVAL);
276         goto fail;
277     }
278
279     if ((ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
280                           &s->interrupt_callback, NULL)) < 0)
281         goto fail;
282
283     if ((ret = avformat_write_header(oc, NULL)) < 0) {
284         avio_close(oc->pb);
285         goto fail;
286     }
287
288 fail:
289     if (ret) {
290         if (oc) {
291             oc->streams = NULL;
292             oc->nb_streams = 0;
293             avformat_free_context(oc);
294         }
295         if (seg->list)
296             avio_close(seg->list_pb);
297     }
298     return ret;
299 }
300
301 static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
302 {
303     SegmentContext *seg = s->priv_data;
304     AVFormatContext *oc = seg->avf;
305     AVStream *st = oc->streams[pkt->stream_index];
306     int64_t end_pts;
307     int ret;
308
309     if (seg->times) {
310         end_pts = seg->number <= seg->nb_times ? seg->times[seg->number-1] : INT64_MAX;
311     } else {
312         end_pts = seg->time * seg->number;
313     }
314
315     /* if the segment has video, start a new segment *only* with a key video frame */
316     if ((st->codec->codec_type == AVMEDIA_TYPE_VIDEO || !seg->has_video) &&
317         av_compare_ts(pkt->pts, st->time_base,
318                       end_pts-seg->time_delta, AV_TIME_BASE_Q) >= 0 &&
319         pkt->flags & AV_PKT_FLAG_KEY) {
320
321         av_log(s, AV_LOG_DEBUG, "Next segment starts with packet stream:%d pts:%"PRId64" pts_time:%f\n",
322                pkt->stream_index, pkt->pts, pkt->pts * av_q2d(st->time_base));
323
324         if ((ret = segment_end(s)) < 0 || (ret = segment_start(s)) < 0)
325             goto fail;
326         seg->start_time = (double)pkt->pts * av_q2d(st->time_base);
327     } else if (pkt->pts != AV_NOPTS_VALUE) {
328         seg->end_time = FFMAX(seg->end_time,
329                               (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));
330     }
331
332     ret = oc->oformat->write_packet(oc, pkt);
333
334 fail:
335     if (ret < 0) {
336         oc->streams = NULL;
337         oc->nb_streams = 0;
338         if (seg->list)
339             avio_close(seg->list_pb);
340         avformat_free_context(oc);
341     }
342
343     return ret;
344 }
345
346 static int seg_write_trailer(struct AVFormatContext *s)
347 {
348     SegmentContext *seg = s->priv_data;
349     AVFormatContext *oc = seg->avf;
350     int ret = segment_end(s);
351     if (seg->list)
352         avio_close(seg->list_pb);
353
354     av_opt_free(seg);
355     av_freep(&seg->times);
356
357     oc->streams = NULL;
358     oc->nb_streams = 0;
359     avformat_free_context(oc);
360     return ret;
361 }
362
363 #define OFFSET(x) offsetof(SegmentContext, x)
364 #define E AV_OPT_FLAG_ENCODING_PARAM
365 static const AVOption options[] = {
366     { "segment_format",    "set container format used for the segments", OFFSET(format),  AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
367     { "segment_list",      "set the segment list filename",              OFFSET(list),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
368     { "segment_list_size", "set the maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT,  {.dbl = 5},     0, INT_MAX, E },
369     { "segment_list_type", "set the segment list type",                  OFFSET(list_type), AV_OPT_TYPE_INT,  {.dbl = LIST_TYPE_FLAT}, 0, LIST_TYPE_NB-1, E, "list_type" },
370     { "flat", "flat format",     0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, 0, "list_type" },
371     { "ext",  "extended format", 0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_EXT  }, INT_MIN, INT_MAX, 0, "list_type" },
372     { "segment_time",      "set segment duration",                       OFFSET(time_str),AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
373     { "segment_time_delta","set approximation value used for the segment times", OFFSET(time_delta_str), AV_OPT_TYPE_STRING, {.str = "0"}, 0, 0, E },
374     { "segment_times",     "set segment split time points",              OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL},  0, 0,       E },
375     { "segment_wrap",      "set number after which the index wraps",     OFFSET(wrap),    AV_OPT_TYPE_INT,    {.dbl = 0},     0, INT_MAX, E },
376     { NULL },
377 };
378
379 static const AVClass seg_class = {
380     .class_name = "segment muxer",
381     .item_name  = av_default_item_name,
382     .option     = options,
383     .version    = LIBAVUTIL_VERSION_INT,
384 };
385
386 AVOutputFormat ff_segment_muxer = {
387     .name           = "segment",
388     .long_name      = NULL_IF_CONFIG_SMALL("segment"),
389     .priv_data_size = sizeof(SegmentContext),
390     .flags          = AVFMT_GLOBALHEADER | AVFMT_NOFILE,
391     .write_header   = seg_write_header,
392     .write_packet   = seg_write_packet,
393     .write_trailer  = seg_write_trailer,
394     .priv_class     = &seg_class,
395 };
396
397 static const AVClass sseg_class = {
398     .class_name = "stream_segment muxer",
399     .item_name  = av_default_item_name,
400     .option     = options,
401     .version    = LIBAVUTIL_VERSION_INT,
402 };
403
404 AVOutputFormat ff_stream_segment_muxer = {
405     .name           = "stream_segment,ssegment",
406     .long_name      = NULL_IF_CONFIG_SMALL("streaming segment muxer"),
407     .priv_data_size = sizeof(SegmentContext),
408     .flags          = AVFMT_NOFILE,
409     .write_header   = seg_write_header,
410     .write_packet   = seg_write_packet,
411     .write_trailer  = seg_write_trailer,
412     .priv_class     = &sseg_class,
413 };