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  ffurl_closep(&os->out);
103  ffurl_closep(&os->out2);
104  os->out = os->tail_out;
105  os->tail_out = NULL;
106  }
107  if (offset >= os->cur_start_pos) {
108  if (os->out)
109  ffurl_seek(os->out, offset - os->cur_start_pos, SEEK_SET);
110  os->cur_pos = offset;
111  return offset;
112  }
113  for (i = os->nb_fragments - 1; i >= 0; i--) {
114  Fragment *frag = os->fragments[i];
115  if (offset >= frag->start_pos && offset < frag->start_pos + frag->size) {
116  int ret;
117  AVDictionary *opts = NULL;
118  os->tail_out = os->out;
119  av_dict_set(&opts, "truncate", "0", 0);
120  ret = ffurl_open_whitelist(&os->out, frag->file, AVIO_FLAG_WRITE,
121  &os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist, os->ctx->protocol_blacklist, NULL);
122  av_dict_free(&opts);
123  if (ret < 0) {
124  os->out = os->tail_out;
125  os->tail_out = NULL;
126  return ret;
127  }
128  av_dict_set(&opts, "truncate", "0", 0);
129  ffurl_open_whitelist(&os->out2, frag->infofile, AVIO_FLAG_WRITE,
130  &os->ctx->interrupt_callback, &opts, os->ctx->protocol_whitelist, os->ctx->protocol_blacklist, NULL);
131  av_dict_free(&opts);
132  ffurl_seek(os->out, offset - frag->start_pos, SEEK_SET);
133  if (os->out2)
134  ffurl_seek(os->out2, offset - frag->start_pos, SEEK_SET);
135  os->cur_pos = offset;
136  return offset;
137  }
138  }
139  return AVERROR(EIO);
140 }
141 
142 static void get_private_data(OutputStream *os)
143 {
144  AVCodecParameters *par = os->ctx->streams[0]->codecpar;
145  uint8_t *ptr = par->extradata;
146  int size = par->extradata_size;
147  int i;
148  if (par->codec_id == AV_CODEC_ID_H264) {
149  ff_avc_write_annexb_extradata(ptr, &ptr, &size);
150  if (!ptr)
151  ptr = par->extradata;
152  }
153  if (!ptr)
154  return;
155  os->private_str = av_mallocz(2*size + 1);
156  if (!os->private_str)
157  goto fail;
158  for (i = 0; i < size; i++)
159  snprintf(&os->private_str[2*i], 3, "%02x", ptr[i]);
160 fail:
161  if (ptr != par->extradata)
162  av_free(ptr);
163 }
164 
165 static void ism_free(AVFormatContext *s)
166 {
167  SmoothStreamingContext *c = s->priv_data;
168  int i, j;
169  if (!c->streams)
170  return;
171  for (i = 0; i < s->nb_streams; i++) {
172  OutputStream *os = &c->streams[i];
173  ffurl_closep(&os->out);
174  ffurl_closep(&os->out2);
175  ffurl_closep(&os->tail_out);
176  if (os->ctx && os->ctx_inited)
177  av_write_trailer(os->ctx);
178  if (os->ctx && os->ctx->pb)
179  avio_context_free(&os->ctx->pb);
180  avformat_free_context(os->ctx);
181  av_freep(&os->private_str);
182  for (j = 0; j < os->nb_fragments; j++)
183  av_freep(&os->fragments[j]);
184  av_freep(&os->fragments);
185  }
186  av_freep(&c->streams);
187 }
188 
189 static void output_chunk_list(OutputStream *os, AVIOContext *out, int final, int skip, int window_size)
190 {
191  int removed = 0, i, start = 0;
192  if (os->nb_fragments <= 0)
193  return;
194  if (os->fragments[0]->n > 0)
195  removed = 1;
196  if (final)
197  skip = 0;
198  if (window_size)
199  start = FFMAX(os->nb_fragments - skip - window_size, 0);
200  for (i = start; i < os->nb_fragments - skip; i++) {
201  Fragment *frag = os->fragments[i];
202  if (!final || removed)
203  avio_printf(out, "<c t=\"%"PRIu64"\" d=\"%"PRIu64"\" />\n", frag->start_time, frag->duration);
204  else
205  avio_printf(out, "<c n=\"%d\" d=\"%"PRIu64"\" />\n", frag->n, frag->duration);
206  }
207 }
208 
209 static int write_manifest(AVFormatContext *s, int final)
210 {
211  SmoothStreamingContext *c = s->priv_data;
212  AVIOContext *out;
213  char filename[1024], temp_filename[1024];
214  int ret, i, video_chunks = 0, audio_chunks = 0, video_streams = 0, audio_streams = 0;
215  int64_t duration = 0;
216 
217  snprintf(filename, sizeof(filename), "%s/Manifest", s->url);
218  snprintf(temp_filename, sizeof(temp_filename), "%s/Manifest.tmp", s->url);
219  ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, NULL);
220  if (ret < 0) {
221  av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
222  return ret;
223  }
224  avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
225  for (i = 0; i < s->nb_streams; i++) {
226  OutputStream *os = &c->streams[i];
227  if (os->nb_fragments > 0) {
228  Fragment *last = os->fragments[os->nb_fragments - 1];
229  duration = last->start_time + last->duration;
230  }
231  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
232  video_chunks = os->nb_fragments;
233  video_streams++;
234  } else {
235  audio_chunks = os->nb_fragments;
236  audio_streams++;
237  }
238  }
239  if (!final) {
240  duration = 0;
241  video_chunks = audio_chunks = 0;
242  }
243  if (c->window_size) {
244  video_chunks = FFMIN(video_chunks, c->window_size);
245  audio_chunks = FFMIN(audio_chunks, c->window_size);
246  }
247  avio_printf(out, "<SmoothStreamingMedia MajorVersion=\"2\" MinorVersion=\"0\" Duration=\"%"PRIu64"\"", duration);
248  if (!final)
249  avio_printf(out, " IsLive=\"true\" LookAheadFragmentCount=\"%d\" DVRWindowLength=\"0\"", c->lookahead_count);
250  avio_printf(out, ">\n");
251  if (c->has_video) {
252  int last = -1, index = 0;
253  avio_printf(out, "<StreamIndex Type=\"video\" QualityLevels=\"%d\" Chunks=\"%d\" Url=\"QualityLevels({bitrate})/Fragments(video={start time})\">\n", video_streams, video_chunks);
254  for (i = 0; i < s->nb_streams; i++) {
255  OutputStream *os = &c->streams[i];
256  if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
257  continue;
258  last = i;
259  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);
260  index++;
261  }
262  output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size);
263  avio_printf(out, "</StreamIndex>\n");
264  }
265  if (c->has_audio) {
266  int last = -1, index = 0;
267  avio_printf(out, "<StreamIndex Type=\"audio\" QualityLevels=\"%d\" Chunks=\"%d\" Url=\"QualityLevels({bitrate})/Fragments(audio={start time})\">\n", audio_streams, audio_chunks);
268  for (i = 0; i < s->nb_streams; i++) {
269  OutputStream *os = &c->streams[i];
270  if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
271  continue;
272  last = i;
273  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);
274  index++;
275  }
276  output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size);
277  avio_printf(out, "</StreamIndex>\n");
278  }
279  avio_printf(out, "</SmoothStreamingMedia>\n");
280  avio_flush(out);
281  ff_format_io_close(s, &out);
282  return ff_rename(temp_filename, filename, s);
283 }
284 
285 static int ism_write_header(AVFormatContext *s)
286 {
287  SmoothStreamingContext *c = s->priv_data;
288  int ret = 0, i;
289  ff_const59 AVOutputFormat *oformat;
290 
291  if (mkdir(s->url, 0777) == -1 && errno != EEXIST) {
292  ret = AVERROR(errno);
293  av_log(s, AV_LOG_ERROR, "mkdir failed\n");
294  goto fail;
295  }
296 
297  oformat = av_guess_format("ismv", NULL, NULL);
298  if (!oformat) {
299  ret = AVERROR_MUXER_NOT_FOUND;
300  goto fail;
301  }
302 
303  c->streams = av_mallocz_array(s->nb_streams, sizeof(*c->streams));
304  if (!c->streams) {
305  ret = AVERROR(ENOMEM);
306  goto fail;
307  }
308 
309  for (i = 0; i < s->nb_streams; i++) {
310  OutputStream *os = &c->streams[i];
311  AVFormatContext *ctx;
312  AVStream *st;
313  AVDictionary *opts = NULL;
314 
315  if (!s->streams[i]->codecpar->bit_rate) {
316  av_log(s, AV_LOG_WARNING, "No bit rate set for stream %d\n", i);
317  // create a tmp name for the directory of fragments
318  snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(Tmp_%d)", s->url, i);
319  } else {
320  snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%"PRId64")", s->url, s->streams[i]->codecpar->bit_rate);
321  }
322 
323  if (mkdir(os->dirname, 0777) == -1 && errno != EEXIST) {
324  ret = AVERROR(errno);
325  av_log(s, AV_LOG_ERROR, "mkdir failed\n");
326  goto fail;
327  }
328 
329  os->ctx = ctx = avformat_alloc_context();
330  if (!ctx || ff_copy_whiteblacklists(ctx, s) < 0) {
331  ret = AVERROR(ENOMEM);
332  goto fail;
333  }
334  ctx->oformat = oformat;
335  ctx->interrupt_callback = s->interrupt_callback;
336 
337  if (!(st = avformat_new_stream(ctx, NULL))) {
338  ret = AVERROR(ENOMEM);
339  goto fail;
340  }
341  avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
342  st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
343  st->time_base = s->streams[i]->time_base;
344 
345  ctx->pb = avio_alloc_context(os->iobuf, sizeof(os->iobuf), AVIO_FLAG_WRITE, os, NULL, ism_write, ism_seek);
346  if (!ctx->pb) {
347  ret = AVERROR(ENOMEM);
348  goto fail;
349  }
350 
351  av_dict_set_int(&opts, "ism_lookahead", c->lookahead_count, 0);
352  av_dict_set(&opts, "movflags", "frag_custom", 0);
353  ret = avformat_write_header(ctx, &opts);
354  av_dict_free(&opts);
355  if (ret < 0) {
356  goto fail;
357  }
358  os->ctx_inited = 1;
359  avio_flush(ctx->pb);
360  s->streams[i]->time_base = st->time_base;
361  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
362  c->has_video = 1;
363  os->stream_type_tag = "video";
364  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
365  os->fourcc = "H264";
366  } else if (st->codecpar->codec_id == AV_CODEC_ID_VC1) {
367  os->fourcc = "WVC1";
368  } else {
369  av_log(s, AV_LOG_ERROR, "Unsupported video codec\n");
370  ret = AVERROR(EINVAL);
371  goto fail;
372  }
373  } else {
374  c->has_audio = 1;
375  os->stream_type_tag = "audio";
376  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
377  os->fourcc = "AACL";
378  os->audio_tag = 0xff;
379  } else if (st->codecpar->codec_id == AV_CODEC_ID_WMAPRO) {
380  os->fourcc = "WMAP";
381  os->audio_tag = 0x0162;
382  } else {
383  av_log(s, AV_LOG_ERROR, "Unsupported audio codec\n");
384  ret = AVERROR(EINVAL);
385  goto fail;
386  }
387  os->packet_size = st->codecpar->block_align ? st->codecpar->block_align : 4;
388  }
389  get_private_data(os);
390  }
391 
392  if (!c->has_video && c->min_frag_duration <= 0) {
393  av_log(s, AV_LOG_WARNING, "no video stream and no min frag duration set\n");
394  ret = AVERROR(EINVAL);
395  goto fail;
396  }
397  ret = write_manifest(s, 0);
398 
399 fail:
400  if (ret)
401  ism_free(s);
402  return ret;
403 }
404 
405 static int parse_fragment(AVFormatContext *s, const char *filename, int64_t *start_ts, int64_t *duration, int64_t *moof_size, int64_t size)
406 {
407  AVIOContext *in;
408  int ret;
409  uint32_t len;
410  if ((ret = s->io_open(s, &in, filename, AVIO_FLAG_READ, NULL)) < 0)
411  return ret;
412  ret = AVERROR(EIO);
413  *moof_size = avio_rb32(in);
414  if (*moof_size < 8 || *moof_size > size)
415  goto fail;
416  if (avio_rl32(in) != MKTAG('m','o','o','f'))
417  goto fail;
418  len = avio_rb32(in);
419  if (len > *moof_size)
420  goto fail;
421  if (avio_rl32(in) != MKTAG('m','f','h','d'))
422  goto fail;
423  avio_seek(in, len - 8, SEEK_CUR);
424  avio_rb32(in); /* traf size */
425  if (avio_rl32(in) != MKTAG('t','r','a','f'))
426  goto fail;
427  while (avio_tell(in) < *moof_size) {
428  uint32_t len = avio_rb32(in);
429  uint32_t tag = avio_rl32(in);
430  int64_t end = avio_tell(in) + len - 8;
431  if (len < 8 || len >= *moof_size)
432  goto fail;
433  if (tag == MKTAG('u','u','i','d')) {
434  static const uint8_t tfxd[] = {
435  0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
436  0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
437  };
438  uint8_t uuid[16];
439  avio_read(in, uuid, 16);
440  if (!memcmp(uuid, tfxd, 16) && len >= 8 + 16 + 4 + 16) {
441  avio_seek(in, 4, SEEK_CUR);
442  *start_ts = avio_rb64(in);
443  *duration = avio_rb64(in);
444  ret = 0;
445  break;
446  }
447  }
448  avio_seek(in, end, SEEK_SET);
449  }
450 fail:
451  ff_format_io_close(s, &in);
452  return ret;
453 }
454 
455 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)
456 {
457  int err;
458  Fragment *frag;
459  if (os->nb_fragments >= os->fragments_size) {
460  os->fragments_size = (os->fragments_size + 1) * 2;
461  if ((err = av_reallocp_array(&os->fragments, sizeof(*os->fragments),
462  os->fragments_size)) < 0) {
463  os->fragments_size = 0;
464  os->nb_fragments = 0;
465  return err;
466  }
467  }
468  frag = av_mallocz(sizeof(*frag));
469  if (!frag)
470  return AVERROR(ENOMEM);
471  av_strlcpy(frag->file, file, sizeof(frag->file));
472  av_strlcpy(frag->infofile, infofile, sizeof(frag->infofile));
473  frag->start_time = start_time;
474  frag->duration = duration;
475  frag->start_pos = start_pos;
476  frag->size = size;
477  frag->n = os->fragment_index;
478  os->fragments[os->nb_fragments++] = frag;
479  os->fragment_index++;
480  return 0;
481 }
482 
483 static int copy_moof(AVFormatContext *s, const char* infile, const char *outfile, int64_t size)
484 {
485  AVIOContext *in, *out;
486  int ret = 0;
487  if ((ret = s->io_open(s, &in, infile, AVIO_FLAG_READ, NULL)) < 0)
488  return ret;
489  if ((ret = s->io_open(s, &out, outfile, AVIO_FLAG_WRITE, NULL)) < 0) {
490  ff_format_io_close(s, &in);
491  return ret;
492  }
493  while (size > 0) {
494  uint8_t buf[8192];
495  int n = FFMIN(size, sizeof(buf));
496  n = avio_read(in, buf, n);
497  if (n <= 0) {
498  ret = AVERROR(EIO);
499  break;
500  }
501  avio_write(out, buf, n);
502  size -= n;
503  }
504  avio_flush(out);
505  ff_format_io_close(s, &out);
506  ff_format_io_close(s, &in);
507  return ret;
508 }
509 
510 static int ism_flush(AVFormatContext *s, int final)
511 {
512  SmoothStreamingContext *c = s->priv_data;
513  int i, ret = 0;
514 
515  for (i = 0; i < s->nb_streams; i++) {
516  OutputStream *os = &c->streams[i];
517  char filename[1024], target_filename[1024], header_filename[1024], curr_dirname[1024];
518  int64_t size;
519  int64_t start_ts, duration, moof_size;
520  if (!os->packets_written)
521  continue;
522 
523  snprintf(filename, sizeof(filename), "%s/temp", os->dirname);
524  ret = ffurl_open_whitelist(&os->out, filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL);
525  if (ret < 0)
526  break;
527  os->cur_start_pos = os->tail_pos;
528  av_write_frame(os->ctx, NULL);
529  avio_flush(os->ctx->pb);
530  os->packets_written = 0;
531  if (!os->out || os->tail_out)
532  return AVERROR(EIO);
533 
534  ffurl_closep(&os->out);
535  size = os->tail_pos - os->cur_start_pos;
536  if ((ret = parse_fragment(s, filename, &start_ts, &duration, &moof_size, size)) < 0)
537  break;
538 
539  if (!s->streams[i]->codecpar->bit_rate) {
540  int64_t bitrate = (int64_t) size * 8 * AV_TIME_BASE / av_rescale_q(duration, s->streams[i]->time_base, AV_TIME_BASE_Q);
541  if (!bitrate) {
542  av_log(s, AV_LOG_ERROR, "calculating bitrate got zero.\n");
543  ret = AVERROR(EINVAL);
544  return ret;
545  }
546 
547  av_log(s, AV_LOG_DEBUG, "calculated bitrate: %"PRId64"\n", bitrate);
548  s->streams[i]->codecpar->bit_rate = bitrate;
549  memcpy(curr_dirname, os->dirname, sizeof(os->dirname));
550  snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%"PRId64")", s->url, s->streams[i]->codecpar->bit_rate);
551  snprintf(filename, sizeof(filename), "%s/temp", os->dirname);
552 
553  // rename the tmp folder back to the correct name since we now have the bitrate
554  if ((ret = ff_rename((const char*)curr_dirname, os->dirname, s)) < 0)
555  return ret;
556  }
557 
558  snprintf(header_filename, sizeof(header_filename), "%s/FragmentInfo(%s=%"PRIu64")", os->dirname, os->stream_type_tag, start_ts);
559  snprintf(target_filename, sizeof(target_filename), "%s/Fragments(%s=%"PRIu64")", os->dirname, os->stream_type_tag, start_ts);
560  copy_moof(s, filename, header_filename, moof_size);
561  ret = ff_rename(filename, target_filename, s);
562  if (ret < 0)
563  break;
564  add_fragment(os, target_filename, header_filename, start_ts, duration,
565  os->cur_start_pos, size);
566  }
567 
568  if (c->window_size || (final && c->remove_at_exit)) {
569  for (i = 0; i < s->nb_streams; i++) {
570  OutputStream *os = &c->streams[i];
571  int j;
572  int remove = os->nb_fragments - c->window_size - c->extra_window_size - c->lookahead_count;
573  if (final && c->remove_at_exit)
574  remove = os->nb_fragments;
575  if (remove > 0) {
576  for (j = 0; j < remove; j++) {
577  unlink(os->fragments[j]->file);
578  unlink(os->fragments[j]->infofile);
579  av_freep(&os->fragments[j]);
580  }
581  os->nb_fragments -= remove;
582  memmove(os->fragments, os->fragments + remove, os->nb_fragments * sizeof(*os->fragments));
583  }
584  if (final && c->remove_at_exit)
585  rmdir(os->dirname);
586  }
587  }
588 
589  if (ret >= 0)
590  ret = write_manifest(s, final);
591  return ret;
592 }
593 
594 static int ism_write_packet(AVFormatContext *s, AVPacket *pkt)
595 {
596  SmoothStreamingContext *c = s->priv_data;
597  AVStream *st = s->streams[pkt->stream_index];
598  OutputStream *os = &c->streams[pkt->stream_index];
599  int64_t end_dts = (c->nb_fragments + 1) * (int64_t) c->min_frag_duration;
600  int ret;
601 
602  if (st->first_dts == AV_NOPTS_VALUE)
603  st->first_dts = pkt->dts;
604 
605  if ((!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
606  av_compare_ts(pkt->dts - st->first_dts, st->time_base,
607  end_dts, AV_TIME_BASE_Q) >= 0 &&
608  pkt->flags & AV_PKT_FLAG_KEY && os->packets_written) {
609 
610  if ((ret = ism_flush(s, 0)) < 0)
611  return ret;
612  c->nb_fragments++;
613  }
614 
615  os->packets_written++;
616  return ff_write_chained(os->ctx, 0, pkt, s, 0);
617 }
618 
619 static int ism_write_trailer(AVFormatContext *s)
620 {
621  SmoothStreamingContext *c = s->priv_data;
622  ism_flush(s, 1);
623 
624  if (c->remove_at_exit) {
625  char filename[1024];
626  snprintf(filename, sizeof(filename), "%s/Manifest", s->url);
627  unlink(filename);
628  rmdir(s->url);
629  }
630 
631  ism_free(s);
632  return 0;
633 }
634 
635 #define OFFSET(x) offsetof(SmoothStreamingContext, x)
636 #define E AV_OPT_FLAG_ENCODING_PARAM
637 static const AVOption options[] = {
638  { "window_size", "number of fragments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
639  { "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 },
640  { "lookahead_count", "number of lookahead fragments", OFFSET(lookahead_count), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, INT_MAX, E },
641  { "min_frag_duration", "minimum fragment duration (in microseconds)", OFFSET(min_frag_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E },
642  { "remove_at_exit", "remove all fragments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
643  { NULL },
644 };
645 
646 static const AVClass ism_class = {
647  .class_name = "smooth streaming muxer",
648  .item_name = av_default_item_name,
649  .option = options,
650  .version = LIBAVUTIL_VERSION_INT,
651 };
652 
653 
654 AVOutputFormat ff_smoothstreaming_muxer = {
655  .name = "smoothstreaming",
656  .long_name = NULL_IF_CONFIG_SMALL("Smooth Streaming Muxer"),
657  .priv_data_size = sizeof(SmoothStreamingContext),
658  .audio_codec = AV_CODEC_ID_AAC,
659  .video_codec = AV_CODEC_ID_H264,
660  .flags = AVFMT_GLOBALHEADER | AVFMT_NOFILE,
661  .write_header = ism_write_header,
662  .write_packet = ism_write_packet,
663  .write_trailer = ism_write_trailer,
664  .priv_class = &ism_class,
665 };
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: codec_par.h:74
OutputStream::cur_start_pos
int64_t cur_start_pos
Definition: smoothstreamingenc.c:58
AVOutputFormat::name
const char * name
Definition: avformat.h:491
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:4526
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
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: codec_par.h:52
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:436
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
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:143
AVFormatContext::protocol_blacklist
char * protocol_blacklist
',' separated list of disallowed protocols.
Definition: avformat.h:1930
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:92
ff_smoothstreaming_muxer
AVOutputFormat ff_smoothstreaming_muxer
Definition: smoothstreamingenc.c:654
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1403
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:483
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
float.h
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: packet.h:388
get_private_data
static void get_private_data(OutputStream *os)
Definition: smoothstreamingenc.c:142
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:535
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:1613
OutputStream::stream_type_tag
const char * stream_type_tag
Definition: smoothstreamingenc.c:60
fail
#define fail()
Definition: checkasm.h:123
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
ff_rename
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap avpriv_io_move and log if error happens.
Definition: avio.c:673
OutputStream::tail_out
URLContext * tail_out
Definition: smoothstreamingenc.c:57
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:1067
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:1305
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:635
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: codec_id.h:447
ism_flush
static int ism_flush(AVFormatContext *s, int final)
Definition: smoothstreamingenc.c:510
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:619
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
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: codec_id.h:76
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:505
ism_write
static int ism_write(void *opaque, uint8_t *buf, int buf_size)
Definition: smoothstreamingenc.c:82
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:233
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
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:894
NULL
#define NULL
Definition: coverity.c:32
OutputStream::ctx_inited
int ctx_inited
Definition: dashenc.c:101
isom.h
OutputStream::dirname
char dirname[1024]
Definition: smoothstreamingenc.c:53
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
AVFormatContext::protocol_whitelist
char * protocol_whitelist
',' separated list of allowed protocols.
Definition: avformat.h:1895
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:899
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1377
avc.h
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:1190
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:165
AVFormatContext::oformat
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1354
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:412
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:747
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:332
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:159
size
int size
Definition: twinvq_data.h:11134
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:458
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:927
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: packet.h:354
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:206
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: packet.h:361
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:209
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:702
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:1251
URLContext
Definition: url.h:38
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:461
AVOutputFormat
Definition: avformat.h:490
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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: codec_par.h:177
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:126
url.h
uint8_t
uint8_t
Definition: audio_convert.c:194
OutputStream::ctx
AVFormatContext * ctx
Definition: dashenc.c:100
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:237
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:119
len
int len
Definition: vorbis_enc_data.h:452
ism_write_packet
static int ism_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: smoothstreamingenc.c:594
ffurl_closep
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:446
tag
uint32_t tag
Definition: movenc.c:1532
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
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:646
options
static const AVOption options[]
Definition: smoothstreamingenc.c:637
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:405
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
Writes a formatted string to the context.
OutputStream::out
URLContext * out
Definition: smoothstreamingenc.c:55
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2109
ff_avc_write_annexb_extradata
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:221
OutputStream::iobuf
uint8_t iobuf[32768]
Definition: hdsenc.c:50
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
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:285
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4455
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
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:423
output_chunk_list
static void output_chunk_list(OutputStream *os, AVIOContext *out, int final, int skip, int window_size)
Definition: smoothstreamingenc.c:189
file.h
AVPacket::stream_index
int stream_index
Definition: packet.h:357
OutputStream::out
AVIOContext * out
Definition: dashenc.c:102
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:5695
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
OutputStream::out2
URLContext * out2
Definition: smoothstreamingenc.c:56
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: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:332
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:346
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
E
#define E
Definition: smoothstreamingenc.c:636
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:455
Generated on Wed Aug 24 2022 21:32:04 for FFmpeg by   doxygen 1.8.17