FFmpeg
smoothstreamingenc.c
Go to the documentation of this file.
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 "avio_internal.h"
30 #include "internal.h"
31 #include "os_support.h"
32 #include "avc.h"
33 #include "url.h"
34 #include "isom.h"
35 
36 #include "libavutil/opt.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/file.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/intreadwrite.h"
41 
42 typedef struct Fragment {
43  char file[1024];
44  char infofile[1024];
45  int64_t start_time, duration;
46  int n;
47  int64_t start_pos, size;
48 } Fragment;
49 
50 typedef struct OutputStream {
51  AVFormatContext *ctx;
52  int ctx_inited;
53  char dirname[1024];
54  uint8_t iobuf[32768];
55  URLContext *out; // Current output stream where all output is written
56  URLContext *out2; // Auxiliary output stream where all output is also written
57  URLContext *tail_out; // The actual main output stream, if we're currently seeked back to write elsewhere
58  int64_t tail_pos, cur_pos, cur_start_pos;
59  int packets_written;
60  const char *stream_type_tag;
61  int nb_fragments, fragments_size, fragment_index;
62  Fragment **fragments;
63 
64  const char *fourcc;
65  char *private_str;
66  int packet_size;
67  int audio_tag;
68 } OutputStream;
69 
70 typedef struct SmoothStreamingContext {
71  const AVClass *class; /* Class for private options. */
72  int window_size;
73  int extra_window_size;
74  int lookahead_count;
75  int min_frag_duration;
76  int remove_at_exit;
77  OutputStream *streams;
78  int has_video, has_audio;
79  int nb_fragments;
80 } SmoothStreamingContext;
81 
82 static int ism_write(void *opaque, uint8_t *buf, int buf_size)
83 {
84  OutputStream *os = opaque;
85  if (os->out)
86  ffurl_write(os->out, buf, buf_size);
87  if (os->out2)
88  ffurl_write(os->out2, buf, buf_size);
89  os->cur_pos += buf_size;
90  if (os->cur_pos >= os->tail_pos)
91  os->tail_pos = os->cur_pos;
92  return buf_size;
93 }
94 
95 static int64_t ism_seek(void *opaque, int64_t offset, int whence)
96 {
97  OutputStream *os = opaque;
98  int i;
99  if (whence != SEEK_SET)
100  return AVERROR(ENOSYS);
101  if (os->tail_out) {
102  if (os->out) {
103  ffurl_close(os->out);
104  }
105  if (os->out2) {
106  ffurl_close(os->out2);
107  }
108  os->out = os->tail_out;
109  os->out2 = NULL;
110  os->tail_out = NULL;
111  }
112  if (offset >= os->cur_start_pos) {
113  if (os->out)
114  ffurl_seek(os->out, offset - os->cur_start_pos, SEEK_SET);
115  os->cur_pos = offset;
116  return offset;
117  }
118  for (i = os->nb_fragments - 1; i >= 0; i--) {
119  Fragment *frag = os->fragments[i];
120  if (offset >= frag->start_pos && offset < frag->start_pos + frag->size) {
121  int ret;
122  AVDictionary *opts = NULL;
123  os->tail_out = os->out;
124  av_dict_set(&opts, "truncate", "0", 0);
125  ret = ffurl_open_whitelist(&os->out, frag->file, AVIO_FLAG_WRITE,
126  &os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist, os->ctx->protocol_blacklist, NULL);
127  av_dict_free(&opts);
128  if (ret < 0) {
129  os->out = os->tail_out;
130  os->tail_out = NULL;
131  return ret;
132  }
133  av_dict_set(&opts, "truncate", "0", 0);
134  ffurl_open_whitelist(&os->out2, frag->infofile, AVIO_FLAG_WRITE,
135  &os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist, os->ctx->protocol_blacklist, NULL);
136  av_dict_free(&opts);
137  ffurl_seek(os->out, offset - frag->start_pos, SEEK_SET);
138  if (os->out2)
139  ffurl_seek(os->out2, offset - frag->start_pos, SEEK_SET);
140  os->cur_pos = offset;
141  return offset;
142  }
143  }
144  return AVERROR(EIO);
145 }
146 
147 static void get_private_data(OutputStream *os)
148 {
149  AVCodecParameters *par = os->ctx->streams[0]->codecpar;
150  uint8_t *ptr = par->extradata;
151  int size = par->extradata_size;
152  int i;
153  if (par->codec_id == AV_CODEC_ID_H264) {
154  ff_avc_write_annexb_extradata(ptr, &ptr, &size);
155  if (!ptr)
156  ptr = par->extradata;
157  }
158  if (!ptr)
159  return;
160  os->private_str = av_mallocz(2*size + 1);
161  if (!os->private_str)
162  goto fail;
163  for (i = 0; i < size; i++)
164  snprintf(&os->private_str[2*i], 3, "%02x", ptr[i]);
165 fail:
166  if (ptr != par->extradata)
167  av_free(ptr);
168 }
169 
170 static void ism_free(AVFormatContext *s)
171 {
172  SmoothStreamingContext *c = s->priv_data;
173  int i, j;
174  if (!c->streams)
175  return;
176  for (i = 0; i < s->nb_streams; i++) {
177  OutputStream *os = &c->streams[i];
178  ffurl_close(os->out);
179  ffurl_close(os->out2);
180  ffurl_close(os->tail_out);
181  os->out = os->out2 = os->tail_out = NULL;
182  if (os->ctx && os->ctx_inited)
183  av_write_trailer(os->ctx);
184  if (os->ctx && os->ctx->pb)
185  avio_context_free(&os->ctx->pb);
186  if (os->ctx)
187  avformat_free_context(os->ctx);
188  av_freep(&os->private_str);
189  for (j = 0; j < os->nb_fragments; j++)
190  av_freep(&os->fragments[j]);
191  av_freep(&os->fragments);
192  }
193  av_freep(&c->streams);
194 }
195 
196 static void output_chunk_list(OutputStream *os, AVIOContext *out, int final, int skip, int window_size)
197 {
198  int removed = 0, i, start = 0;
199  if (os->nb_fragments <= 0)
200  return;
201  if (os->fragments[0]->n > 0)
202  removed = 1;
203  if (final)
204  skip = 0;
205  if (window_size)
206  start = FFMAX(os->nb_fragments - skip - window_size, 0);
207  for (i = start; i < os->nb_fragments - skip; i++) {
208  Fragment *frag = os->fragments[i];
209  if (!final || removed)
210  avio_printf(out, "<c t=\"%"PRIu64"\" d=\"%"PRIu64"\" />\n", frag->start_time, frag->duration);
211  else
212  avio_printf(out, "<c n=\"%d\" d=\"%"PRIu64"\" />\n", frag->n, frag->duration);
213  }
214 }
215 
216 static int write_manifest(AVFormatContext *s, int final)
217 {
218  SmoothStreamingContext *c = s->priv_data;
219  AVIOContext *out;
220  char filename[1024], temp_filename[1024];
221  int ret, i, video_chunks = 0, audio_chunks = 0, video_streams = 0, audio_streams = 0;
222  int64_t duration = 0;
223 
224  snprintf(filename, sizeof(filename), "%s/Manifest", s->url);
225  snprintf(temp_filename, sizeof(temp_filename), "%s/Manifest.tmp", s->url);
226  ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, NULL);
227  if (ret < 0) {
228  av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
229  return ret;
230  }
231  avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
232  for (i = 0; i < s->nb_streams; i++) {
233  OutputStream *os = &c->streams[i];
234  if (os->nb_fragments > 0) {
235  Fragment *last = os->fragments[os->nb_fragments - 1];
236  duration = last->start_time + last->duration;
237  }
238  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
239  video_chunks = os->nb_fragments;
240  video_streams++;
241  } else {
242  audio_chunks = os->nb_fragments;
243  audio_streams++;
244  }
245  }
246  if (!final) {
247  duration = 0;
248  video_chunks = audio_chunks = 0;
249  }
250  if (c->window_size) {
251  video_chunks = FFMIN(video_chunks, c->window_size);
252  audio_chunks = FFMIN(audio_chunks, c->window_size);
253  }
254  avio_printf(out, "<SmoothStreamingMedia MajorVersion=\"2\" MinorVersion=\"0\" Duration=\"%"PRIu64"\"", duration);
255  if (!final)
256  avio_printf(out, " IsLive=\"true\" LookAheadFragmentCount=\"%d\" DVRWindowLength=\"0\"", c->lookahead_count);
257  avio_printf(out, ">\n");
258  if (c->has_video) {
259  int last = -1, index = 0;
260  avio_printf(out, "<StreamIndex Type=\"video\" QualityLevels=\"%d\" Chunks=\"%d\" Url=\"QualityLevels({bitrate})/Fragments(video={start time})\">\n", video_streams, video_chunks);
261  for (i = 0; i < s->nb_streams; i++) {
262  OutputStream *os = &c->streams[i];
263  if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
264  continue;
265  last = i;
266  avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%"PRId64"\" FourCC=\"%s\" MaxWidth=\"%d\" MaxHeight=\"%d\" CodecPrivateData=\"%s\" />\n", index, s->streams[i]->codecpar->bit_rate, os->fourcc, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height, os->private_str);
267  index++;
268  }
269  output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size);
270  avio_printf(out, "</StreamIndex>\n");
271  }
272  if (c->has_audio) {
273  int last = -1, index = 0;
274  avio_printf(out, "<StreamIndex Type=\"audio\" QualityLevels=\"%d\" Chunks=\"%d\" Url=\"QualityLevels({bitrate})/Fragments(audio={start time})\">\n", audio_streams, audio_chunks);
275  for (i = 0; i < s->nb_streams; i++) {
276  OutputStream *os = &c->streams[i];
277  if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
278  continue;
279  last = i;
280  avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%"PRId64"\" FourCC=\"%s\" SamplingRate=\"%d\" Channels=\"%d\" BitsPerSample=\"16\" PacketSize=\"%d\" AudioTag=\"%d\" CodecPrivateData=\"%s\" />\n", index, s->streams[i]->codecpar->bit_rate, os->fourcc, s->streams[i]->codecpar->sample_rate, s->streams[i]->codecpar->channels, os->packet_size, os->audio_tag, os->private_str);
281  index++;
282  }
283  output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size);
284  avio_printf(out, "</StreamIndex>\n");
285  }
286  avio_printf(out, "</SmoothStreamingMedia>\n");
287  avio_flush(out);
288  ff_format_io_close(s, &out);
289  return ff_rename(temp_filename, filename, s);
290 }
291 
292 static int ism_write_header(AVFormatContext *s)
293 {
294  SmoothStreamingContext *c = s->priv_data;
295  int ret = 0, i;
296  ff_const59 AVOutputFormat *oformat;
297 
298  if (mkdir(s->url, 0777) == -1 && errno != EEXIST) {
299  ret = AVERROR(errno);
300  av_log(s, AV_LOG_ERROR, "mkdir failed\n");
301  goto fail;
302  }
303 
304  oformat = av_guess_format("ismv", NULL, NULL);
305  if (!oformat) {
306  ret = AVERROR_MUXER_NOT_FOUND;
307  goto fail;
308  }
309 
310  c->streams = av_mallocz_array(s->nb_streams, sizeof(*c->streams));
311  if (!c->streams) {
312  ret = AVERROR(ENOMEM);
313  goto fail;
314  }
315 
316  for (i = 0; i < s->nb_streams; i++) {
317  OutputStream *os = &c->streams[i];
318  AVFormatContext *ctx;
319  AVStream *st;
320  AVDictionary *opts = NULL;
321 
322  if (!s->streams[i]->codecpar->bit_rate) {
323  av_log(s, AV_LOG_WARNING, "No bit rate set for stream %d\n", i);
324  // create a tmp name for the directory of fragments
325  snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(Tmp_%d)", s->url, i);
326  } else {
327  snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%"PRId64")", s->url, s->streams[i]->codecpar->bit_rate);
328  }
329 
330  if (mkdir(os->dirname, 0777) == -1 && errno != EEXIST) {
331  ret = AVERROR(errno);
332  av_log(s, AV_LOG_ERROR, "mkdir failed\n");
333  goto fail;
334  }
335 
336  os->ctx = ctx = avformat_alloc_context();
337  if (!ctx || ff_copy_whiteblacklists(ctx, s) < 0) {
338  ret = AVERROR(ENOMEM);
339  goto fail;
340  }
341  ctx->oformat = oformat;
342  ctx->interrupt_callback = s->interrupt_callback;
343 
344  if (!(st = avformat_new_stream(ctx, NULL))) {
345  ret = AVERROR(ENOMEM);
346  goto fail;
347  }
348  avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
349  st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
350  st->time_base = s->streams[i]->time_base;
351 
352  ctx->pb = avio_alloc_context(os->iobuf, sizeof(os->iobuf), AVIO_FLAG_WRITE, os, NULL, ism_write, ism_seek);
353  if (!ctx->pb) {
354  ret = AVERROR(ENOMEM);
355  goto fail;
356  }
357 
358  av_dict_set_int(&opts, "ism_lookahead", c->lookahead_count, 0);
359  av_dict_set(&opts, "movflags", "frag_custom", 0);
360  ret = avformat_write_header(ctx, &opts);
361  av_dict_free(&opts);
362  if (ret < 0) {
363  goto fail;
364  }
365  os->ctx_inited = 1;
366  avio_flush(ctx->pb);
367  s->streams[i]->time_base = st->time_base;
368  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
369  c->has_video = 1;
370  os->stream_type_tag = "video";
371  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
372  os->fourcc = "H264";
373  } else if (st->codecpar->codec_id == AV_CODEC_ID_VC1) {
374  os->fourcc = "WVC1";
375  } else {
376  av_log(s, AV_LOG_ERROR, "Unsupported video codec\n");
377  ret = AVERROR(EINVAL);
378  goto fail;
379  }
380  } else {
381  c->has_audio = 1;
382  os->stream_type_tag = "audio";
383  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
384  os->fourcc = "AACL";
385  os->audio_tag = 0xff;
386  } else if (st->codecpar->codec_id == AV_CODEC_ID_WMAPRO) {
387  os->fourcc = "WMAP";
388  os->audio_tag = 0x0162;
389  } else {
390  av_log(s, AV_LOG_ERROR, "Unsupported audio codec\n");
391  ret = AVERROR(EINVAL);
392  goto fail;
393  }
394  os->packet_size = st->codecpar->block_align ? st->codecpar->block_align : 4;
395  }
396  get_private_data(os);
397  }
398 
399  if (!c->has_video && c->min_frag_duration <= 0) {
400  av_log(s, AV_LOG_WARNING, "no video stream and no min frag duration set\n");
401  ret = AVERROR(EINVAL);
402  goto fail;
403  }
404  ret = write_manifest(s, 0);
405 
406 fail:
407  if (ret)
408  ism_free(s);
409  return ret;
410 }
411 
412 static int parse_fragment(AVFormatContext *s, const char *filename, int64_t *start_ts, int64_t *duration, int64_t *moof_size, int64_t size)
413 {
414  AVIOContext *in;
415  int ret;
416  uint32_t len;
417  if ((ret = s->io_open(s, &in, filename, AVIO_FLAG_READ, NULL)) < 0)
418  return ret;
419  ret = AVERROR(EIO);
420  *moof_size = avio_rb32(in);
421  if (*moof_size < 8 || *moof_size > size)
422  goto fail;
423  if (avio_rl32(in) != MKTAG('m','o','o','f'))
424  goto fail;
425  len = avio_rb32(in);
426  if (len > *moof_size)
427  goto fail;
428  if (avio_rl32(in) != MKTAG('m','f','h','d'))
429  goto fail;
430  avio_seek(in, len - 8, SEEK_CUR);
431  avio_rb32(in); /* traf size */
432  if (avio_rl32(in) != MKTAG('t','r','a','f'))
433  goto fail;
434  while (avio_tell(in) < *moof_size) {
435  uint32_t len = avio_rb32(in);
436  uint32_t tag = avio_rl32(in);
437  int64_t end = avio_tell(in) + len - 8;
438  if (len < 8 || len >= *moof_size)
439  goto fail;
440  if (tag == MKTAG('u','u','i','d')) {
441  static const uint8_t tfxd[] = {
442  0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
443  0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
444  };
445  uint8_t uuid[16];
446  avio_read(in, uuid, 16);
447  if (!memcmp(uuid, tfxd, 16) && len >= 8 + 16 + 4 + 16) {
448  avio_seek(in, 4, SEEK_CUR);
449  *start_ts = avio_rb64(in);
450  *duration = avio_rb64(in);
451  ret = 0;
452  break;
453  }
454  }
455  avio_seek(in, end, SEEK_SET);
456  }
457 fail:
458  ff_format_io_close(s, &in);
459  return ret;
460 }
461 
462 static 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)
463 {
464  int err;
465  Fragment *frag;
466  if (os->nb_fragments >= os->fragments_size) {
467  os->fragments_size = (os->fragments_size + 1) * 2;
468  if ((err = av_reallocp(&os->fragments, sizeof(*os->fragments) *
469  os->fragments_size)) < 0) {
470  os->fragments_size = 0;
471  os->nb_fragments = 0;
472  return err;
473  }
474  }
475  frag = av_mallocz(sizeof(*frag));
476  if (!frag)
477  return AVERROR(ENOMEM);
478  av_strlcpy(frag->file, file, sizeof(frag->file));
479  av_strlcpy(frag->infofile, infofile, sizeof(frag->infofile));
480  frag->start_time = start_time;
481  frag->duration = duration;
482  frag->start_pos = start_pos;
483  frag->size = size;
484  frag->n = os->fragment_index;
485  os->fragments[os->nb_fragments++] = frag;
486  os->fragment_index++;
487  return 0;
488 }
489 
490 static int copy_moof(AVFormatContext *s, const char* infile, const char *outfile, int64_t size)
491 {
492  AVIOContext *in, *out;
493  int ret = 0;
494  if ((ret = s->io_open(s, &in, infile, AVIO_FLAG_READ, NULL)) < 0)
495  return ret;
496  if ((ret = s->io_open(s, &out, outfile, AVIO_FLAG_WRITE, NULL)) < 0) {
497  ff_format_io_close(s, &in);
498  return ret;
499  }
500  while (size > 0) {
501  uint8_t buf[8192];
502  int n = FFMIN(size, sizeof(buf));
503  n = avio_read(in, buf, n);
504  if (n <= 0) {
505  ret = AVERROR(EIO);
506  break;
507  }
508  avio_write(out, buf, n);
509  size -= n;
510  }
511  avio_flush(out);
512  ff_format_io_close(s, &out);
513  ff_format_io_close(s, &in);
514  return ret;
515 }
516 
517 static int ism_flush(AVFormatContext *s, int final)
518 {
519  SmoothStreamingContext *c = s->priv_data;
520  int i, ret = 0;
521 
522  for (i = 0; i < s->nb_streams; i++) {
523  OutputStream *os = &c->streams[i];
524  char filename[1024], target_filename[1024], header_filename[1024], curr_dirname[1024];
525  int64_t size;
526  int64_t start_ts, duration, moof_size;
527  if (!os->packets_written)
528  continue;
529 
530  snprintf(filename, sizeof(filename), "%s/temp", os->dirname);
531  ret = ffurl_open_whitelist(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL);
532  if (ret < 0)
533  break;
534  os->cur_start_pos = os->tail_pos;
535  av_write_frame(os->ctx, NULL);
536  avio_flush(os->ctx->pb);
537  os->packets_written = 0;
538  if (!os->out || os->tail_out)
539  return AVERROR(EIO);
540 
541  ffurl_close(os->out);
542  os->out = NULL;
543  size = os->tail_pos - os->cur_start_pos;
544  if ((ret = parse_fragment(s, filename, &start_ts, &duration, &moof_size, size)) < 0)
545  break;
546 
547  if (!s->streams[i]->codecpar->bit_rate) {
548  int64_t bitrate = (int64_t) size * 8 * AV_TIME_BASE / av_rescale_q(duration, s->streams[i]->time_base, AV_TIME_BASE_Q);
549  if (!bitrate) {
550  av_log(s, AV_LOG_ERROR, "calculating bitrate got zero.\n");
551  ret = AVERROR(EINVAL);
552  return ret;
553  }
554 
555  av_log(s, AV_LOG_DEBUG, "calculated bitrate: %"PRId64"\n", bitrate);
556  s->streams[i]->codecpar->bit_rate = bitrate;
557  memcpy(curr_dirname, os->dirname, sizeof(os->dirname));
558  snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%"PRId64")", s->url, s->streams[i]->codecpar->bit_rate);
559  snprintf(filename, sizeof(filename), "%s/temp", os->dirname);
560 
561  // rename the tmp folder back to the correct name since we now have the bitrate
562  if ((ret = ff_rename((const char*)curr_dirname, os->dirname, s)) < 0)
563  return ret;
564  }
565 
566  snprintf(header_filename, sizeof(header_filename), "%s/FragmentInfo(%s=%"PRIu64")", os->dirname, os->stream_type_tag, start_ts);
567  snprintf(target_filename, sizeof(target_filename), "%s/Fragments(%s=%"PRIu64")", os->dirname, os->stream_type_tag, start_ts);
568  copy_moof(s, filename, header_filename, moof_size);
569  ret = ff_rename(filename, target_filename, s);
570  if (ret < 0)
571  break;
572  add_fragment(os, target_filename, header_filename, start_ts, duration,
573  os->cur_start_pos, size);
574  }
575 
576  if (c->window_size || (final && c->remove_at_exit)) {
577  for (i = 0; i < s->nb_streams; i++) {
578  OutputStream *os = &c->streams[i];
579  int j;
580  int remove = os->nb_fragments - c->window_size - c->extra_window_size - c->lookahead_count;
581  if (final && c->remove_at_exit)
582  remove = os->nb_fragments;
583  if (remove > 0) {
584  for (j = 0; j < remove; j++) {
585  unlink(os->fragments[j]->file);
586  unlink(os->fragments[j]->infofile);
587  av_freep(&os->fragments[j]);
588  }
589  os->nb_fragments -= remove;
590  memmove(os->fragments, os->fragments + remove, os->nb_fragments * sizeof(*os->fragments));
591  }
592  if (final && c->remove_at_exit)
593  rmdir(os->dirname);
594  }
595  }
596 
597  if (ret >= 0)
598  ret = write_manifest(s, final);
599  return ret;
600 }
601 
602 static int ism_write_packet(AVFormatContext *s, AVPacket *pkt)
603 {
604  SmoothStreamingContext *c = s->priv_data;
605  AVStream *st = s->streams[pkt->stream_index];
606  OutputStream *os = &c->streams[pkt->stream_index];
607  int64_t end_dts = (c->nb_fragments + 1) * (int64_t) c->min_frag_duration;
608  int ret;
609 
610  if (st->first_dts == AV_NOPTS_VALUE)
611  st->first_dts = pkt->dts;
612 
613  if ((!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
614  av_compare_ts(pkt->dts - st->first_dts, st->time_base,
615  end_dts, AV_TIME_BASE_Q) >= 0 &&
616  pkt->flags & AV_PKT_FLAG_KEY && os->packets_written) {
617 
618  if ((ret = ism_flush(s, 0)) < 0)
619  return ret;
620  c->nb_fragments++;
621  }
622 
623  os->packets_written++;
624  return ff_write_chained(os->ctx, 0, pkt, s, 0);
625 }
626 
627 static int ism_write_trailer(AVFormatContext *s)
628 {
629  SmoothStreamingContext *c = s->priv_data;
630  ism_flush(s, 1);
631 
632  if (c->remove_at_exit) {
633  char filename[1024];
634  snprintf(filename, sizeof(filename), "%s/Manifest", s->url);
635  unlink(filename);
636  rmdir(s->url);
637  }
638 
639  ism_free(s);
640  return 0;
641 }
642 
643 #define OFFSET(x) offsetof(SmoothStreamingContext, x)
644 #define E AV_OPT_FLAG_ENCODING_PARAM
645 static const AVOption options[] = {
646  { "window_size", "number of fragments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
647  { "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 },
648  { "lookahead_count", "number of lookahead fragments", OFFSET(lookahead_count), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, INT_MAX, E },
649  { "min_frag_duration", "minimum fragment duration (in microseconds)", OFFSET(min_frag_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E },
650  { "remove_at_exit", "remove all fragments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
651  { NULL },
652 };
653 
654 static const AVClass ism_class = {
655  .class_name = "smooth streaming muxer",
656  .item_name = av_default_item_name,
657  .option = options,
658  .version = LIBAVUTIL_VERSION_INT,
659 };
660 
661 
662 AVOutputFormat ff_smoothstreaming_muxer = {
663  .name = "smoothstreaming",
664  .long_name = NULL_IF_CONFIG_SMALL("Smooth Streaming Muxer"),
665  .priv_data_size = sizeof(SmoothStreamingContext),
666  .audio_codec = AV_CODEC_ID_AAC,
667  .video_codec = AV_CODEC_ID_H264,
668  .flags = AVFMT_GLOBALHEADER | AVFMT_NOFILE,
669  .write_header = ism_write_header,
670  .write_packet = ism_write_packet,
671  .write_trailer = ism_write_trailer,
672  .priv_class = &ism_class,
673 };
ff_rename
static int ff_rename(const char *oldpath, const char *newpath, void *logctx)
Wrap errno on rename() error.
Definition: internal.h:591
SmoothStreamingContext::remove_at_exit
int remove_at_exit
Definition: smoothstreamingenc.c:76
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
OutputStream::cur_start_pos
int64_t cur_start_pos
Definition: smoothstreamingenc.c:58
AVOutputFormat::name
const char * name
Definition: avformat.h:496
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4480
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
out
FILE * out
Definition: movenc.c:54
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
n
int n
Definition: avisynth_c.h:760
ffurl_seek
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
Change the position that will be used by the next read/write operation on the resource accessed by h.
Definition: avio.c:437
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:366
OutputStream::fragment_index
int fragment_index
Definition: hdsenc.c:55
avio_context_free
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:148
AVFormatContext::protocol_blacklist
char * protocol_blacklist
',' separated list of disallowed protocols.
Definition: avformat.h:1937
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
OutputStream::packets_written
uint64_t packets_written
Definition: ffmpeg.h:534
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
ff_smoothstreaming_muxer
AVOutputFormat ff_smoothstreaming_muxer
Definition: smoothstreamingenc.c:662
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1410
SmoothStreamingContext
Definition: smoothstreamingenc.c:70
AVOption
AVOption.
Definition: opt.h:246
outfile
FILE * outfile
Definition: audiogen.c:96
Fragment::start_time
int64_t start_time
Definition: hdsenc.c:41
copy_moof
static int copy_moof(AVFormatContext *s, const char *infile, const char *outfile, int64_t size)
Definition: smoothstreamingenc.c:490
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
float.h
ffurl_close
int ffurl_close(URLContext *h)
Definition: avio.c:470
mathematics.h
AVDictionary
Definition: dict.c:30
SmoothStreamingContext::extra_window_size
int extra_window_size
Definition: smoothstreamingenc.c:73
OutputStream::nb_fragments
int nb_fragments
Definition: hdsenc.c:55
OutputStream::audio_tag
int audio_tag
Definition: smoothstreamingenc.c:67
SmoothStreamingContext::nb_fragments
int nb_fragments
Definition: smoothstreamingenc.c:79
os_support.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
get_private_data
static void get_private_data(OutputStream *os)
Definition: smoothstreamingenc.c:147
ff_const59
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning.
Definition: avformat.h:540
Fragment
Definition: hdsenc.c:39
av_guess_format
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1620
OutputStream::stream_type_tag
const char * stream_type_tag
Definition: smoothstreamingenc.c:60
fail
#define fail()
Definition: checkasm.h:120
start
void INT64 start
Definition: avisynth_c.h:767
Fragment::file
char file[1024]
Definition: hdsenc.c:40
SmoothStreamingContext::has_audio
int has_audio
Definition: smoothstreamingenc.c:78
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
OutputStream::tail_out
URLContext * tail_out
Definition: smoothstreamingenc.c:57
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:800
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
SmoothStreamingContext::window_size
int window_size
Definition: smoothstreamingenc.c:72
AVStream::first_dts
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: avformat.h:1072
ff_write_chained
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, AVFormatContext *src, int interleave)
Write a packet to another muxer than the one the user originally intended.
Definition: mux.c:1318
duration
int64_t duration
Definition: movenc.c:63
ffurl_open_whitelist
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it.
Definition: avio.c:307
OFFSET
#define OFFSET(x)
Definition: smoothstreamingenc.c:643
intreadwrite.h
Fragment::start_pos
int64_t start_pos
Definition: smoothstreamingenc.c:47
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_CODEC_ID_WMAPRO
@ AV_CODEC_ID_WMAPRO
Definition: avcodec.h:601
ism_flush
static int ism_flush(AVFormatContext *s, int final)
Definition: smoothstreamingenc.c:517
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:224
ism_write_trailer
static int ism_write_trailer(AVFormatContext *s)
Definition: smoothstreamingenc.c:627
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:655
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
ism_seek
static int64_t ism_seek(void *opaque, int64_t offset, int whence)
Definition: smoothstreamingenc.c:95
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: avcodec.h:245
avformat_write_header
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:508
ism_write
static int ism_write(void *opaque, uint8_t *buf, int buf_size)
Definition: smoothstreamingenc.c:82
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:899
NULL
#define NULL
Definition: coverity.c:32
OutputStream::ctx_inited
int ctx_inited
Definition: dashenc.c:80
isom.h
OutputStream::dirname
char dirname[1024]
Definition: smoothstreamingenc.c:53
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
AVFormatContext::protocol_whitelist
char * protocol_whitelist
',' separated list of allowed protocols.
Definition: avformat.h:1902
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:921
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1384
avc.h
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:878
Fragment::duration
int64_t duration
Definition: hdsenc.c:41
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ism_free
static void ism_free(AVFormatContext *s)
Definition: smoothstreamingenc.c:170
AVFormatContext::oformat
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1361
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: avcodec.h:566
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:769
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
start_time
static int64_t start_time
Definition: ffplay.c:331
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
Fragment::size
int64_t size
Definition: smoothstreamingenc.c:47
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:164
size
int size
Definition: twinvq_data.h:11134
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:932
SmoothStreamingContext::min_frag_duration
int min_frag_duration
Definition: smoothstreamingenc.c:75
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: avcodec.h:1476
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
OutputStream::fourcc
const char * fourcc
Definition: smoothstreamingenc.c:64
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
bitrate
int64_t bitrate
Definition: h264_levels.c:131
write_manifest
static int write_manifest(AVFormatContext *s, int final)
Definition: smoothstreamingenc.c:216
OutputStream::private_str
char * private_str
Definition: smoothstreamingenc.c:65
SmoothStreamingContext::lookahead_count
int lookahead_count
Definition: smoothstreamingenc.c:74
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:690
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1254
URLContext
Definition: url.h:38
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
AVOutputFormat
Definition: avformat.h:495
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
avio_internal.h
AVERROR_MUXER_NOT_FOUND
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
Definition: error.h:60
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVCodecParameters::block_align
int block_align
Audio only.
Definition: avcodec.h:4074
OutputStream::tail_pos
int64_t tail_pos
Definition: smoothstreamingenc.c:58
avio_alloc_context
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:131
url.h
uint8_t
uint8_t
Definition: audio_convert.c:194
OutputStream::ctx
AVFormatContext * ctx
Definition: dashenc.c:79
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: avcodec.h:288
len
int len
Definition: vorbis_enc_data.h:452
ism_write_packet
static int ism_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: smoothstreamingenc.c:602
tag
uint32_t tag
Definition: movenc.c:1496
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:870
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
SmoothStreamingContext::streams
OutputStream * streams
Definition: smoothstreamingenc.c:77
ism_class
static const AVClass ism_class
Definition: smoothstreamingenc.c:654
options
static const AVOption options[]
Definition: smoothstreamingenc.c:645
avformat.h
parse_fragment
static int parse_fragment(AVFormatContext *s, const char *filename, int64_t *start_ts, int64_t *duration, int64_t *moof_size, int64_t size)
Definition: smoothstreamingenc.c:412
OutputStream::fragments_size
int fragments_size
Definition: hdsenc.c:55
OutputStream::fragments
Fragment ** fragments
Definition: hdsenc.c:56
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
OutputStream::out
URLContext * out
Definition: smoothstreamingenc.c:55
ff_avc_write_annexb_extradata
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:198
OutputStream::iobuf
uint8_t iobuf[32768]
Definition: hdsenc.c:50
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
config.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
ism_write_header
static int ism_write_header(AVFormatContext *s)
Definition: smoothstreamingenc.c:292
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4414
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:647
ffurl_write
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:424
output_chunk_list
static void output_chunk_list(OutputStream *os, AVIOContext *out, int final, int skip, int window_size)
Definition: smoothstreamingenc.c:196
file.h
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1479
OutputStream::out
AVIOContext * out
Definition: dashenc.c:81
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
Definition: dict.c:147
ff_format_io_close
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5665
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
OutputStream::out2
URLContext * out2
Definition: smoothstreamingenc.c:56
avio_flush
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
OutputStream::cur_pos
int64_t cur_pos
Definition: smoothstreamingenc.c:58
OutputStream
Definition: muxing.c:53
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
OutputStream::packet_size
int packet_size
Definition: smoothstreamingenc.c:66
avstring.h
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
snprintf
#define snprintf
Definition: snprintf.h:34
Fragment::n
int n
Definition: hdsenc.c:42
SmoothStreamingContext::has_video
int has_video
Definition: smoothstreamingenc.c:78
Fragment::infofile
char infofile[1024]
Definition: smoothstreamingenc.c:44
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2080
E
#define E
Definition: smoothstreamingenc.c:644
add_fragment
static 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)
Definition: smoothstreamingenc.c:462
Generated on Wed Aug 24 2022 21:27:25 for FFmpeg by   doxygen 1.8.17