falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
83197 Commits
32 Branches
351MB
Tree: 2b20290061
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2b20290061'
${ noResults }
FFmpeg/libavformat/segment.c

1107 lines
41KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2011, Luca Barbato

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. /**

  22.  * @file generic segmenter

  23.  * M3U8 specification can be find here:

  24.  * @url{http://tools.ietf.org/id/draft-pantos-http-live-streaming}

  25.  */

  26. 

  27. /* #define DEBUG */

  28. 

  29. #include <float.h>

  30. #include <time.h>

  31. 

  32. #include "avformat.h"

  33. #include "avio_internal.h"

  34. #include "internal.h"

  35. 

  36. #include "libavutil/avassert.h"

  37. #include "libavutil/internal.h"

  38. #include "libavutil/log.h"

  39. #include "libavutil/opt.h"

  40. #include "libavutil/avstring.h"

  41. #include "libavutil/parseutils.h"

  42. #include "libavutil/mathematics.h"

  43. #include "libavutil/time.h"

  44. #include "libavutil/timecode.h"

  45. #include "libavutil/time_internal.h"

  46. #include "libavutil/timestamp.h"

  47. 

  48. typedef struct SegmentListEntry {

  49.     int index;

  50.     double start_time, end_time;

  51.     int64_t start_pts;

  52.     int64_t offset_pts;

  53.     char *filename;

  54.     struct SegmentListEntry *next;

  55.     int64_t last_duration;

  56. } SegmentListEntry;

  57. 

  58. typedef enum {

  59.     LIST_TYPE_UNDEFINED = -1,

  60.     LIST_TYPE_FLAT = 0,

  61.     LIST_TYPE_CSV,

  62.     LIST_TYPE_M3U8,

  63.     LIST_TYPE_EXT, ///< deprecated

  64.     LIST_TYPE_FFCONCAT,

  65.     LIST_TYPE_NB,

  66. } ListType;

  67. 

  68. #define SEGMENT_LIST_FLAG_CACHE 1

  69. #define SEGMENT_LIST_FLAG_LIVE  2

  70. 

  71. typedef struct SegmentContext {

  72.     const AVClass *class;  /**< Class for private options. */

  73.     int segment_idx;       ///< index of the segment file to write, starting from 0

  74.     int segment_idx_wrap;  ///< number after which the index wraps

  75.     int segment_idx_wrap_nb;  ///< number of time the index has wraped

  76.     int segment_count;     ///< number of segment files already written

  77.     AVOutputFormat *oformat;

  78.     AVFormatContext *avf;

  79.     char *format;              ///< format to use for output segment files

  80.     char *format_options_str;  ///< format options to use for output segment files

  81.     AVDictionary *format_options;

  82.     char *list;            ///< filename for the segment list file

  83.     int   list_flags;      ///< flags affecting list generation

  84.     int   list_size;       ///< number of entries for the segment list file

  85. 

  86.     int use_clocktime;    ///< flag to cut segments at regular clock time

  87.     int64_t clocktime_offset; //< clock offset for cutting the segments at regular clock time

  88.     int64_t clocktime_wrap_duration; //< wrapping duration considered for starting a new segment

  89.     int64_t last_val;      ///< remember last time for wrap around detection

  90.     int64_t last_cut;      ///< remember last cut

  91.     int cut_pending;

  92.     int header_written;    ///< whether we've already called avformat_write_header

  93. 

  94.     char *entry_prefix;    ///< prefix to add to list entry filenames

  95.     int list_type;         ///< set the list type

  96.     AVIOContext *list_pb;  ///< list file put-byte context

  97.     char *time_str;        ///< segment duration specification string

  98.     int64_t time;          ///< segment duration

  99.     int use_strftime;      ///< flag to expand filename with strftime

  100.     int increment_tc;      ///< flag to increment timecode if found

  101. 

  102.     char *times_str;       ///< segment times specification string

  103.     int64_t *times;        ///< list of segment interval specification

  104.     int nb_times;          ///< number of elments in the times array

  105. 

  106.     char *frames_str;      ///< segment frame numbers specification string

  107.     int *frames;           ///< list of frame number specification

  108.     int nb_frames;         ///< number of elments in the frames array

  109.     int frame_count;       ///< total number of reference frames

  110.     int segment_frame_count; ///< number of reference frames in the segment

  111. 

  112.     int64_t time_delta;

  113.     int  individual_header_trailer; /**< Set by a private option. */

  114.     int  write_header_trailer; /**< Set by a private option. */

  115.     char *header_filename;  ///< filename to write the output header to

  116. 

  117.     int reset_timestamps;  ///< reset timestamps at the begin of each segment

  118.     int64_t initial_offset;    ///< initial timestamps offset, expressed in microseconds

  119.     char *reference_stream_specifier; ///< reference stream specifier

  120.     int   reference_stream_index;

  121.     int   break_non_keyframes;

  122.     int   write_empty;

  123. 

  124.     int use_rename;

  125.     char temp_list_filename[1024];

  126. 

  127.     SegmentListEntry cur_entry;

  128.     SegmentListEntry *segment_list_entries;

  129.     SegmentListEntry *segment_list_entries_end;

  130. } SegmentContext;

  131. 

  132. static void print_csv_escaped_str(AVIOContext *ctx, const char *str)

  133. {

  134.     int needs_quoting = !!str[strcspn(str, "\",\n\r")];

  135. 

  136.     if (needs_quoting)

  137.         avio_w8(ctx, '"');

  138. 

  139.     for (; *str; str++) {

  140.         if (*str == '"')

  141.             avio_w8(ctx, '"');

  142.         avio_w8(ctx, *str);

  143.     }

  144.     if (needs_quoting)

  145.         avio_w8(ctx, '"');

  146. }

  147. 

  148. static int segment_mux_init(AVFormatContext *s)

  149. {

  150.     SegmentContext *seg = s->priv_data;

  151.     AVFormatContext *oc;

  152.     int i;

  153.     int ret;

  154. 

  155.     ret = avformat_alloc_output_context2(&seg->avf, seg->oformat, NULL, NULL);

  156.     if (ret < 0)

  157.         return ret;

  158.     oc = seg->avf;

  159. 

  160.     oc->interrupt_callback = s->interrupt_callback;

  161.     oc->max_delay          = s->max_delay;

  162.     av_dict_copy(&oc->metadata, s->metadata, 0);

  163.     oc->opaque             = s->opaque;

  164.     oc->io_close           = s->io_close;

  165.     oc->io_open            = s->io_open;

  166.     oc->flags              = s->flags;

  167. 

  168.     for (i = 0; i < s->nb_streams; i++) {

  169.         AVStream *st;

  170.         AVCodecParameters *ipar, *opar;

  171. 

  172.         if (!(st = avformat_new_stream(oc, NULL)))

  173.             return AVERROR(ENOMEM);

  174.         ipar = s->streams[i]->codecpar;

  175.         opar = st->codecpar;

  176.         avcodec_parameters_copy(opar, ipar);

  177.         if (!oc->oformat->codec_tag ||

  178.             av_codec_get_id (oc->oformat->codec_tag, ipar->codec_tag) == opar->codec_id ||

  179.             av_codec_get_tag(oc->oformat->codec_tag, ipar->codec_id) <= 0) {

  180.             opar->codec_tag = ipar->codec_tag;

  181.         } else {

  182.             opar->codec_tag = 0;

  183.         }

  184.         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;

  185.         st->time_base = s->streams[i]->time_base;

  186.         av_dict_copy(&st->metadata, s->streams[i]->metadata, 0);

  187.     }

  188. 

  189.     return 0;

  190. }

  191. 

  192. static int set_segment_filename(AVFormatContext *s)

  193. {

  194.     SegmentContext *seg = s->priv_data;

  195.     AVFormatContext *oc = seg->avf;

  196.     size_t size;

  197.     int ret;

  198. 

  199.     if (seg->segment_idx_wrap)

  200.         seg->segment_idx %= seg->segment_idx_wrap;

  201.     if (seg->use_strftime) {

  202.         time_t now0;

  203.         struct tm *tm, tmpbuf;

  204.         time(&now0);

  205.         tm = localtime_r(&now0, &tmpbuf);

  206.         if (!strftime(oc->filename, sizeof(oc->filename), s->filename, tm)) {

  207.             av_log(oc, AV_LOG_ERROR, "Could not get segment filename with strftime\n");

  208.             return AVERROR(EINVAL);

  209.         }

  210.     } else if (av_get_frame_filename(oc->filename, sizeof(oc->filename),

  211.                                      s->filename, seg->segment_idx) < 0) {

  212.         av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", s->filename);

  213.         return AVERROR(EINVAL);

  214.     }

  215. 

  216.     /* copy modified name in list entry */

  217.     size = strlen(av_basename(oc->filename)) + 1;

  218.     if (seg->entry_prefix)

  219.         size += strlen(seg->entry_prefix);

  220. 

  221.     if ((ret = av_reallocp(&seg->cur_entry.filename, size)) < 0)

  222.         return ret;

  223.     snprintf(seg->cur_entry.filename, size, "%s%s",

  224.              seg->entry_prefix ? seg->entry_prefix : "",

  225.              av_basename(oc->filename));

  226. 

  227.     return 0;

  228. }

  229. 

  230. static int segment_start(AVFormatContext *s, int write_header)

  231. {

  232.     SegmentContext *seg = s->priv_data;

  233.     AVFormatContext *oc = seg->avf;

  234.     int err = 0;

  235. 

  236.     if (write_header) {

  237.         avformat_free_context(oc);

  238.         seg->avf = NULL;

  239.         if ((err = segment_mux_init(s)) < 0)

  240.             return err;

  241.         oc = seg->avf;

  242.     }

  243. 

  244.     seg->segment_idx++;

  245.     if ((seg->segment_idx_wrap) && (seg->segment_idx % seg->segment_idx_wrap == 0))

  246.         seg->segment_idx_wrap_nb++;

  247. 

  248.     if ((err = set_segment_filename(s)) < 0)

  249.         return err;

  250. 

  251.     if ((err = s->io_open(s, &oc->pb, oc->filename, AVIO_FLAG_WRITE, NULL)) < 0) {

  252.         av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", oc->filename);

  253.         return err;

  254.     }

  255.     if (!seg->individual_header_trailer)

  256.         oc->pb->seekable = 0;

  257. 

  258.     if (oc->oformat->priv_class && oc->priv_data)

  259.         av_opt_set(oc->priv_data, "mpegts_flags", "+resend_headers", 0);

  260. 

  261.     if (write_header) {

  262.         AVDictionary *options = NULL;

  263.         av_dict_copy(&options, seg->format_options, 0);

  264.         av_dict_set(&options, "fflags", "-autobsf", 0);

  265.         err = avformat_write_header(oc, &options);

  266.         av_dict_free(&options);

  267.         if (err < 0)

  268.             return err;

  269.     }

  270. 

  271.     seg->segment_frame_count = 0;

  272.     return 0;

  273. }

  274. 

  275. static int segment_list_open(AVFormatContext *s)

  276. {

  277.     SegmentContext *seg = s->priv_data;

  278.     int ret;

  279. 

  280.     snprintf(seg->temp_list_filename, sizeof(seg->temp_list_filename), seg->use_rename ? "%s.tmp" : "%s", seg->list);

  281.     ret = s->io_open(s, &seg->list_pb, seg->temp_list_filename, AVIO_FLAG_WRITE, NULL);

  282.     if (ret < 0) {

  283.         av_log(s, AV_LOG_ERROR, "Failed to open segment list '%s'\n", seg->list);

  284.         return ret;

  285.     }

  286. 

  287.     if (seg->list_type == LIST_TYPE_M3U8 && seg->segment_list_entries) {

  288.         SegmentListEntry *entry;

  289.         double max_duration = 0;

  290. 

  291.         avio_printf(seg->list_pb, "#EXTM3U\n");

  292.         avio_printf(seg->list_pb, "#EXT-X-VERSION:3\n");

  293.         avio_printf(seg->list_pb, "#EXT-X-MEDIA-SEQUENCE:%d\n", seg->segment_list_entries->index);

  294.         avio_printf(seg->list_pb, "#EXT-X-ALLOW-CACHE:%s\n",

  295.                     seg->list_flags & SEGMENT_LIST_FLAG_CACHE ? "YES" : "NO");

  296. 

  297.         av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%d\n",

  298.                seg->segment_list_entries->index);

  299. 

  300.         for (entry = seg->segment_list_entries; entry; entry = entry->next)

  301.             max_duration = FFMAX(max_duration, entry->end_time - entry->start_time);

  302.         avio_printf(seg->list_pb, "#EXT-X-TARGETDURATION:%"PRId64"\n", (int64_t)ceil(max_duration));

  303.     } else if (seg->list_type == LIST_TYPE_FFCONCAT) {

  304.         avio_printf(seg->list_pb, "ffconcat version 1.0\n");

  305.     }

  306. 

  307.     return ret;

  308. }

  309. 

  310. static void segment_list_print_entry(AVIOContext      *list_ioctx,

  311.                                      ListType          list_type,

  312.                                      const SegmentListEntry *list_entry,

  313.                                      void *log_ctx)

  314. {

  315.     switch (list_type) {

  316.     case LIST_TYPE_FLAT:

  317.         avio_printf(list_ioctx, "%s\n", list_entry->filename);

  318.         break;

  319.     case LIST_TYPE_CSV:

  320.     case LIST_TYPE_EXT:

  321.         print_csv_escaped_str(list_ioctx, list_entry->filename);

  322.         avio_printf(list_ioctx, ",%f,%f\n", list_entry->start_time, list_entry->end_time);

  323.         break;

  324.     case LIST_TYPE_M3U8:

  325.         avio_printf(list_ioctx, "#EXTINF:%f,\n%s\n",

  326.                     list_entry->end_time - list_entry->start_time, list_entry->filename);

  327.         break;

  328.     case LIST_TYPE_FFCONCAT:

  329.     {

  330.         char *buf;

  331.         if (av_escape(&buf, list_entry->filename, NULL, AV_ESCAPE_MODE_AUTO, AV_ESCAPE_FLAG_WHITESPACE) < 0) {

  332.             av_log(log_ctx, AV_LOG_WARNING,

  333.                    "Error writing list entry '%s' in list file\n", list_entry->filename);

  334.             return;

  335.         }

  336.         avio_printf(list_ioctx, "file %s\n", buf);

  337.         av_free(buf);

  338.         break;

  339.     }

  340.     default:

  341.         av_assert0(!"Invalid list type");

  342.     }

  343. }

  344. 

  345. static int segment_end(AVFormatContext *s, int write_trailer, int is_last)

  346. {

  347.     SegmentContext *seg = s->priv_data;

  348.     AVFormatContext *oc = seg->avf;

  349.     int ret = 0;

  350.     AVTimecode tc;

  351.     AVRational rate;

  352.     AVDictionaryEntry *tcr;

  353.     char buf[AV_TIMECODE_STR_SIZE];

  354.     int i;

  355.     int err;

  356. 

  357.     if (!oc || !oc->pb)

  358.         return AVERROR(EINVAL);

  359. 

  360.     av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */

  361.     if (write_trailer)

  362.         ret = av_write_trailer(oc);

  363. 

  364.     if (ret < 0)

  365.         av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n",

  366.                oc->filename);

  367. 

  368.     if (seg->list) {

  369.         if (seg->list_size || seg->list_type == LIST_TYPE_M3U8) {

  370.             SegmentListEntry *entry = av_mallocz(sizeof(*entry));

  371.             if (!entry) {

  372.                 ret = AVERROR(ENOMEM);

  373.                 goto end;

  374.             }

  375. 

  376.             /* append new element */

  377.             memcpy(entry, &seg->cur_entry, sizeof(*entry));

  378.             entry->filename = av_strdup(entry->filename);

  379.             if (!seg->segment_list_entries)

  380.                 seg->segment_list_entries = seg->segment_list_entries_end = entry;

  381.             else

  382.                 seg->segment_list_entries_end->next = entry;

  383.             seg->segment_list_entries_end = entry;

  384. 

  385.             /* drop first item */

  386.             if (seg->list_size && seg->segment_count >= seg->list_size) {

  387.                 entry = seg->segment_list_entries;

  388.                 seg->segment_list_entries = seg->segment_list_entries->next;

  389.                 av_freep(&entry->filename);

  390.                 av_freep(&entry);

  391.             }

  392. 

  393.             if ((ret = segment_list_open(s)) < 0)

  394.                 goto end;

  395.             for (entry = seg->segment_list_entries; entry; entry = entry->next)

  396.                 segment_list_print_entry(seg->list_pb, seg->list_type, entry, s);

  397.             if (seg->list_type == LIST_TYPE_M3U8 && is_last)

  398.                 avio_printf(seg->list_pb, "#EXT-X-ENDLIST\n");

  399.             ff_format_io_close(s, &seg->list_pb);

  400.             if (seg->use_rename)

  401.                 ff_rename(seg->temp_list_filename, seg->list, s);

  402.         } else {

  403.             segment_list_print_entry(seg->list_pb, seg->list_type, &seg->cur_entry, s);

  404.             avio_flush(seg->list_pb);

  405.         }

  406.     }

  407. 

  408.     av_log(s, AV_LOG_VERBOSE, "segment:'%s' count:%d ended\n",

  409.            seg->avf->filename, seg->segment_count);

  410.     seg->segment_count++;

  411. 

  412.     if (seg->increment_tc) {

  413.         tcr = av_dict_get(s->metadata, "timecode", NULL, 0);

  414.         if (tcr) {

  415.             /* search the first video stream */

  416.             for (i = 0; i < s->nb_streams; i++) {

  417.                 if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {

  418.                     rate = s->streams[i]->avg_frame_rate;/* Get fps from the video stream */

  419.                     err = av_timecode_init_from_string(&tc, rate, tcr->value, s);

  420.                     if (err < 0) {

  421.                         av_log(s, AV_LOG_WARNING, "Could not increment timecode, error occurred during timecode creation.");

  422.                         break;

  423.                     }

  424.                     tc.start += (int)((seg->cur_entry.end_time - seg->cur_entry.start_time) * av_q2d(rate));/* increment timecode */

  425.                     av_dict_set(&s->metadata, "timecode",

  426.                                 av_timecode_make_string(&tc, buf, 0), 0);

  427.                     break;

  428.                 }

  429.             }

  430.         } else {

  431.             av_log(s, AV_LOG_WARNING, "Could not increment timecode, no timecode metadata found");

  432.         }

  433.     }

  434. 

  435. end:

  436.     ff_format_io_close(oc, &oc->pb);

  437. 

  438.     return ret;

  439. }

  440. 

  441. static int parse_times(void *log_ctx, int64_t **times, int *nb_times,

  442.                        const char *times_str)

  443. {

  444.     char *p;

  445.     int i, ret = 0;

  446.     char *times_str1 = av_strdup(times_str);

  447.     char *saveptr = NULL;

  448. 

  449.     if (!times_str1)

  450.         return AVERROR(ENOMEM);

  451. 

  452. #define FAIL(err) ret = err; goto end

  453. 

  454.     *nb_times = 1;

  455.     for (p = times_str1; *p; p++)

  456.         if (*p == ',')

  457.             (*nb_times)++;

  458. 

  459.     *times = av_malloc_array(*nb_times, sizeof(**times));

  460.     if (!*times) {

  461.         av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced times array\n");

  462.         FAIL(AVERROR(ENOMEM));

  463.     }

  464. 

  465.     p = times_str1;

  466.     for (i = 0; i < *nb_times; i++) {

  467.         int64_t t;

  468.         char *tstr = av_strtok(p, ",", &saveptr);

  469.         p = NULL;

  470. 

  471.         if (!tstr || !tstr[0]) {

  472.             av_log(log_ctx, AV_LOG_ERROR, "Empty time specification in times list %s\n",

  473.                    times_str);

  474.             FAIL(AVERROR(EINVAL));

  475.         }

  476. 

  477.         ret = av_parse_time(&t, tstr, 1);

  478.         if (ret < 0) {

  479.             av_log(log_ctx, AV_LOG_ERROR,

  480.                    "Invalid time duration specification '%s' in times list %s\n", tstr, times_str);

  481.             FAIL(AVERROR(EINVAL));

  482.         }

  483.         (*times)[i] = t;

  484. 

  485.         /* check on monotonicity */

  486.         if (i && (*times)[i-1] > (*times)[i]) {

  487.             av_log(log_ctx, AV_LOG_ERROR,

  488.                    "Specified time %f is greater than the following time %f\n",

  489.                    (float)((*times)[i])/1000000, (float)((*times)[i-1])/1000000);

  490.             FAIL(AVERROR(EINVAL));

  491.         }

  492.     }

  493. 

  494. end:

  495.     av_free(times_str1);

  496.     return ret;

  497. }

  498. 

  499. static int parse_frames(void *log_ctx, int **frames, int *nb_frames,

  500.                         const char *frames_str)

  501. {

  502.     char *p;

  503.     int i, ret = 0;

  504.     char *frames_str1 = av_strdup(frames_str);

  505.     char *saveptr = NULL;

  506. 

  507.     if (!frames_str1)

  508.         return AVERROR(ENOMEM);

  509. 

  510. #define FAIL(err) ret = err; goto end

  511. 

  512.     *nb_frames = 1;

  513.     for (p = frames_str1; *p; p++)

  514.         if (*p == ',')

  515.             (*nb_frames)++;

  516. 

  517.     *frames = av_malloc_array(*nb_frames, sizeof(**frames));

  518.     if (!*frames) {

  519.         av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced frames array\n");

  520.         FAIL(AVERROR(ENOMEM));

  521.     }

  522. 

  523.     p = frames_str1;

  524.     for (i = 0; i < *nb_frames; i++) {

  525.         long int f;

  526.         char *tailptr;

  527.         char *fstr = av_strtok(p, ",", &saveptr);

  528. 

  529.         p = NULL;

  530.         if (!fstr) {

  531.             av_log(log_ctx, AV_LOG_ERROR, "Empty frame specification in frame list %s\n",

  532.                    frames_str);

  533.             FAIL(AVERROR(EINVAL));

  534.         }

  535.         f = strtol(fstr, &tailptr, 10);

  536.         if (*tailptr || f <= 0 || f >= INT_MAX) {

  537.             av_log(log_ctx, AV_LOG_ERROR,

  538.                    "Invalid argument '%s', must be a positive integer <= INT64_MAX\n",

  539.                    fstr);

  540.             FAIL(AVERROR(EINVAL));

  541.         }

  542.         (*frames)[i] = f;

  543. 

  544.         /* check on monotonicity */

  545.         if (i && (*frames)[i-1] > (*frames)[i]) {

  546.             av_log(log_ctx, AV_LOG_ERROR,

  547.                    "Specified frame %d is greater than the following frame %d\n",

  548.                    (*frames)[i], (*frames)[i-1]);

  549.             FAIL(AVERROR(EINVAL));

  550.         }

  551.     }

  552. 

  553. end:

  554.     av_free(frames_str1);

  555.     return ret;

  556. }

  557. 

  558. static int open_null_ctx(AVIOContext **ctx)

  559. {

  560.     int buf_size = 32768;

  561.     uint8_t *buf = av_malloc(buf_size);

  562.     if (!buf)

  563.         return AVERROR(ENOMEM);

  564.     *ctx = avio_alloc_context(buf, buf_size, AVIO_FLAG_WRITE, NULL, NULL, NULL, NULL);

  565.     if (!*ctx) {

  566.         av_free(buf);

  567.         return AVERROR(ENOMEM);

  568.     }

  569.     return 0;

  570. }

  571. 

  572. static void close_null_ctxp(AVIOContext **pb)

  573. {

  574.     av_freep(&(*pb)->buffer);

  575.     av_freep(pb);

  576. }

  577. 

  578. static int select_reference_stream(AVFormatContext *s)

  579. {

  580.     SegmentContext *seg = s->priv_data;

  581.     int ret, i;

  582. 

  583.     seg->reference_stream_index = -1;

  584.     if (!strcmp(seg->reference_stream_specifier, "auto")) {

  585.         /* select first index of type with highest priority */

  586.         int type_index_map[AVMEDIA_TYPE_NB];

  587.         static const enum AVMediaType type_priority_list[] = {

  588.             AVMEDIA_TYPE_VIDEO,

  589.             AVMEDIA_TYPE_AUDIO,

  590.             AVMEDIA_TYPE_SUBTITLE,

  591.             AVMEDIA_TYPE_DATA,

  592.             AVMEDIA_TYPE_ATTACHMENT

  593.         };

  594.         enum AVMediaType type;

  595. 

  596.         for (i = 0; i < AVMEDIA_TYPE_NB; i++)

  597.             type_index_map[i] = -1;

  598. 

  599.         /* select first index for each type */

  600.         for (i = 0; i < s->nb_streams; i++) {

  601.             type = s->streams[i]->codecpar->codec_type;

  602.             if ((unsigned)type < AVMEDIA_TYPE_NB && type_index_map[type] == -1

  603.                 /* ignore attached pictures/cover art streams */

  604.                 && !(s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC))

  605.                 type_index_map[type] = i;

  606.         }

  607. 

  608.         for (i = 0; i < FF_ARRAY_ELEMS(type_priority_list); i++) {

  609.             type = type_priority_list[i];

  610.             if ((seg->reference_stream_index = type_index_map[type]) >= 0)

  611.                 break;

  612.         }

  613.     } else {

  614.         for (i = 0; i < s->nb_streams; i++) {

  615.             ret = avformat_match_stream_specifier(s, s->streams[i],

  616.                                                   seg->reference_stream_specifier);

  617.             if (ret < 0)

  618.                 return ret;

  619.             if (ret > 0) {

  620.                 seg->reference_stream_index = i;

  621.                 break;

  622.             }

  623.         }

  624.     }

  625. 

  626.     if (seg->reference_stream_index < 0) {

  627.         av_log(s, AV_LOG_ERROR, "Could not select stream matching identifier '%s'\n",

  628.                seg->reference_stream_specifier);

  629.         return AVERROR(EINVAL);

  630.     }

  631. 

  632.     return 0;

  633. }

  634. 

  635. static void seg_free(AVFormatContext *s)

  636. {

  637.     SegmentContext *seg = s->priv_data;

  638.     ff_format_io_close(seg->avf, &seg->list_pb);

  639.     avformat_free_context(seg->avf);

  640.     seg->avf = NULL;

  641. }

  642. 

  643. static int seg_init(AVFormatContext *s)

  644. {

  645.     SegmentContext *seg = s->priv_data;

  646.     AVFormatContext *oc = seg->avf;

  647.     AVDictionary *options = NULL;

  648.     int ret;

  649.     int i;

  650. 

  651.     seg->segment_count = 0;

  652.     if (!seg->write_header_trailer)

  653.         seg->individual_header_trailer = 0;

  654. 

  655.     if (seg->header_filename) {

  656.         seg->write_header_trailer = 1;

  657.         seg->individual_header_trailer = 0;

  658.     }

  659. 

  660.     if (seg->initial_offset > 0) {

  661.         av_log(s, AV_LOG_WARNING, "NOTE: the option initial_offset is deprecated,"

  662.                "you can use output_ts_offset instead of it\n");

  663.     }

  664. 

  665.     if (!!seg->time_str + !!seg->times_str + !!seg->frames_str > 1) {

  666.         av_log(s, AV_LOG_ERROR,

  667.                "segment_time, segment_times, and segment_frames options "

  668.                "are mutually exclusive, select just one of them\n");

  669.         return AVERROR(EINVAL);

  670.     }

  671. 

  672.     if (seg->times_str) {

  673.         if ((ret = parse_times(s, &seg->times, &seg->nb_times, seg->times_str)) < 0)

  674.             return ret;

  675.     } else if (seg->frames_str) {

  676.         if ((ret = parse_frames(s, &seg->frames, &seg->nb_frames, seg->frames_str)) < 0)

  677.             return ret;

  678.     } else {

  679.         /* set default value if not specified */

  680.         if (!seg->time_str)

  681.             seg->time_str = av_strdup("2");

  682.         if ((ret = av_parse_time(&seg->time, seg->time_str, 1)) < 0) {

  683.             av_log(s, AV_LOG_ERROR,

  684.                    "Invalid time duration specification '%s' for segment_time option\n",

  685.                    seg->time_str);

  686.             return ret;

  687.         }

  688.         if (seg->use_clocktime) {

  689.             if (seg->time <= 0) {

  690.                 av_log(s, AV_LOG_ERROR, "Invalid negative segment_time with segment_atclocktime option set\n");

  691.                 return AVERROR(EINVAL);

  692.             }

  693.             seg->clocktime_offset = seg->time - (seg->clocktime_offset % seg->time);

  694.         }

  695.     }

  696. 

  697.     if (seg->format_options_str) {

  698.         ret = av_dict_parse_string(&seg->format_options, seg->format_options_str, "=", ":", 0);

  699.         if (ret < 0) {

  700.             av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n",

  701.                    seg->format_options_str);

  702.             return ret;

  703.         }

  704.     }

  705. 

  706.     if (seg->list) {

  707.         if (seg->list_type == LIST_TYPE_UNDEFINED) {

  708.             if      (av_match_ext(seg->list, "csv" )) seg->list_type = LIST_TYPE_CSV;

  709.             else if (av_match_ext(seg->list, "ext" )) seg->list_type = LIST_TYPE_EXT;

  710.             else if (av_match_ext(seg->list, "m3u8")) seg->list_type = LIST_TYPE_M3U8;

  711.             else if (av_match_ext(seg->list, "ffcat,ffconcat")) seg->list_type = LIST_TYPE_FFCONCAT;

  712.             else                                      seg->list_type = LIST_TYPE_FLAT;

  713.         }

  714.         if (!seg->list_size && seg->list_type != LIST_TYPE_M3U8) {

  715.             if ((ret = segment_list_open(s)) < 0)

  716.                 return ret;

  717.         } else {

  718.             const char *proto = avio_find_protocol_name(seg->list);

  719.             seg->use_rename = proto && !strcmp(proto, "file");

  720.         }

  721.     }

  722. 

  723.     if (seg->list_type == LIST_TYPE_EXT)

  724.         av_log(s, AV_LOG_WARNING, "'ext' list type option is deprecated in favor of 'csv'\n");

  725. 

  726.     if ((ret = select_reference_stream(s)) < 0)

  727.         return ret;

  728.     av_log(s, AV_LOG_VERBOSE, "Selected stream id:%d type:%s\n",

  729.            seg->reference_stream_index,

  730.            av_get_media_type_string(s->streams[seg->reference_stream_index]->codecpar->codec_type));

  731. 

  732.     seg->oformat = av_guess_format(seg->format, s->filename, NULL);

  733. 

  734.     if (!seg->oformat)

  735.         return AVERROR_MUXER_NOT_FOUND;

  736.     if (seg->oformat->flags & AVFMT_NOFILE) {

  737.         av_log(s, AV_LOG_ERROR, "format %s not supported.\n",

  738.                seg->oformat->name);

  739.         return AVERROR(EINVAL);

  740.     }

  741. 

  742.     if ((ret = segment_mux_init(s)) < 0)

  743.         return ret;

  744. 

  745.     if ((ret = set_segment_filename(s)) < 0)

  746.         return ret;

  747.     oc = seg->avf;

  748. 

  749.     if (seg->write_header_trailer) {

  750.         if ((ret = s->io_open(s, &oc->pb,

  751.                               seg->header_filename ? seg->header_filename : oc->filename,

  752.                               AVIO_FLAG_WRITE, NULL)) < 0) {

  753.             av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", oc->filename);

  754.             return ret;

  755.         }

  756.         if (!seg->individual_header_trailer)

  757.             oc->pb->seekable = 0;

  758.     } else {

  759.         if ((ret = open_null_ctx(&oc->pb)) < 0)

  760.             return ret;

  761.     }

  762. 

  763.     av_dict_copy(&options, seg->format_options, 0);

  764.     av_dict_set(&options, "fflags", "-autobsf", 0);

  765.     ret = avformat_init_output(oc, &options);

  766.     if (av_dict_count(options)) {

  767.         av_log(s, AV_LOG_ERROR,

  768.                "Some of the provided format options in '%s' are not recognized\n", seg->format_options_str);

  769.         av_dict_free(&options);

  770.         return AVERROR(EINVAL);

  771.     }

  772.     av_dict_free(&options);

  773. 

  774.     if (ret < 0) {

  775.         ff_format_io_close(oc, &oc->pb);

  776.         return ret;

  777.     }

  778.     seg->segment_frame_count = 0;

  779. 

  780.     av_assert0(s->nb_streams == oc->nb_streams);

  781.     if (ret == AVSTREAM_INIT_IN_WRITE_HEADER) {

  782.         ret = avformat_write_header(oc, NULL);

  783.         if (ret < 0)

  784.             return ret;

  785.         seg->header_written = 1;

  786.     }

  787. 

  788.     for (i = 0; i < s->nb_streams; i++) {

  789.         AVStream *inner_st  = oc->streams[i];

  790.         AVStream *outer_st = s->streams[i];

  791.         avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);

  792.     }

  793. 

  794.     if (oc->avoid_negative_ts > 0 && s->avoid_negative_ts < 0)

  795.         s->avoid_negative_ts = 1;

  796. 

  797.     return ret;

  798. }

  799. 

  800. static int seg_write_header(AVFormatContext *s)

  801. {

  802.     SegmentContext *seg = s->priv_data;

  803.     AVFormatContext *oc = seg->avf;

  804.     int ret, i;

  805. 

  806.     if (!seg->header_written) {

  807.         for (i = 0; i < s->nb_streams; i++) {

  808.             AVStream *st = oc->streams[i];

  809.             AVCodecParameters *ipar, *opar;

  810. 

  811.             ipar = s->streams[i]->codecpar;

  812.             opar = oc->streams[i]->codecpar;

  813.             avcodec_parameters_copy(opar, ipar);

  814.             if (!oc->oformat->codec_tag ||

  815.                 av_codec_get_id (oc->oformat->codec_tag, ipar->codec_tag) == opar->codec_id ||

  816.                 av_codec_get_tag(oc->oformat->codec_tag, ipar->codec_id) <= 0) {

  817.                 opar->codec_tag = ipar->codec_tag;

  818.             } else {

  819.                 opar->codec_tag = 0;

  820.             }

  821.             st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;

  822.             st->time_base = s->streams[i]->time_base;

  823.         }

  824.         ret = avformat_write_header(oc, NULL);

  825.         if (ret < 0)

  826.             return ret;

  827.     }

  828. 

  829.     if (!seg->write_header_trailer || seg->header_filename) {

  830.         if (seg->header_filename) {

  831.             av_write_frame(oc, NULL);

  832.             ff_format_io_close(oc, &oc->pb);

  833.         } else {

  834.             close_null_ctxp(&oc->pb);

  835.         }

  836.         if ((ret = oc->io_open(oc, &oc->pb, oc->filename, AVIO_FLAG_WRITE, NULL)) < 0)

  837.             return ret;

  838.         if (!seg->individual_header_trailer)

  839.             oc->pb->seekable = 0;

  840.     }

  841. 

  842.     return 0;

  843. }

  844. 

  845. static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)

  846. {

  847.     SegmentContext *seg = s->priv_data;

  848.     AVStream *st = s->streams[pkt->stream_index];

  849.     int64_t end_pts = INT64_MAX, offset;

  850.     int start_frame = INT_MAX;

  851.     int ret;

  852.     struct tm ti;

  853.     int64_t usecs;

  854.     int64_t wrapped_val;

  855. 

  856.     if (!seg->avf || !seg->avf->pb)

  857.         return AVERROR(EINVAL);

  858. 

  859. calc_times:

  860.     if (seg->times) {

  861.         end_pts = seg->segment_count < seg->nb_times ?

  862.             seg->times[seg->segment_count] : INT64_MAX;

  863.     } else if (seg->frames) {

  864.         start_frame = seg->segment_count < seg->nb_frames ?

  865.             seg->frames[seg->segment_count] : INT_MAX;

  866.     } else {

  867.         if (seg->use_clocktime) {

  868.             int64_t avgt = av_gettime();

  869.             time_t sec = avgt / 1000000;

  870.             localtime_r(&sec, &ti);

  871.             usecs = (int64_t)(ti.tm_hour * 3600 + ti.tm_min * 60 + ti.tm_sec) * 1000000 + (avgt % 1000000);

  872.             wrapped_val = (usecs + seg->clocktime_offset) % seg->time;

  873.             if (seg->last_cut != usecs && wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration) {

  874.                 seg->cut_pending = 1;

  875.                 seg->last_cut = usecs;

  876.             }

  877.             seg->last_val = wrapped_val;

  878.         } else {

  879.             end_pts = seg->time * (seg->segment_count + 1);

  880.         }

  881.     }

  882. 

  883.     ff_dlog(s, "packet stream:%d pts:%s pts_time:%s duration_time:%s is_key:%d frame:%d\n",

  884.             pkt->stream_index, av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),

  885.             av_ts2timestr(pkt->duration, &st->time_base),

  886.             pkt->flags & AV_PKT_FLAG_KEY,

  887.             pkt->stream_index == seg->reference_stream_index ? seg->frame_count : -1);

  888. 

  889.     if (pkt->stream_index == seg->reference_stream_index &&

  890.         (pkt->flags & AV_PKT_FLAG_KEY || seg->break_non_keyframes) &&

  891.         (seg->segment_frame_count > 0 || seg->write_empty) &&

  892.         (seg->cut_pending || seg->frame_count >= start_frame ||

  893.          (pkt->pts != AV_NOPTS_VALUE &&

  894.           av_compare_ts(pkt->pts, st->time_base,

  895.                         end_pts - seg->time_delta, AV_TIME_BASE_Q) >= 0))) {

  896.         /* sanitize end time in case last packet didn't have a defined duration */

  897.         if (seg->cur_entry.last_duration == 0)

  898.             seg->cur_entry.end_time = (double)pkt->pts * av_q2d(st->time_base);

  899. 

  900.         if ((ret = segment_end(s, seg->individual_header_trailer, 0)) < 0)

  901.             goto fail;

  902. 

  903.         if ((ret = segment_start(s, seg->individual_header_trailer)) < 0)

  904.             goto fail;

  905. 

  906.         seg->cut_pending = 0;

  907.         seg->cur_entry.index = seg->segment_idx + seg->segment_idx_wrap * seg->segment_idx_wrap_nb;

  908.         seg->cur_entry.start_time = (double)pkt->pts * av_q2d(st->time_base);

  909.         seg->cur_entry.start_pts = av_rescale_q(pkt->pts, st->time_base, AV_TIME_BASE_Q);

  910.         seg->cur_entry.end_time = seg->cur_entry.start_time;

  911. 

  912.         if (seg->times || (!seg->frames && !seg->use_clocktime) && seg->write_empty)

  913.             goto calc_times;

  914.     }

  915. 

  916.     if (pkt->stream_index == seg->reference_stream_index) {

  917.         if (pkt->pts != AV_NOPTS_VALUE)

  918.             seg->cur_entry.end_time =

  919.                 FFMAX(seg->cur_entry.end_time, (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));

  920.         seg->cur_entry.last_duration = pkt->duration;

  921.     }

  922. 

  923.     if (seg->segment_frame_count == 0) {

  924.         av_log(s, AV_LOG_VERBOSE, "segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d\n",

  925.                seg->avf->filename, pkt->stream_index,

  926.                av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base), seg->frame_count);

  927.     }

  928. 

  929.     av_log(s, AV_LOG_DEBUG, "stream:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s",

  930.            pkt->stream_index,

  931.            av_ts2timestr(seg->cur_entry.start_pts, &AV_TIME_BASE_Q),

  932.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),

  933.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));

  934. 

  935.     /* compute new timestamps */

  936.     offset = av_rescale_q(seg->initial_offset - (seg->reset_timestamps ? seg->cur_entry.start_pts : 0),

  937.                           AV_TIME_BASE_Q, st->time_base);

  938.     if (pkt->pts != AV_NOPTS_VALUE)

  939.         pkt->pts += offset;

  940.     if (pkt->dts != AV_NOPTS_VALUE)

  941.         pkt->dts += offset;

  942. 

  943.     av_log(s, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",

  944.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),

  945.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));

  946. 

  947.     ret = ff_write_chained(seg->avf, pkt->stream_index, pkt, s, seg->initial_offset || seg->reset_timestamps);

  948. 

  949. fail:

  950.     if (pkt->stream_index == seg->reference_stream_index) {

  951.         seg->frame_count++;

  952.         seg->segment_frame_count++;

  953.     }

  954. 

  955.     return ret;

  956. }

  957. 

  958. static int seg_write_trailer(struct AVFormatContext *s)

  959. {

  960.     SegmentContext *seg = s->priv_data;

  961.     AVFormatContext *oc = seg->avf;

  962.     SegmentListEntry *cur, *next;

  963.     int ret = 0;

  964. 

  965.     if (!oc)

  966.         goto fail;

  967. 

  968.     if (!seg->write_header_trailer) {

  969.         if ((ret = segment_end(s, 0, 1)) < 0)

  970.             goto fail;

  971.         if ((ret = open_null_ctx(&oc->pb)) < 0)

  972.             goto fail;

  973.         ret = av_write_trailer(oc);

  974.         close_null_ctxp(&oc->pb);

  975.     } else {

  976.         ret = segment_end(s, 1, 1);

  977.     }

  978. fail:

  979.     if (seg->list)

  980.         ff_format_io_close(s, &seg->list_pb);

  981. 

  982.     av_dict_free(&seg->format_options);

  983.     av_opt_free(seg);

  984.     av_freep(&seg->times);

  985.     av_freep(&seg->frames);

  986.     av_freep(&seg->cur_entry.filename);

  987. 

  988.     cur = seg->segment_list_entries;

  989.     while (cur) {

  990.         next = cur->next;

  991.         av_freep(&cur->filename);

  992.         av_free(cur);

  993.         cur = next;

  994.     }

  995. 

  996.     avformat_free_context(oc);

  997.     seg->avf = NULL;

  998.     return ret;

  999. }

  1000. 

  1001. static int seg_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)

  1002. {

  1003.     SegmentContext *seg = s->priv_data;

  1004.     AVFormatContext *oc = seg->avf;

  1005.     if (oc->oformat->check_bitstream) {

  1006.         int ret = oc->oformat->check_bitstream(oc, pkt);

  1007.         if (ret == 1) {

  1008.             AVStream *st = s->streams[pkt->stream_index];

  1009.             AVStream *ost = oc->streams[pkt->stream_index];

  1010.             st->internal->bsfcs = ost->internal->bsfcs;

  1011.             st->internal->nb_bsfcs = ost->internal->nb_bsfcs;

  1012.             ost->internal->bsfcs = NULL;

  1013.             ost->internal->nb_bsfcs = 0;

  1014.         }

  1015.         return ret;

  1016.     }

  1017.     return 1;

  1018. }

  1019. 

  1020. #define OFFSET(x) offsetof(SegmentContext, x)

  1021. #define E AV_OPT_FLAG_ENCODING_PARAM

  1022. static const AVOption options[] = {

  1023.     { "reference_stream",  "set reference stream", OFFSET(reference_stream_specifier), AV_OPT_TYPE_STRING, {.str = "auto"}, CHAR_MIN, CHAR_MAX, E },

  1024.     { "segment_format",    "set container format used for the segments", OFFSET(format),  AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },

  1025.     { "segment_format_options", "set list of options for the container format used for the segments", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },

  1026.     { "segment_list",      "set the segment list filename",              OFFSET(list),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },

  1027.     { "segment_header_filename", "write a single file containing the header", OFFSET(header_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },

  1028. 

  1029.     { "segment_list_flags","set flags affecting segment list generation", OFFSET(list_flags), AV_OPT_TYPE_FLAGS, {.i64 = SEGMENT_LIST_FLAG_CACHE }, 0, UINT_MAX, E, "list_flags"},

  1030.     { "cache",             "allow list caching",                                    0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_LIST_FLAG_CACHE }, INT_MIN, INT_MAX,   E, "list_flags"},

  1031.     { "live",              "enable live-friendly list generation (useful for HLS)", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_LIST_FLAG_LIVE }, INT_MIN, INT_MAX,    E, "list_flags"},

  1032. 

  1033.     { "segment_list_size", "set the maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT,  {.i64 = 0},     0, INT_MAX, E },

  1034. 

  1035.     { "segment_list_type", "set the segment list type",                  OFFSET(list_type), AV_OPT_TYPE_INT,  {.i64 = LIST_TYPE_UNDEFINED}, -1, LIST_TYPE_NB-1, E, "list_type" },

  1036.     { "flat", "flat format",     0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, E, "list_type" },

  1037.     { "csv",  "csv format",      0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_CSV  }, INT_MIN, INT_MAX, E, "list_type" },

  1038.     { "ext",  "extended format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_EXT  }, INT_MIN, INT_MAX, E, "list_type" },

  1039.     { "ffconcat", "ffconcat format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_FFCONCAT }, INT_MIN, INT_MAX, E, "list_type" },

  1040.     { "m3u8", "M3U8 format",     0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, "list_type" },

  1041.     { "hls", "Apple HTTP Live Streaming compatible", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, "list_type" },

  1042. 

  1043.     { "segment_atclocktime",      "set segment to be cut at clocktime",  OFFSET(use_clocktime), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E},

  1044.     { "segment_clocktime_offset", "set segment clocktime offset",        OFFSET(clocktime_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, 86400000000LL, E},

  1045.     { "segment_clocktime_wrap_duration", "set segment clocktime wrapping duration", OFFSET(clocktime_wrap_duration), AV_OPT_TYPE_DURATION, {.i64 = INT64_MAX}, 0, INT64_MAX, E},

  1046.     { "segment_time",      "set segment duration",                       OFFSET(time_str),AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },

  1047.     { "segment_time_delta","set approximation value used for the segment times", OFFSET(time_delta), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, 0, E },

  1048.     { "segment_times",     "set segment split time points",              OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL},  0, 0,       E },

  1049.     { "segment_frames",    "set segment split frame numbers",            OFFSET(frames_str),AV_OPT_TYPE_STRING,{.str = NULL},  0, 0,       E },

  1050.     { "segment_wrap",      "set number after which the index wraps",     OFFSET(segment_idx_wrap), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },

  1051.     { "segment_list_entry_prefix", "set base url prefix for segments", OFFSET(entry_prefix), AV_OPT_TYPE_STRING,  {.str = NULL}, 0, 0, E },

  1052.     { "segment_start_number", "set the sequence number of the first segment", OFFSET(segment_idx), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },

  1053.     { "segment_wrap_number", "set the number of wrap before the first segment", OFFSET(segment_idx_wrap_nb), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },

  1054.     { "strftime",          "set filename expansion with strftime at segment creation", OFFSET(use_strftime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },

  1055.     { "increment_tc", "increment timecode between each segment", OFFSET(increment_tc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },

  1056.     { "break_non_keyframes", "allow breaking segments on non-keyframes", OFFSET(break_non_keyframes), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },

  1057. 

  1058.     { "individual_header_trailer", "write header/trailer to each segment", OFFSET(individual_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },

  1059.     { "write_header_trailer", "write a header to the first segment and a trailer to the last one", OFFSET(write_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },

  1060.     { "reset_timestamps", "reset timestamps at the begin of each segment", OFFSET(reset_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },

  1061.     { "initial_offset", "set initial timestamp offset", OFFSET(initial_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX, INT64_MAX, E },

  1062.     { "write_empty_segments", "allow writing empty 'filler' segments", OFFSET(write_empty), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },

  1063.     { NULL },

  1064. };

  1065. 

  1066. static const AVClass seg_class = {

  1067.     .class_name = "segment muxer",

  1068.     .item_name  = av_default_item_name,

  1069.     .option     = options,

  1070.     .version    = LIBAVUTIL_VERSION_INT,

  1071. };

  1072. 

  1073. AVOutputFormat ff_segment_muxer = {

  1074.     .name           = "segment",

  1075.     .long_name      = NULL_IF_CONFIG_SMALL("segment"),

  1076.     .priv_data_size = sizeof(SegmentContext),

  1077.     .flags          = AVFMT_NOFILE|AVFMT_GLOBALHEADER,

  1078.     .init           = seg_init,

  1079.     .write_header   = seg_write_header,

  1080.     .write_packet   = seg_write_packet,

  1081.     .write_trailer  = seg_write_trailer,

  1082.     .deinit         = seg_free,

  1083.     .check_bitstream = seg_check_bitstream,

  1084.     .priv_class     = &seg_class,

  1085. };

  1086. 

  1087. static const AVClass sseg_class = {

  1088.     .class_name = "stream_segment muxer",

  1089.     .item_name  = av_default_item_name,

  1090.     .option     = options,

  1091.     .version    = LIBAVUTIL_VERSION_INT,

  1092. };

  1093. 

  1094. AVOutputFormat ff_stream_segment_muxer = {

  1095.     .name           = "stream_segment,ssegment",

  1096.     .long_name      = NULL_IF_CONFIG_SMALL("streaming segment muxer"),

  1097.     .priv_data_size = sizeof(SegmentContext),

  1098.     .flags          = AVFMT_NOFILE,

  1099.     .init           = seg_init,

  1100.     .write_header   = seg_write_header,

  1101.     .write_packet   = seg_write_packet,

  1102.     .write_trailer  = seg_write_trailer,

  1103.     .deinit         = seg_free,

  1104.     .check_bitstream = seg_check_bitstream,

  1105.     .priv_class     = &sseg_class,

  1106. };