1/* 2 * Live smooth streaming fragmenter 3 * Copyright (c) 2012 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#include "avc.h" 32#include "url.h" 33#include "isom.h" 34 35#include "libavutil/opt.h" 36#include "libavutil/avstring.h" 37#include "libavutil/mathematics.h" 38#include "libavutil/intreadwrite.h" 39 40typedef struct { 41 char file[1024]; 42 char infofile[1024]; 43 int64_t start_time, duration; 44 int n; 45 int64_t start_pos, size; 46} Fragment; 47 48typedef struct { 49 AVFormatContext *ctx; 50 int ctx_inited; 51 char dirname[1024]; 52 uint8_t iobuf[32768]; 53 URLContext *out; // Current output stream where all output is written 54 URLContext *out2; // Auxiliary output stream where all output is also written 55 URLContext *tail_out; // The actual main output stream, if we're currently seeked back to write elsewhere 56 int64_t tail_pos, cur_pos, cur_start_pos; 57 int packets_written; 58 const char *stream_type_tag; 59 int nb_fragments, fragments_size, fragment_index; 60 Fragment **fragments; 61 62 const char *fourcc; 63 char *private_str; 64 int packet_size; 65 int audio_tag; 66} OutputStream; 67 68typedef struct { 69 const AVClass *class; /* Class for private options. */ 70 int window_size; 71 int extra_window_size; 72 int lookahead_count; 73 int min_frag_duration; 74 int remove_at_exit; 75 OutputStream *streams; 76 int has_video, has_audio; 77 int nb_fragments; 78} SmoothStreamingContext; 79 80static int ism_write(void *opaque, uint8_t *buf, int buf_size) 81{ 82 OutputStream *os = opaque; 83 if (os->out) 84 ffurl_write(os->out, buf, buf_size); 85 if (os->out2) 86 ffurl_write(os->out2, buf, buf_size); 87 os->cur_pos += buf_size; 88 if (os->cur_pos >= os->tail_pos) 89 os->tail_pos = os->cur_pos; 90 return buf_size; 91} 92 93static int64_t ism_seek(void *opaque, int64_t offset, int whence) 94{ 95 OutputStream *os = opaque; 96 int i; 97 if (whence != SEEK_SET) 98 return AVERROR(ENOSYS); 99 if (os->tail_out) { 100 if (os->out) { 101 ffurl_close(os->out); 102 } 103 if (os->out2) { 104 ffurl_close(os->out2); 105 } 106 os->out = os->tail_out; 107 os->out2 = NULL; 108 os->tail_out = NULL; 109 } 110 if (offset >= os->cur_start_pos) { 111 if (os->out) 112 ffurl_seek(os->out, offset - os->cur_start_pos, SEEK_SET); 113 os->cur_pos = offset; 114 return offset; 115 } 116 for (i = os->nb_fragments - 1; i >= 0; i--) { 117 Fragment *frag = os->fragments[i]; 118 if (offset >= frag->start_pos && offset < frag->start_pos + frag->size) { 119 int ret; 120 AVDictionary *opts = NULL; 121 os->tail_out = os->out; 122 av_dict_set(&opts, "truncate", "0", 0); 123 ret = ffurl_open(&os->out, frag->file, AVIO_FLAG_READ_WRITE, &os->ctx->interrupt_callback, &opts); 124 av_dict_free(&opts); 125 if (ret < 0) { 126 os->out = os->tail_out; 127 os->tail_out = NULL; 128 return ret; 129 } 130 av_dict_set(&opts, "truncate", "0", 0); 131 ffurl_open(&os->out2, frag->infofile, AVIO_FLAG_READ_WRITE, &os->ctx->interrupt_callback, &opts); 132 av_dict_free(&opts); 133 ffurl_seek(os->out, offset - frag->start_pos, SEEK_SET); 134 if (os->out2) 135 ffurl_seek(os->out2, offset - frag->start_pos, SEEK_SET); 136 os->cur_pos = offset; 137 return offset; 138 } 139 } 140 return AVERROR(EIO); 141} 142 143static void get_private_data(OutputStream *os) 144{ 145 AVCodecContext *codec = os->ctx->streams[0]->codec; 146 uint8_t *ptr = codec->extradata; 147 int size = codec->extradata_size; 148 int i; 149 if (codec->codec_id == AV_CODEC_ID_H264) { 150 ff_avc_write_annexb_extradata(ptr, &ptr, &size); 151 if (!ptr) 152 ptr = codec->extradata; 153 } 154 if (!ptr) 155 return; 156 os->private_str = av_mallocz(2*size + 1); 157 if (!os->private_str) 158 goto fail; 159 for (i = 0; i < size; i++) 160 snprintf(&os->private_str[2*i], 3, "%02x", ptr[i]); 161fail: 162 if (ptr != codec->extradata) 163 av_free(ptr); 164} 165 166static void ism_free(AVFormatContext *s) 167{ 168 SmoothStreamingContext *c = s->priv_data; 169 int i, j; 170 if (!c->streams) 171 return; 172 for (i = 0; i < s->nb_streams; i++) { 173 OutputStream *os = &c->streams[i]; 174 ffurl_close(os->out); 175 ffurl_close(os->out2); 176 ffurl_close(os->tail_out); 177 os->out = os->out2 = os->tail_out = NULL; 178 if (os->ctx && os->ctx_inited) 179 av_write_trailer(os->ctx); 180 if (os->ctx && os->ctx->pb) 181 av_free(os->ctx->pb); 182 if (os->ctx) 183 avformat_free_context(os->ctx); 184 av_free(os->private_str); 185 for (j = 0; j < os->nb_fragments; j++) 186 av_free(os->fragments[j]); 187 av_free(os->fragments); 188 } 189 av_freep(&c->streams); 190} 191 192static void output_chunk_list(OutputStream *os, AVIOContext *out, int final, int skip, int window_size) 193{ 194 int removed = 0, i, start = 0; 195 if (os->nb_fragments <= 0) 196 return; 197 if (os->fragments[0]->n > 0) 198 removed = 1; 199 if (final) 200 skip = 0; 201 if (window_size) 202 start = FFMAX(os->nb_fragments - skip - window_size, 0); 203 for (i = start; i < os->nb_fragments - skip; i++) { 204 Fragment *frag = os->fragments[i]; 205 if (!final || removed) 206 avio_printf(out, "<c t=\"%"PRIu64"\" d=\"%"PRIu64"\" />\n", frag->start_time, frag->duration); 207 else 208 avio_printf(out, "<c n=\"%d\" d=\"%"PRIu64"\" />\n", frag->n, frag->duration); 209 } 210} 211 212static int write_manifest(AVFormatContext *s, int final) 213{ 214 SmoothStreamingContext *c = s->priv_data; 215 AVIOContext *out; 216 char filename[1024], temp_filename[1024]; 217 int ret, i, video_chunks = 0, audio_chunks = 0, video_streams = 0, audio_streams = 0; 218 int64_t duration = 0; 219 220 snprintf(filename, sizeof(filename), "%s/Manifest", s->filename); 221 snprintf(temp_filename, sizeof(temp_filename), "%s/Manifest.tmp", s->filename); 222 ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL); 223 if (ret < 0) { 224 av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename); 225 return ret; 226 } 227 avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"); 228 for (i = 0; i < s->nb_streams; i++) { 229 OutputStream *os = &c->streams[i]; 230 if (os->nb_fragments > 0) { 231 Fragment *last = os->fragments[os->nb_fragments - 1]; 232 duration = last->start_time + last->duration; 233 } 234 if (s->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 235 video_chunks = os->nb_fragments; 236 video_streams++; 237 } else { 238 audio_chunks = os->nb_fragments; 239 audio_streams++; 240 } 241 } 242 if (!final) { 243 duration = 0; 244 video_chunks = audio_chunks = 0; 245 } 246 if (c->window_size) { 247 video_chunks = FFMIN(video_chunks, c->window_size); 248 audio_chunks = FFMIN(audio_chunks, c->window_size); 249 } 250 avio_printf(out, "<SmoothStreamingMedia MajorVersion=\"2\" MinorVersion=\"0\" Duration=\"%"PRIu64"\"", duration); 251 if (!final) 252 avio_printf(out, " IsLive=\"true\" LookAheadFragmentCount=\"%d\" DVRWindowLength=\"0\"", c->lookahead_count); 253 avio_printf(out, ">\n"); 254 if (c->has_video) { 255 int last = -1, index = 0; 256 avio_printf(out, "<StreamIndex Type=\"video\" QualityLevels=\"%d\" Chunks=\"%d\" Url=\"QualityLevels({bitrate})/Fragments(video={start time})\">\n", video_streams, video_chunks); 257 for (i = 0; i < s->nb_streams; i++) { 258 OutputStream *os = &c->streams[i]; 259 if (s->streams[i]->codec->codec_type != AVMEDIA_TYPE_VIDEO) 260 continue; 261 last = i; 262 avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%d\" FourCC=\"%s\" MaxWidth=\"%d\" MaxHeight=\"%d\" CodecPrivateData=\"%s\" />\n", index, s->streams[i]->codec->bit_rate, os->fourcc, s->streams[i]->codec->width, s->streams[i]->codec->height, os->private_str); 263 index++; 264 } 265 output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size); 266 avio_printf(out, "</StreamIndex>\n"); 267 } 268 if (c->has_audio) { 269 int last = -1, index = 0; 270 avio_printf(out, "<StreamIndex Type=\"audio\" QualityLevels=\"%d\" Chunks=\"%d\" Url=\"QualityLevels({bitrate})/Fragments(audio={start time})\">\n", audio_streams, audio_chunks); 271 for (i = 0; i < s->nb_streams; i++) { 272 OutputStream *os = &c->streams[i]; 273 if (s->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO) 274 continue; 275 last = i; 276 avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%d\" FourCC=\"%s\" SamplingRate=\"%d\" Channels=\"%d\" BitsPerSample=\"16\" PacketSize=\"%d\" AudioTag=\"%d\" CodecPrivateData=\"%s\" />\n", index, s->streams[i]->codec->bit_rate, os->fourcc, s->streams[i]->codec->sample_rate, s->streams[i]->codec->channels, os->packet_size, os->audio_tag, os->private_str); 277 index++; 278 } 279 output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size); 280 avio_printf(out, "</StreamIndex>\n"); 281 } 282 avio_printf(out, "</SmoothStreamingMedia>\n"); 283 avio_flush(out); 284 avio_close(out); 285 rename(temp_filename, filename); 286 return 0; 287} 288 289static int ism_write_header(AVFormatContext *s) 290{ 291 SmoothStreamingContext *c = s->priv_data; 292 int ret = 0, i; 293 AVOutputFormat *oformat; 294 295 if (mkdir(s->filename, 0777) < 0) { 296 av_log(s, AV_LOG_ERROR, "mkdir failed\n"); 297 ret = AVERROR(errno); 298 goto fail; 299 } 300 301 oformat = av_guess_format("ismv", NULL, NULL); 302 if (!oformat) { 303 ret = AVERROR_MUXER_NOT_FOUND; 304 goto fail; 305 } 306 307 c->streams = av_mallocz_array(s->nb_streams, sizeof(*c->streams)); 308 if (!c->streams) { 309 ret = AVERROR(ENOMEM); 310 goto fail; 311 } 312 313 for (i = 0; i < s->nb_streams; i++) { 314 OutputStream *os = &c->streams[i]; 315 AVFormatContext *ctx; 316 AVStream *st; 317 AVDictionary *opts = NULL; 318 char buf[10]; 319 320 if (!s->streams[i]->codec->bit_rate) { 321 av_log(s, AV_LOG_ERROR, "No bit rate set for stream %d\n", i); 322 ret = AVERROR(EINVAL); 323 goto fail; 324 } 325 snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%d)", s->filename, s->streams[i]->codec->bit_rate); 326 if (mkdir(os->dirname, 0777) < 0) { 327 ret = AVERROR(errno); 328 av_log(s, AV_LOG_ERROR, "mkdir failed\n"); 329 goto fail; 330 } 331 332 ctx = avformat_alloc_context(); 333 if (!ctx) { 334 ret = AVERROR(ENOMEM); 335 goto fail; 336 } 337 os->ctx = ctx; 338 ctx->oformat = oformat; 339 ctx->interrupt_callback = s->interrupt_callback; 340 341 if (!(st = avformat_new_stream(ctx, NULL))) { 342 ret = AVERROR(ENOMEM); 343 goto fail; 344 } 345 avcodec_copy_context(st->codec, s->streams[i]->codec); 346 st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio; 347 348 ctx->pb = avio_alloc_context(os->iobuf, sizeof(os->iobuf), AVIO_FLAG_WRITE, os, NULL, ism_write, ism_seek); 349 if (!ctx->pb) { 350 ret = AVERROR(ENOMEM); 351 goto fail; 352 } 353 354 snprintf(buf, sizeof(buf), "%d", c->lookahead_count); 355 av_dict_set(&opts, "ism_lookahead", buf, 0); 356 av_dict_set(&opts, "movflags", "frag_custom", 0); 357 if ((ret = avformat_write_header(ctx, &opts)) < 0) { 358 goto fail; 359 } 360 os->ctx_inited = 1; 361 avio_flush(ctx->pb); 362 av_dict_free(&opts); 363 s->streams[i]->time_base = st->time_base; 364 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 365 c->has_video = 1; 366 os->stream_type_tag = "video"; 367 if (st->codec->codec_id == AV_CODEC_ID_H264) { 368 os->fourcc = "H264"; 369 } else if (st->codec->codec_id == AV_CODEC_ID_VC1) { 370 os->fourcc = "WVC1"; 371 } else { 372 av_log(s, AV_LOG_ERROR, "Unsupported video codec\n"); 373 ret = AVERROR(EINVAL); 374 goto fail; 375 } 376 } else { 377 c->has_audio = 1; 378 os->stream_type_tag = "audio"; 379 if (st->codec->codec_id == AV_CODEC_ID_AAC) { 380 os->fourcc = "AACL"; 381 os->audio_tag = 0xff; 382 } else if (st->codec->codec_id == AV_CODEC_ID_WMAPRO) { 383 os->fourcc = "WMAP"; 384 os->audio_tag = 0x0162; 385 } else { 386 av_log(s, AV_LOG_ERROR, "Unsupported audio codec\n"); 387 ret = AVERROR(EINVAL); 388 goto fail; 389 } 390 os->packet_size = st->codec->block_align ? st->codec->block_align : 4; 391 } 392 get_private_data(os); 393 } 394 395 if (!c->has_video && c->min_frag_duration <= 0) { 396 av_log(s, AV_LOG_WARNING, "no video stream and no min frag duration set\n"); 397 ret = AVERROR(EINVAL); 398 } 399 ret = write_manifest(s, 0); 400 401fail: 402 if (ret) 403 ism_free(s); 404 return ret; 405} 406 407static int parse_fragment(AVFormatContext *s, const char *filename, int64_t *start_ts, int64_t *duration, int64_t *moof_size, int64_t size) 408{ 409 AVIOContext *in; 410 int ret; 411 uint32_t len; 412 if ((ret = avio_open2(&in, filename, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0) 413 return ret; 414 ret = AVERROR(EIO); 415 *moof_size = avio_rb32(in); 416 if (*moof_size < 8 || *moof_size > size) 417 goto fail; 418 if (avio_rl32(in) != MKTAG('m','o','o','f')) 419 goto fail; 420 len = avio_rb32(in); 421 if (len > *moof_size) 422 goto fail; 423 if (avio_rl32(in) != MKTAG('m','f','h','d')) 424 goto fail; 425 avio_seek(in, len - 8, SEEK_CUR); 426 avio_rb32(in); /* traf size */ 427 if (avio_rl32(in) != MKTAG('t','r','a','f')) 428 goto fail; 429 while (avio_tell(in) < *moof_size) { 430 uint32_t len = avio_rb32(in); 431 uint32_t tag = avio_rl32(in); 432 int64_t end = avio_tell(in) + len - 8; 433 if (len < 8 || len >= *moof_size) 434 goto fail; 435 if (tag == MKTAG('u','u','i','d')) { 436 static const uint8_t tfxd[] = { 437 0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6, 438 0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2 439 }; 440 uint8_t uuid[16]; 441 avio_read(in, uuid, 16); 442 if (!memcmp(uuid, tfxd, 16) && len >= 8 + 16 + 4 + 16) { 443 avio_seek(in, 4, SEEK_CUR); 444 *start_ts = avio_rb64(in); 445 *duration = avio_rb64(in); 446 ret = 0; 447 break; 448 } 449 } 450 avio_seek(in, end, SEEK_SET); 451 } 452fail: 453 avio_close(in); 454 return ret; 455} 456 457static int add_fragment(OutputStream *os, const char *file, const char *infofile, int64_t start_time, int64_t duration, int64_t start_pos, int64_t size) 458{ 459 int err; 460 Fragment *frag; 461 if (os->nb_fragments >= os->fragments_size) { 462 os->fragments_size = (os->fragments_size + 1) * 2; 463 if ((err = av_reallocp(&os->fragments, sizeof(*os->fragments) * 464 os->fragments_size)) < 0) { 465 os->fragments_size = 0; 466 os->nb_fragments = 0; 467 return err; 468 } 469 } 470 frag = av_mallocz(sizeof(*frag)); 471 if (!frag) 472 return AVERROR(ENOMEM); 473 av_strlcpy(frag->file, file, sizeof(frag->file)); 474 av_strlcpy(frag->infofile, infofile, sizeof(frag->infofile)); 475 frag->start_time = start_time; 476 frag->duration = duration; 477 frag->start_pos = start_pos; 478 frag->size = size; 479 frag->n = os->fragment_index; 480 os->fragments[os->nb_fragments++] = frag; 481 os->fragment_index++; 482 return 0; 483} 484 485static int copy_moof(AVFormatContext *s, const char* infile, const char *outfile, int64_t size) 486{ 487 AVIOContext *in, *out; 488 int ret = 0; 489 if ((ret = avio_open2(&in, infile, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0) 490 return ret; 491 if ((ret = avio_open2(&out, outfile, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL)) < 0) { 492 avio_close(in); 493 return ret; 494 } 495 while (size > 0) { 496 uint8_t buf[8192]; 497 int n = FFMIN(size, sizeof(buf)); 498 n = avio_read(in, buf, n); 499 if (n <= 0) { 500 ret = AVERROR(EIO); 501 break; 502 } 503 avio_write(out, buf, n); 504 size -= n; 505 } 506 avio_flush(out); 507 avio_close(out); 508 avio_close(in); 509 return ret; 510} 511 512static int ism_flush(AVFormatContext *s, int final) 513{ 514 SmoothStreamingContext *c = s->priv_data; 515 int i, ret = 0; 516 517 for (i = 0; i < s->nb_streams; i++) { 518 OutputStream *os = &c->streams[i]; 519 char filename[1024], target_filename[1024], header_filename[1024]; 520 int64_t start_pos = os->tail_pos, size; 521 int64_t start_ts, duration, moof_size; 522 if (!os->packets_written) 523 continue; 524 525 snprintf(filename, sizeof(filename), "%s/temp", os->dirname); 526 ret = ffurl_open(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL); 527 if (ret < 0) 528 break; 529 os->cur_start_pos = os->tail_pos; 530 av_write_frame(os->ctx, NULL); 531 avio_flush(os->ctx->pb); 532 os->packets_written = 0; 533 if (!os->out || os->tail_out) 534 return AVERROR(EIO); 535 536 ffurl_close(os->out); 537 os->out = NULL; 538 size = os->tail_pos - start_pos; 539 if ((ret = parse_fragment(s, filename, &start_ts, &duration, &moof_size, size)) < 0) 540 break; 541 snprintf(header_filename, sizeof(header_filename), "%s/FragmentInfo(%s=%"PRIu64")", os->dirname, os->stream_type_tag, start_ts); 542 snprintf(target_filename, sizeof(target_filename), "%s/Fragments(%s=%"PRIu64")", os->dirname, os->stream_type_tag, start_ts); 543 copy_moof(s, filename, header_filename, moof_size); 544 rename(filename, target_filename); 545 add_fragment(os, target_filename, header_filename, start_ts, duration, start_pos, size); 546 } 547 548 if (c->window_size || (final && c->remove_at_exit)) { 549 for (i = 0; i < s->nb_streams; i++) { 550 OutputStream *os = &c->streams[i]; 551 int j; 552 int remove = os->nb_fragments - c->window_size - c->extra_window_size - c->lookahead_count; 553 if (final && c->remove_at_exit) 554 remove = os->nb_fragments; 555 if (remove > 0) { 556 for (j = 0; j < remove; j++) { 557 unlink(os->fragments[j]->file); 558 unlink(os->fragments[j]->infofile); 559 av_free(os->fragments[j]); 560 } 561 os->nb_fragments -= remove; 562 memmove(os->fragments, os->fragments + remove, os->nb_fragments * sizeof(*os->fragments)); 563 } 564 if (final && c->remove_at_exit) 565 rmdir(os->dirname); 566 } 567 } 568 569 if (ret >= 0) 570 ret = write_manifest(s, final); 571 return ret; 572} 573 574static int ism_write_packet(AVFormatContext *s, AVPacket *pkt) 575{ 576 SmoothStreamingContext *c = s->priv_data; 577 AVStream *st = s->streams[pkt->stream_index]; 578 OutputStream *os = &c->streams[pkt->stream_index]; 579 int64_t end_dts = (c->nb_fragments + 1LL) * c->min_frag_duration; 580 int ret; 581 582 if (st->first_dts == AV_NOPTS_VALUE) 583 st->first_dts = pkt->dts; 584 585 if ((!c->has_video || st->codec->codec_type == AVMEDIA_TYPE_VIDEO) && 586 av_compare_ts(pkt->dts - st->first_dts, st->time_base, 587 end_dts, AV_TIME_BASE_Q) >= 0 && 588 pkt->flags & AV_PKT_FLAG_KEY && os->packets_written) { 589 590 if ((ret = ism_flush(s, 0)) < 0) 591 return ret; 592 c->nb_fragments++; 593 } 594 595 os->packets_written++; 596 return ff_write_chained(os->ctx, 0, pkt, s); 597} 598 599static int ism_write_trailer(AVFormatContext *s) 600{ 601 SmoothStreamingContext *c = s->priv_data; 602 ism_flush(s, 1); 603 604 if (c->remove_at_exit) { 605 char filename[1024]; 606 snprintf(filename, sizeof(filename), "%s/Manifest", s->filename); 607 unlink(filename); 608 rmdir(s->filename); 609 } 610 611 ism_free(s); 612 return 0; 613} 614 615#define OFFSET(x) offsetof(SmoothStreamingContext, x) 616#define E AV_OPT_FLAG_ENCODING_PARAM 617static const AVOption options[] = { 618 { "window_size", "number of fragments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E }, 619 { "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 }, 620 { "lookahead_count", "number of lookahead fragments", OFFSET(lookahead_count), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, INT_MAX, E }, 621 { "min_frag_duration", "minimum fragment duration (in microseconds)", OFFSET(min_frag_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E }, 622 { "remove_at_exit", "remove all fragments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E }, 623 { NULL }, 624}; 625 626static const AVClass ism_class = { 627 .class_name = "smooth streaming muxer", 628 .item_name = av_default_item_name, 629 .option = options, 630 .version = LIBAVUTIL_VERSION_INT, 631}; 632 633 634AVOutputFormat ff_smoothstreaming_muxer = { 635 .name = "smoothstreaming", 636 .long_name = NULL_IF_CONFIG_SMALL("Smooth Streaming Muxer"), 637 .priv_data_size = sizeof(SmoothStreamingContext), 638 .audio_codec = AV_CODEC_ID_AAC, 639 .video_codec = AV_CODEC_ID_H264, 640 .flags = AVFMT_GLOBALHEADER | AVFMT_NOFILE, 641 .write_header = ism_write_header, 642 .write_packet = ism_write_packet, 643 .write_trailer = ism_write_trailer, 644 .codec_tag = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 }, 645 .priv_class = &ism_class, 646}; 647