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.
82196 Commits
32 Branches
293MB
Tree: 8e6478b723
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8e6478b723'
${ noResults }
FFmpeg/libavformat/segment.c

1104 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.     av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */

  358.     if (write_trailer)

  359.         ret = av_write_trailer(oc);

  360. 

  361.     if (ret < 0)

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

  363.                oc->filename);

  364. 

  365.     if (seg->list) {

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

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

  368.             if (!entry) {

  369.                 ret = AVERROR(ENOMEM);

  370.                 goto end;

  371.             }

  372. 

  373.             /* append new element */

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

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

  376.             if (!seg->segment_list_entries)

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

  378.             else

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

  380.             seg->segment_list_entries_end = entry;

  381. 

  382.             /* drop first item */

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

  384.                 entry = seg->segment_list_entries;

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

  386.                 av_freep(&entry->filename);

  387.                 av_freep(&entry);

  388.             }

  389. 

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

  391.                 goto end;

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

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

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

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

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

  397.             if (seg->use_rename)

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

  399.         } else {

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

  401.             avio_flush(seg->list_pb);

  402.         }

  403.     }

  404. 

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

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

  407.     seg->segment_count++;

  408. 

  409.     if (seg->increment_tc) {

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

  411.         if (tcr) {

  412.             /* search the first video stream */

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

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

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

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

  417.                     if (err < 0) {

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

  419.                         break;

  420.                     }

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

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

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

  424.                     break;

  425.                 }

  426.             }

  427.         } else {

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

  429.         }

  430.     }

  431. 

  432. end:

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

  434. 

  435.     return ret;

  436. }

  437. 

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

  439.                        const char *times_str)

  440. {

  441.     char *p;

  442.     int i, ret = 0;

  443.     char *times_str1 = av_strdup(times_str);

  444.     char *saveptr = NULL;

  445. 

  446.     if (!times_str1)

  447.         return AVERROR(ENOMEM);

  448. 

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

  450. 

  451.     *nb_times = 1;

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

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

  454.             (*nb_times)++;

  455. 

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

  457.     if (!*times) {

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

  459.         FAIL(AVERROR(ENOMEM));

  460.     }

  461. 

  462.     p = times_str1;

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

  464.         int64_t t;

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

  466.         p = NULL;

  467. 

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

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

  470.                    times_str);

  471.             FAIL(AVERROR(EINVAL));

  472.         }

  473. 

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

  475.         if (ret < 0) {

  476.             av_log(log_ctx, AV_LOG_ERROR,

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

  478.             FAIL(AVERROR(EINVAL));

  479.         }

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

  481. 

  482.         /* check on monotonicity */

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

  484.             av_log(log_ctx, AV_LOG_ERROR,

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

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

  487.             FAIL(AVERROR(EINVAL));

  488.         }

  489.     }

  490. 

  491. end:

  492.     av_free(times_str1);

  493.     return ret;

  494. }

  495. 

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

  497.                         const char *frames_str)

  498. {

  499.     char *p;

  500.     int i, ret = 0;

  501.     char *frames_str1 = av_strdup(frames_str);

  502.     char *saveptr = NULL;

  503. 

  504.     if (!frames_str1)

  505.         return AVERROR(ENOMEM);

  506. 

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

  508. 

  509.     *nb_frames = 1;

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

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

  512.             (*nb_frames)++;

  513. 

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

  515.     if (!*frames) {

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

  517.         FAIL(AVERROR(ENOMEM));

  518.     }

  519. 

  520.     p = frames_str1;

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

  522.         long int f;

  523.         char *tailptr;

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

  525. 

  526.         p = NULL;

  527.         if (!fstr) {

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

  529.                    frames_str);

  530.             FAIL(AVERROR(EINVAL));

  531.         }

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

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

  534.             av_log(log_ctx, AV_LOG_ERROR,

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

  536.                    fstr);

  537.             FAIL(AVERROR(EINVAL));

  538.         }

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

  540. 

  541.         /* check on monotonicity */

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

  543.             av_log(log_ctx, AV_LOG_ERROR,

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

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

  546.             FAIL(AVERROR(EINVAL));

  547.         }

  548.     }

  549. 

  550. end:

  551.     av_free(frames_str1);

  552.     return ret;

  553. }

  554. 

  555. static int open_null_ctx(AVIOContext **ctx)

  556. {

  557.     int buf_size = 32768;

  558.     uint8_t *buf = av_malloc(buf_size);

  559.     if (!buf)

  560.         return AVERROR(ENOMEM);

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

  562.     if (!*ctx) {

  563.         av_free(buf);

  564.         return AVERROR(ENOMEM);

  565.     }

  566.     return 0;

  567. }

  568. 

  569. static void close_null_ctxp(AVIOContext **pb)

  570. {

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

  572.     av_freep(pb);

  573. }

  574. 

  575. static int select_reference_stream(AVFormatContext *s)

  576. {

  577.     SegmentContext *seg = s->priv_data;

  578.     int ret, i;

  579. 

  580.     seg->reference_stream_index = -1;

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

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

  583.         int type_index_map[AVMEDIA_TYPE_NB];

  584.         static const enum AVMediaType type_priority_list[] = {

  585.             AVMEDIA_TYPE_VIDEO,

  586.             AVMEDIA_TYPE_AUDIO,

  587.             AVMEDIA_TYPE_SUBTITLE,

  588.             AVMEDIA_TYPE_DATA,

  589.             AVMEDIA_TYPE_ATTACHMENT

  590.         };

  591.         enum AVMediaType type;

  592. 

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

  594.             type_index_map[i] = -1;

  595. 

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

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

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

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

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

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

  602.                 type_index_map[type] = i;

  603.         }

  604. 

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

  606.             type = type_priority_list[i];

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

  608.                 break;

  609.         }

  610.     } else {

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

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

  613.                                                   seg->reference_stream_specifier);

  614.             if (ret < 0)

  615.                 return ret;

  616.             if (ret > 0) {

  617.                 seg->reference_stream_index = i;

  618.                 break;

  619.             }

  620.         }

  621.     }

  622. 

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

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

  625.                seg->reference_stream_specifier);

  626.         return AVERROR(EINVAL);

  627.     }

  628. 

  629.     return 0;

  630. }

  631. 

  632. static void seg_free(AVFormatContext *s)

  633. {

  634.     SegmentContext *seg = s->priv_data;

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

  636.     avformat_free_context(seg->avf);

  637.     seg->avf = NULL;

  638. }

  639. 

  640. static int seg_init(AVFormatContext *s)

  641. {

  642.     SegmentContext *seg = s->priv_data;

  643.     AVFormatContext *oc = seg->avf;

  644.     AVDictionary *options = NULL;

  645.     int ret;

  646.     int i;

  647. 

  648.     seg->segment_count = 0;

  649.     if (!seg->write_header_trailer)

  650.         seg->individual_header_trailer = 0;

  651. 

  652.     if (seg->header_filename) {

  653.         seg->write_header_trailer = 1;

  654.         seg->individual_header_trailer = 0;

  655.     }

  656. 

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

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

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

  660.     }

  661. 

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

  663.         av_log(s, AV_LOG_ERROR,

  664.                "segment_time, segment_times, and segment_frames options "

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

  666.         return AVERROR(EINVAL);

  667.     }

  668. 

  669.     if (seg->times_str) {

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

  671.             return ret;

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

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

  674.             return ret;

  675.     } else {

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

  677.         if (!seg->time_str)

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

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

  680.             av_log(s, AV_LOG_ERROR,

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

  682.                    seg->time_str);

  683.             return ret;

  684.         }

  685.         if (seg->use_clocktime) {

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

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

  688.                 return AVERROR(EINVAL);

  689.             }

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

  691.         }

  692.     }

  693. 

  694.     if (seg->format_options_str) {

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

  696.         if (ret < 0) {

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

  698.                    seg->format_options_str);

  699.             return ret;

  700.         }

  701.     }

  702. 

  703.     if (seg->list) {

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

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

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

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

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

  709.             else                                      seg->list_type = LIST_TYPE_FLAT;

  710.         }

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

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

  713.                 return ret;

  714.         } else {

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

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

  717.         }

  718.     }

  719. 

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

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

  722. 

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

  724.         return ret;

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

  726.            seg->reference_stream_index,

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

  728. 

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

  730. 

  731.     if (!seg->oformat)

  732.         return AVERROR_MUXER_NOT_FOUND;

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

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

  735.                seg->oformat->name);

  736.         return AVERROR(EINVAL);

  737.     }

  738. 

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

  740.         return ret;

  741. 

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

  743.         return ret;

  744.     oc = seg->avf;

  745. 

  746.     if (seg->write_header_trailer) {

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

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

  749.                               AVIO_FLAG_WRITE, NULL)) < 0) {

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

  751.             return ret;

  752.         }

  753.         if (!seg->individual_header_trailer)

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

  755.     } else {

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

  757.             return ret;

  758.     }

  759. 

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

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

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

  763.     if (av_dict_count(options)) {

  764.         av_log(s, AV_LOG_ERROR,

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

  766.         av_dict_free(&options);

  767.         return AVERROR(EINVAL);

  768.     }

  769.     av_dict_free(&options);

  770. 

  771.     if (ret < 0) {

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

  773.         return ret;

  774.     }

  775.     seg->segment_frame_count = 0;

  776. 

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

  778.     if (ret == AVSTREAM_INIT_IN_WRITE_HEADER) {

  779.         ret = avformat_write_header(oc, NULL);

  780.         if (ret < 0)

  781.             return ret;

  782.         seg->header_written = 1;

  783.     }

  784. 

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

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

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

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

  789.     }

  790. 

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

  792.         s->avoid_negative_ts = 1;

  793. 

  794.     return ret;

  795. }

  796. 

  797. static int seg_write_header(AVFormatContext *s)

  798. {

  799.     SegmentContext *seg = s->priv_data;

  800.     AVFormatContext *oc = seg->avf;

  801.     int ret, i;

  802. 

  803.     if (!seg->header_written) {

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

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

  806.             AVCodecParameters *ipar, *opar;

  807. 

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

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

  810.             avcodec_parameters_copy(opar, ipar);

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

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

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

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

  815.             } else {

  816.                 opar->codec_tag = 0;

  817.             }

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

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

  820.         }

  821.         ret = avformat_write_header(oc, NULL);

  822.         if (ret < 0)

  823.             return ret;

  824.     }

  825. 

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

  827.         if (seg->header_filename) {

  828.             av_write_frame(oc, NULL);

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

  830.         } else {

  831.             close_null_ctxp(&oc->pb);

  832.         }

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

  834.             return ret;

  835.         if (!seg->individual_header_trailer)

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

  837.     }

  838. 

  839.     return 0;

  840. }

  841. 

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

  843. {

  844.     SegmentContext *seg = s->priv_data;

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

  846.     int64_t end_pts = INT64_MAX, offset;

  847.     int start_frame = INT_MAX;

  848.     int ret;

  849.     struct tm ti;

  850.     int64_t usecs;

  851.     int64_t wrapped_val;

  852. 

  853.     if (!seg->avf)

  854.         return AVERROR(EINVAL);

  855. 

  856. calc_times:

  857.     if (seg->times) {

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

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

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

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

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

  863.     } else {

  864.         if (seg->use_clocktime) {

  865.             int64_t avgt = av_gettime();

  866.             time_t sec = avgt / 1000000;

  867.             localtime_r(&sec, &ti);

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

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

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

  871.                 seg->cut_pending = 1;

  872.                 seg->last_cut = usecs;

  873.             }

  874.             seg->last_val = wrapped_val;

  875.         } else {

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

  877.         }

  878.     }

  879. 

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

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

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

  883.             pkt->flags & AV_PKT_FLAG_KEY,

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

  885. 

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

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

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

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

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

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

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

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

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

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

  896. 

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

  898.             goto fail;

  899. 

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

  901.             goto fail;

  902. 

  903.         seg->cut_pending = 0;

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

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

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

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

  908. 

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

  910.             goto calc_times;

  911.     }

  912. 

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

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

  915.             seg->cur_entry.end_time =

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

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

  918.     }

  919. 

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

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

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

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

  924.     }

  925. 

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

  927.            pkt->stream_index,

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

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

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

  931. 

  932.     /* compute new timestamps */

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

  934.                           AV_TIME_BASE_Q, st->time_base);

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

  936.         pkt->pts += offset;

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

  938.         pkt->dts += offset;

  939. 

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

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

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

  943. 

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

  945. 

  946. fail:

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

  948.         seg->frame_count++;

  949.         seg->segment_frame_count++;

  950.     }

  951. 

  952.     return ret;

  953. }

  954. 

  955. static int seg_write_trailer(struct AVFormatContext *s)

  956. {

  957.     SegmentContext *seg = s->priv_data;

  958.     AVFormatContext *oc = seg->avf;

  959.     SegmentListEntry *cur, *next;

  960.     int ret = 0;

  961. 

  962.     if (!oc)

  963.         goto fail;

  964. 

  965.     if (!seg->write_header_trailer) {

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

  967.             goto fail;

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

  969.             goto fail;

  970.         ret = av_write_trailer(oc);

  971.         close_null_ctxp(&oc->pb);

  972.     } else {

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

  974.     }

  975. fail:

  976.     if (seg->list)

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

  978. 

  979.     av_dict_free(&seg->format_options);

  980.     av_opt_free(seg);

  981.     av_freep(&seg->times);

  982.     av_freep(&seg->frames);

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

  984. 

  985.     cur = seg->segment_list_entries;

  986.     while (cur) {

  987.         next = cur->next;

  988.         av_freep(&cur->filename);

  989.         av_free(cur);

  990.         cur = next;

  991.     }

  992. 

  993.     avformat_free_context(oc);

  994.     seg->avf = NULL;

  995.     return ret;

  996. }

  997. 

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

  999. {

  1000.     SegmentContext *seg = s->priv_data;

  1001.     AVFormatContext *oc = seg->avf;

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

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

  1004.         if (ret == 1) {

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

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

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

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

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

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

  1011.         }

  1012.         return ret;

  1013.     }

  1014.     return 1;

  1015. }

  1016. 

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

  1018. #define E AV_OPT_FLAG_ENCODING_PARAM

  1019. static const AVOption options[] = {

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

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

  1022.     { "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 },

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

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

  1025. 

  1026.     { "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"},

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

  1028.     { "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"},

  1029. 

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

  1031. 

  1032.     { "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" },

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

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

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

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

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

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

  1039. 

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

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

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

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

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

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

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

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

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

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

  1050.     { "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 },

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

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

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

  1054. 

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

  1056.     { "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 },

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

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

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

  1060.     { NULL },

  1061. };

  1062. 

  1063. static const AVClass seg_class = {

  1064.     .class_name = "segment muxer",

  1065.     .item_name  = av_default_item_name,

  1066.     .option     = options,

  1067.     .version    = LIBAVUTIL_VERSION_INT,

  1068. };

  1069. 

  1070. AVOutputFormat ff_segment_muxer = {

  1071.     .name           = "segment",

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

  1073.     .priv_data_size = sizeof(SegmentContext),

  1074.     .flags          = AVFMT_NOFILE|AVFMT_GLOBALHEADER,

  1075.     .init           = seg_init,

  1076.     .write_header   = seg_write_header,

  1077.     .write_packet   = seg_write_packet,

  1078.     .write_trailer  = seg_write_trailer,

  1079.     .deinit         = seg_free,

  1080.     .check_bitstream = seg_check_bitstream,

  1081.     .priv_class     = &seg_class,

  1082. };

  1083. 

  1084. static const AVClass sseg_class = {

  1085.     .class_name = "stream_segment muxer",

  1086.     .item_name  = av_default_item_name,

  1087.     .option     = options,

  1088.     .version    = LIBAVUTIL_VERSION_INT,

  1089. };

  1090. 

  1091. AVOutputFormat ff_stream_segment_muxer = {

  1092.     .name           = "stream_segment,ssegment",

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

  1094.     .priv_data_size = sizeof(SegmentContext),

  1095.     .flags          = AVFMT_NOFILE,

  1096.     .init           = seg_init,

  1097.     .write_header   = seg_write_header,

  1098.     .write_packet   = seg_write_packet,

  1099.     .write_trailer  = seg_write_trailer,

  1100.     .deinit         = seg_free,

  1101.     .check_bitstream = seg_check_bitstream,

  1102.     .priv_class     = &sseg_class,

  1103. };