Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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