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

1112 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. #include <float.h>

  28. #include <time.h>

  29. 

  30. #include "avformat.h"

  31. #include "avio_internal.h"

  32. #include "internal.h"

  33. 

  34. #include "libavutil/avassert.h"

  35. #include "libavutil/internal.h"

  36. #include "libavutil/log.h"

  37. #include "libavutil/opt.h"

  38. #include "libavutil/avstring.h"

  39. #include "libavutil/parseutils.h"

  40. #include "libavutil/mathematics.h"

  41. #include "libavutil/time.h"

  42. #include "libavutil/timecode.h"

  43. #include "libavutil/time_internal.h"

  44. #include "libavutil/timestamp.h"

  45. 

  46. typedef struct SegmentListEntry {

  47.     int index;

  48.     double start_time, end_time;

  49.     int64_t start_pts;

  50.     int64_t offset_pts;

  51.     char *filename;

  52.     struct SegmentListEntry *next;

  53.     int64_t last_duration;

  54. } SegmentListEntry;

  55. 

  56. typedef enum {

  57.     LIST_TYPE_UNDEFINED = -1,

  58.     LIST_TYPE_FLAT = 0,

  59.     LIST_TYPE_CSV,

  60.     LIST_TYPE_M3U8,

  61.     LIST_TYPE_EXT, ///< deprecated

  62.     LIST_TYPE_FFCONCAT,

  63.     LIST_TYPE_NB,

  64. } ListType;

  65. 

  66. #define SEGMENT_LIST_FLAG_CACHE 1

  67. #define SEGMENT_LIST_FLAG_LIVE  2

  68. 

  69. typedef struct SegmentContext {

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

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

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

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

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

  75.     AVOutputFormat *oformat;

  76.     AVFormatContext *avf;

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

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

  79.     AVDictionary *format_options;

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

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

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

  83. 

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

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

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

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

  88.     int cut_pending;

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

  90. 

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

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

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

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

  95.     int64_t time;          ///< segment duration

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

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

  98. 

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

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

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

  102. 

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

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

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

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

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

  108. 

  109.     int64_t time_delta;

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

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

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

  113. 

  114.     int reset_timestamps;  ///< reset timestamps at the beginning of each segment

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

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

  117.     int   reference_stream_index;

  118.     int   break_non_keyframes;

  119.     int   write_empty;

  120. 

  121.     int use_rename;

  122.     char temp_list_filename[1024];

  123. 

  124.     SegmentListEntry cur_entry;

  125.     SegmentListEntry *segment_list_entries;

  126.     SegmentListEntry *segment_list_entries_end;

  127. } SegmentContext;

  128. 

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

  130. {

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

  132. 

  133.     if (needs_quoting)

  134.         avio_w8(ctx, '"');

  135. 

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

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

  138.             avio_w8(ctx, '"');

  139.         avio_w8(ctx, *str);

  140.     }

  141.     if (needs_quoting)

  142.         avio_w8(ctx, '"');

  143. }

  144. 

  145. static int segment_mux_init(AVFormatContext *s)

  146. {

  147.     SegmentContext *seg = s->priv_data;

  148.     AVFormatContext *oc;

  149.     int i;

  150.     int ret;

  151. 

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

  153.     if (ret < 0)

  154.         return ret;

  155.     oc = seg->avf;

  156. 

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

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

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

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

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

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

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

  164. 

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

  166.         AVStream *st;

  167.         AVCodecParameters *ipar, *opar;

  168. 

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

  170.             return AVERROR(ENOMEM);

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

  172.         opar = st->codecpar;

  173.         avcodec_parameters_copy(opar, ipar);

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

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

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

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

  178.         } else {

  179.             opar->codec_tag = 0;

  180.         }

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

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

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

  184.     }

  185. 

  186.     return 0;

  187. }

  188. 

  189. static int set_segment_filename(AVFormatContext *s)

  190. {

  191.     SegmentContext *seg = s->priv_data;

  192.     AVFormatContext *oc = seg->avf;

  193.     size_t size;

  194.     int ret;

  195.     char buf[1024];

  196.     char *new_name;

  197. 

  198.     if (seg->segment_idx_wrap)

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

  200.     if (seg->use_strftime) {

  201.         time_t now0;

  202.         struct tm *tm, tmpbuf;

  203.         time(&now0);

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

  205.         if (!strftime(buf, sizeof(buf), s->url, tm)) {

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

  207.             return AVERROR(EINVAL);

  208.         }

  209.     } else if (av_get_frame_filename(buf, sizeof(buf),

  210.                                      s->url, seg->segment_idx) < 0) {

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

  212.         return AVERROR(EINVAL);

  213.     }

  214.     new_name = av_strdup(buf);

  215.     if (!new_name)

  216.         return AVERROR(ENOMEM);

  217.     ff_format_set_url(oc, new_name);

  218. 

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

  220.     size = strlen(av_basename(oc->url)) + 1;

  221.     if (seg->entry_prefix)

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

  223. 

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

  225.         return ret;

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

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

  228.              av_basename(oc->url));

  229. 

  230.     return 0;

  231. }

  232. 

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

  234. {

  235.     SegmentContext *seg = s->priv_data;

  236.     AVFormatContext *oc = seg->avf;

  237.     int err = 0;

  238. 

  239.     if (write_header) {

  240.         avformat_free_context(oc);

  241.         seg->avf = NULL;

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

  243.             return err;

  244.         oc = seg->avf;

  245.     }

  246. 

  247.     seg->segment_idx++;

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

  249.         seg->segment_idx_wrap_nb++;

  250. 

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

  252.         return err;

  253. 

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

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

  256.         return err;

  257.     }

  258.     if (!seg->individual_header_trailer)

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

  260. 

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

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

  263. 

  264.     if (write_header) {

  265.         AVDictionary *options = NULL;

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

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

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

  269.         av_dict_free(&options);

  270.         if (err < 0)

  271.             return err;

  272.     }

  273. 

  274.     seg->segment_frame_count = 0;

  275.     return 0;

  276. }

  277. 

  278. static int segment_list_open(AVFormatContext *s)

  279. {

  280.     SegmentContext *seg = s->priv_data;

  281.     int ret;

  282. 

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

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

  285.     if (ret < 0) {

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

  287.         return ret;

  288.     }

  289. 

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

  291.         SegmentListEntry *entry;

  292.         double max_duration = 0;

  293. 

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

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

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

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

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

  299. 

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

  301.                seg->segment_list_entries->index);

  302. 

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

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

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

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

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

  308.     }

  309. 

  310.     return ret;

  311. }

  312. 

  313. static void segment_list_print_entry(AVIOContext      *list_ioctx,

  314.                                      ListType          list_type,

  315.                                      const SegmentListEntry *list_entry,

  316.                                      void *log_ctx)

  317. {

  318.     switch (list_type) {

  319.     case LIST_TYPE_FLAT:

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

  321.         break;

  322.     case LIST_TYPE_CSV:

  323.     case LIST_TYPE_EXT:

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

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

  326.         break;

  327.     case LIST_TYPE_M3U8:

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

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

  330.         break;

  331.     case LIST_TYPE_FFCONCAT:

  332.     {

  333.         char *buf;

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

  335.             av_log(log_ctx, AV_LOG_WARNING,

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

  337.             return;

  338.         }

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

  340.         av_free(buf);

  341.         break;

  342.     }

  343.     default:

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

  345.     }

  346. }

  347. 

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

  349. {

  350.     SegmentContext *seg = s->priv_data;

  351.     AVFormatContext *oc = seg->avf;

  352.     int ret = 0;

  353.     AVTimecode tc;

  354.     AVRational rate;

  355.     AVDictionaryEntry *tcr;

  356.     char buf[AV_TIMECODE_STR_SIZE];

  357.     int i;

  358.     int err;

  359. 

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

  361.         return AVERROR(EINVAL);

  362. 

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

  364.     if (write_trailer)

  365.         ret = av_write_trailer(oc);

  366. 

  367.     if (ret < 0)

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

  369.                oc->url);

  370. 

  371.     if (seg->list) {

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

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

  374.             if (!entry) {

  375.                 ret = AVERROR(ENOMEM);

  376.                 goto end;

  377.             }

  378. 

  379.             /* append new element */

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

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

  382.             if (!seg->segment_list_entries)

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

  384.             else

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

  386.             seg->segment_list_entries_end = entry;

  387. 

  388.             /* drop first item */

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

  390.                 entry = seg->segment_list_entries;

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

  392.                 av_freep(&entry->filename);

  393.                 av_freep(&entry);

  394.             }

  395. 

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

  397.                 goto end;

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

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

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

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

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

  403.             if (seg->use_rename)

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

  405.         } else {

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

  407.             avio_flush(seg->list_pb);

  408.         }

  409.     }

  410. 

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

  412.            seg->avf->url, seg->segment_count);

  413.     seg->segment_count++;

  414. 

  415.     if (seg->increment_tc) {

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

  417.         if (tcr) {

  418.             /* search the first video stream */

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

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

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

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

  423.                     if (err < 0) {

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

  425.                         break;

  426.                     }

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

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

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

  430.                     break;

  431.                 }

  432.             }

  433.         } else {

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

  435.         }

  436.     }

  437. 

  438. end:

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

  440. 

  441.     return ret;

  442. }

  443. 

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

  445.                        const char *times_str)

  446. {

  447.     char *p;

  448.     int i, ret = 0;

  449.     char *times_str1 = av_strdup(times_str);

  450.     char *saveptr = NULL;

  451. 

  452.     if (!times_str1)

  453.         return AVERROR(ENOMEM);

  454. 

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

  456. 

  457.     *nb_times = 1;

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

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

  460.             (*nb_times)++;

  461. 

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

  463.     if (!*times) {

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

  465.         FAIL(AVERROR(ENOMEM));

  466.     }

  467. 

  468.     p = times_str1;

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

  470.         int64_t t;

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

  472.         p = NULL;

  473. 

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

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

  476.                    times_str);

  477.             FAIL(AVERROR(EINVAL));

  478.         }

  479. 

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

  481.         if (ret < 0) {

  482.             av_log(log_ctx, AV_LOG_ERROR,

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

  484.             FAIL(AVERROR(EINVAL));

  485.         }

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

  487. 

  488.         /* check on monotonicity */

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

  490.             av_log(log_ctx, AV_LOG_ERROR,

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

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

  493.             FAIL(AVERROR(EINVAL));

  494.         }

  495.     }

  496. 

  497. end:

  498.     av_free(times_str1);

  499.     return ret;

  500. }

  501. 

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

  503.                         const char *frames_str)

  504. {

  505.     char *p;

  506.     int i, ret = 0;

  507.     char *frames_str1 = av_strdup(frames_str);

  508.     char *saveptr = NULL;

  509. 

  510.     if (!frames_str1)

  511.         return AVERROR(ENOMEM);

  512. 

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

  514. 

  515.     *nb_frames = 1;

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

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

  518.             (*nb_frames)++;

  519. 

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

  521.     if (!*frames) {

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

  523.         FAIL(AVERROR(ENOMEM));

  524.     }

  525. 

  526.     p = frames_str1;

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

  528.         long int f;

  529.         char *tailptr;

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

  531. 

  532.         p = NULL;

  533.         if (!fstr) {

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

  535.                    frames_str);

  536.             FAIL(AVERROR(EINVAL));

  537.         }

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

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

  540.             av_log(log_ctx, AV_LOG_ERROR,

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

  542.                    fstr);

  543.             FAIL(AVERROR(EINVAL));

  544.         }

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

  546. 

  547.         /* check on monotonicity */

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

  549.             av_log(log_ctx, AV_LOG_ERROR,

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

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

  552.             FAIL(AVERROR(EINVAL));

  553.         }

  554.     }

  555. 

  556. end:

  557.     av_free(frames_str1);

  558.     return ret;

  559. }

  560. 

  561. static int open_null_ctx(AVIOContext **ctx)

  562. {

  563.     int buf_size = 32768;

  564.     uint8_t *buf = av_malloc(buf_size);

  565.     if (!buf)

  566.         return AVERROR(ENOMEM);

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

  568.     if (!*ctx) {

  569.         av_free(buf);

  570.         return AVERROR(ENOMEM);

  571.     }

  572.     return 0;

  573. }

  574. 

  575. static void close_null_ctxp(AVIOContext **pb)

  576. {

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

  578.     avio_context_free(pb);

  579. }

  580. 

  581. static int select_reference_stream(AVFormatContext *s)

  582. {

  583.     SegmentContext *seg = s->priv_data;

  584.     int ret, i;

  585. 

  586.     seg->reference_stream_index = -1;

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

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

  589.         int type_index_map[AVMEDIA_TYPE_NB];

  590.         static const enum AVMediaType type_priority_list[] = {

  591.             AVMEDIA_TYPE_VIDEO,

  592.             AVMEDIA_TYPE_AUDIO,

  593.             AVMEDIA_TYPE_SUBTITLE,

  594.             AVMEDIA_TYPE_DATA,

  595.             AVMEDIA_TYPE_ATTACHMENT

  596.         };

  597.         enum AVMediaType type;

  598. 

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

  600.             type_index_map[i] = -1;

  601. 

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

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

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

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

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

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

  608.                 type_index_map[type] = i;

  609.         }

  610. 

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

  612.             type = type_priority_list[i];

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

  614.                 break;

  615.         }

  616.     } else {

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

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

  619.                                                   seg->reference_stream_specifier);

  620.             if (ret < 0)

  621.                 return ret;

  622.             if (ret > 0) {

  623.                 seg->reference_stream_index = i;

  624.                 break;

  625.             }

  626.         }

  627.     }

  628. 

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

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

  631.                seg->reference_stream_specifier);

  632.         return AVERROR(EINVAL);

  633.     }

  634. 

  635.     return 0;

  636. }

  637. 

  638. static void seg_free(AVFormatContext *s)

  639. {

  640.     SegmentContext *seg = s->priv_data;

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

  642.     avformat_free_context(seg->avf);

  643.     seg->avf = NULL;

  644. }

  645. 

  646. static int seg_init(AVFormatContext *s)

  647. {

  648.     SegmentContext *seg = s->priv_data;

  649.     AVFormatContext *oc = seg->avf;

  650.     AVDictionary *options = NULL;

  651.     int ret;

  652.     int i;

  653. 

  654.     seg->segment_count = 0;

  655.     if (!seg->write_header_trailer)

  656.         seg->individual_header_trailer = 0;

  657. 

  658.     if (seg->header_filename) {

  659.         seg->write_header_trailer = 1;

  660.         seg->individual_header_trailer = 0;

  661.     }

  662. 

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

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

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

  666.     }

  667. 

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

  669.         av_log(s, AV_LOG_ERROR,

  670.                "segment_time, segment_times, and segment_frames options "

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

  672.         return AVERROR(EINVAL);

  673.     }

  674. 

  675.     if (seg->times_str) {

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

  677.             return ret;

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

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

  680.             return ret;

  681.     } else {

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

  683.         if (!seg->time_str)

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

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

  686.             av_log(s, AV_LOG_ERROR,

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

  688.                    seg->time_str);

  689.             return ret;

  690.         }

  691.         if (seg->use_clocktime) {

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

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

  694.                 return AVERROR(EINVAL);

  695.             }

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

  697.         }

  698.     }

  699. 

  700.     if (seg->format_options_str) {

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

  702.         if (ret < 0) {

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

  704.                    seg->format_options_str);

  705.             return ret;

  706.         }

  707.     }

  708. 

  709.     if (seg->list) {

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

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

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

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

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

  715.             else                                      seg->list_type = LIST_TYPE_FLAT;

  716.         }

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

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

  719.                 return ret;

  720.         } else {

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

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

  723.         }

  724.     }

  725. 

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

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

  728. 

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

  730.         return ret;

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

  732.            seg->reference_stream_index,

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

  734. 

  735.     seg->oformat = av_guess_format(seg->format, s->url, NULL);

  736. 

  737.     if (!seg->oformat)

  738.         return AVERROR_MUXER_NOT_FOUND;

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

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

  741.                seg->oformat->name);

  742.         return AVERROR(EINVAL);

  743.     }

  744. 

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

  746.         return ret;

  747. 

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

  749.         return ret;

  750.     oc = seg->avf;

  751. 

  752.     if (seg->write_header_trailer) {

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

  754.                               seg->header_filename ? seg->header_filename : oc->url,

  755.                               AVIO_FLAG_WRITE, NULL)) < 0) {

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

  757.             return ret;

  758.         }

  759.         if (!seg->individual_header_trailer)

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

  761.     } else {

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

  763.             return ret;

  764.     }

  765. 

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

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

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

  769.     if (av_dict_count(options)) {

  770.         av_log(s, AV_LOG_ERROR,

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

  772.         av_dict_free(&options);

  773.         return AVERROR(EINVAL);

  774.     }

  775.     av_dict_free(&options);

  776. 

  777.     if (ret < 0) {

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

  779.         return ret;

  780.     }

  781.     seg->segment_frame_count = 0;

  782. 

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

  784.     if (ret == AVSTREAM_INIT_IN_WRITE_HEADER) {

  785.         ret = avformat_write_header(oc, NULL);

  786.         if (ret < 0)

  787.             return ret;

  788.         seg->header_written = 1;

  789.     }

  790. 

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

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

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

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

  795.     }

  796. 

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

  798.         s->avoid_negative_ts = 1;

  799. 

  800.     return ret;

  801. }

  802. 

  803. static int seg_write_header(AVFormatContext *s)

  804. {

  805.     SegmentContext *seg = s->priv_data;

  806.     AVFormatContext *oc = seg->avf;

  807.     int ret, i;

  808. 

  809.     if (!seg->header_written) {

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

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

  812.             AVCodecParameters *ipar, *opar;

  813. 

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

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

  816.             avcodec_parameters_copy(opar, ipar);

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

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

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

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

  821.             } else {

  822.                 opar->codec_tag = 0;

  823.             }

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

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

  826.         }

  827.         ret = avformat_write_header(oc, NULL);

  828.         if (ret < 0)

  829.             return ret;

  830.     }

  831. 

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

  833.         if (seg->header_filename) {

  834.             av_write_frame(oc, NULL);

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

  836.         } else {

  837.             close_null_ctxp(&oc->pb);

  838.         }

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

  840.             return ret;

  841.         if (!seg->individual_header_trailer)

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

  843.     }

  844. 

  845.     return 0;

  846. }

  847. 

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

  849. {

  850.     SegmentContext *seg = s->priv_data;

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

  852.     int64_t end_pts = INT64_MAX, offset;

  853.     int start_frame = INT_MAX;

  854.     int ret;

  855.     struct tm ti;

  856.     int64_t usecs;

  857.     int64_t wrapped_val;

  858. 

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

  860.         return AVERROR(EINVAL);

  861. 

  862. calc_times:

  863.     if (seg->times) {

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

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

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

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

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

  869.     } else {

  870.         if (seg->use_clocktime) {

  871.             int64_t avgt = av_gettime();

  872.             time_t sec = avgt / 1000000;

  873.             localtime_r(&sec, &ti);

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

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

  876.             if (wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration)

  877.                 seg->cut_pending = 1;

  878.             seg->last_val = wrapped_val;

  879.         } else {

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

  881.         }

  882.     }

  883. 

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

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

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

  887.             pkt->flags & AV_PKT_FLAG_KEY,

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

  889. 

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

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

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

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

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

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

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

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

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

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

  900. 

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

  902.             goto fail;

  903. 

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

  905.             goto fail;

  906. 

  907.         seg->cut_pending = 0;

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

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

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

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

  912. 

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

  914.             goto calc_times;

  915.     }

  916. 

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

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

  919.             seg->cur_entry.end_time =

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

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

  922.     }

  923. 

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

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

  926.                seg->avf->url, pkt->stream_index,

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

  928.     }

  929. 

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

  931.            pkt->stream_index,

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

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

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

  935. 

  936.     /* compute new timestamps */

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

  938.                           AV_TIME_BASE_Q, st->time_base);

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

  940.         pkt->pts += offset;

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

  942.         pkt->dts += offset;

  943. 

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

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

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

  947. 

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

  949. 

  950. fail:

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

  952.         seg->frame_count++;

  953.         seg->segment_frame_count++;

  954.     }

  955. 

  956.     return ret;

  957. }

  958. 

  959. static int seg_write_trailer(struct AVFormatContext *s)

  960. {

  961.     SegmentContext *seg = s->priv_data;

  962.     AVFormatContext *oc = seg->avf;

  963.     SegmentListEntry *cur, *next;

  964.     int ret = 0;

  965. 

  966.     if (!oc)

  967.         goto fail;

  968. 

  969.     if (!seg->write_header_trailer) {

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

  971.             goto fail;

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

  973.             goto fail;

  974.         ret = av_write_trailer(oc);

  975.         close_null_ctxp(&oc->pb);

  976.     } else {

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

  978.     }

  979. fail:

  980.     if (seg->list)

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

  982. 

  983.     av_dict_free(&seg->format_options);

  984.     av_opt_free(seg);

  985.     av_freep(&seg->times);

  986.     av_freep(&seg->frames);

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

  988. 

  989.     cur = seg->segment_list_entries;

  990.     while (cur) {

  991.         next = cur->next;

  992.         av_freep(&cur->filename);

  993.         av_free(cur);

  994.         cur = next;

  995.     }

  996. 

  997.     avformat_free_context(oc);

  998.     seg->avf = NULL;

  999.     return ret;

  1000. }

  1001. 

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

  1003. {

  1004.     SegmentContext *seg = s->priv_data;

  1005.     AVFormatContext *oc = seg->avf;

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

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

  1008.         if (ret == 1) {

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

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

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

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

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

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

  1015.         }

  1016.         return ret;

  1017.     }

  1018.     return 1;

  1019. }

  1020. 

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

  1022. #define E AV_OPT_FLAG_ENCODING_PARAM

  1023. static const AVOption options[] = {

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

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

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

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

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

  1029. 

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

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

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

  1033. 

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

  1035. 

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

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

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

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

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

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

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

  1043. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1058. 

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

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

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

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

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

  1064.     { NULL },

  1065. };

  1066. 

  1067. #if CONFIG_SEGMENT_MUXER

  1068. static const AVClass seg_class = {

  1069.     .class_name = "segment muxer",

  1070.     .item_name  = av_default_item_name,

  1071.     .option     = options,

  1072.     .version    = LIBAVUTIL_VERSION_INT,

  1073. };

  1074. 

  1075. AVOutputFormat ff_segment_muxer = {

  1076.     .name           = "segment",

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

  1078.     .priv_data_size = sizeof(SegmentContext),

  1079.     .flags          = AVFMT_NOFILE|AVFMT_GLOBALHEADER,

  1080.     .init           = seg_init,

  1081.     .write_header   = seg_write_header,

  1082.     .write_packet   = seg_write_packet,

  1083.     .write_trailer  = seg_write_trailer,

  1084.     .deinit         = seg_free,

  1085.     .check_bitstream = seg_check_bitstream,

  1086.     .priv_class     = &seg_class,

  1087. };

  1088. #endif

  1089. 

  1090. #if CONFIG_STREAM_SEGMENT_MUXER

  1091. static const AVClass sseg_class = {

  1092.     .class_name = "stream_segment muxer",

  1093.     .item_name  = av_default_item_name,

  1094.     .option     = options,

  1095.     .version    = LIBAVUTIL_VERSION_INT,

  1096. };

  1097. 

  1098. AVOutputFormat ff_stream_segment_muxer = {

  1099.     .name           = "stream_segment,ssegment",

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

  1101.     .priv_data_size = sizeof(SegmentContext),

  1102.     .flags          = AVFMT_NOFILE,

  1103.     .init           = seg_init,

  1104.     .write_header   = seg_write_header,

  1105.     .write_packet   = seg_write_packet,

  1106.     .write_trailer  = seg_write_trailer,

  1107.     .deinit         = seg_free,

  1108.     .check_bitstream = seg_check_bitstream,

  1109.     .priv_class     = &sseg_class,

  1110. };

  1111. #endif