FFmpeg
segment.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011, Luca Barbato
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file generic segmenter
23  * M3U8 specification can be find here:
24  * @url{http://tools.ietf.org/id/draft-pantos-http-live-streaming}
25  */
26 
27 #include "config_components.h"
28 
29 #include <time.h>
30 
31 #include "avformat.h"
32 #include "internal.h"
33 #include "mux.h"
34 
35 #include "libavutil/avassert.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/log.h"
38 #include "libavutil/mem.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/avstring.h"
41 #include "libavutil/bprint.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/time.h"
45 #include "libavutil/timecode.h"
47 #include "libavutil/timestamp.h"
48 
49 typedef struct SegmentListEntry {
50  int index;
54  char *filename;
58 
59 typedef enum {
64  LIST_TYPE_EXT, ///< deprecated
67 } ListType;
68 
69 #define SEGMENT_LIST_FLAG_CACHE 1
70 #define SEGMENT_LIST_FLAG_LIVE 2
71 
72 typedef struct SegmentContext {
73  const AVClass *class; /**< Class for private options. */
74  int segment_idx; ///< index of the segment file to write, starting from 0
75  int segment_idx_wrap; ///< number after which the index wraps
76  int segment_idx_wrap_nb; ///< number of time the index has wrapped
77  int segment_count; ///< number of segment files already written
80  char *format; ///< format to use for output segment files
82  char *list; ///< filename for the segment list file
83  int list_flags; ///< flags affecting list generation
84  int list_size; ///< number of entries for the segment list file
85 
86  int is_nullctx; ///< whether avf->pb is a nullctx
87  int use_clocktime; ///< flag to cut segments at regular clock time
88  int64_t clocktime_offset; //< clock offset for cutting the segments at regular clock time
89  int64_t clocktime_wrap_duration; //< wrapping duration considered for starting a new segment
90  int64_t last_val; ///< remember last time for wrap around detection
92  int header_written; ///< whether we've already called avformat_write_header
93 
94  char *entry_prefix; ///< prefix to add to list entry filenames
95  int list_type; ///< set the list type
96  AVIOContext *list_pb; ///< list file put-byte context
97  int64_t time; ///< segment duration
98  int64_t min_seg_duration; ///< minimum segment duration
99  int use_strftime; ///< flag to expand filename with strftime
100  int increment_tc; ///< flag to increment timecode if found
101 
102  char *times_str; ///< segment times specification string
103  int64_t *times; ///< list of segment interval specification
104  int nb_times; ///< number of elements in the times array
105 
106  char *frames_str; ///< segment frame numbers specification string
107  int *frames; ///< list of frame number specification
108  int nb_frames; ///< number of elements in the frames array
109  int frame_count; ///< total number of reference frames
110  int segment_frame_count; ///< number of reference frames in the segment
111 
113  int individual_header_trailer; /**< Set by a private option. */
114  int write_header_trailer; /**< Set by a private option. */
115  char *header_filename; ///< filename to write the output header to
116 
117  int reset_timestamps; ///< reset timestamps at the beginning of each segment
118  int64_t initial_offset; ///< initial timestamps offset, expressed in microseconds
119  char *reference_stream_specifier; ///< reference stream specifier
121  int64_t reference_stream_first_pts; ///< initial timestamp, expressed in microseconds
124 
127 
132 
133 static void print_csv_escaped_str(AVIOContext *ctx, const char *str)
134 {
135  int needs_quoting = !!str[strcspn(str, "\",\n\r")];
136 
137  if (needs_quoting)
138  avio_w8(ctx, '"');
139 
140  for (; *str; str++) {
141  if (*str == '"')
142  avio_w8(ctx, '"');
143  avio_w8(ctx, *str);
144  }
145  if (needs_quoting)
146  avio_w8(ctx, '"');
147 }
148 
150 {
151  SegmentContext *seg = s->priv_data;
152  AVFormatContext *oc;
153  int i;
154  int ret;
155 
157  if (ret < 0)
158  return ret;
159  oc = seg->avf;
160 
161  oc->interrupt_callback = s->interrupt_callback;
162  oc->max_delay = s->max_delay;
163  av_dict_copy(&oc->metadata, s->metadata, 0);
164  oc->opaque = s->opaque;
165  oc->io_close2 = s->io_close2;
166  oc->io_open = s->io_open;
167  oc->flags = s->flags;
168 
169  for (i = 0; i < s->nb_streams; i++) {
170  AVStream *st, *ist = s->streams[i];
171  AVCodecParameters *ipar = ist->codecpar, *opar;
172 
173  st = ff_stream_clone(oc, ist);
174  if (!st)
175  return AVERROR(ENOMEM);
176  opar = st->codecpar;
177  if (!oc->oformat->codec_tag ||
178  av_codec_get_id (oc->oformat->codec_tag, ipar->codec_tag) == opar->codec_id ||
179  av_codec_get_tag(oc->oformat->codec_tag, ipar->codec_id) <= 0) {
180  opar->codec_tag = ipar->codec_tag;
181  } else {
182  opar->codec_tag = 0;
183  }
184  }
185 
186  return 0;
187 }
188 
190 {
191  SegmentContext *seg = s->priv_data;
192  AVFormatContext *oc = seg->avf;
193  size_t size;
194  int ret;
195  AVBPrint filename;
196  char *new_name;
197 
199  if (seg->segment_idx_wrap)
200  seg->segment_idx %= seg->segment_idx_wrap;
201  if (seg->use_strftime) {
202  time_t now0;
203  struct tm *tm, tmpbuf;
204  time(&now0);
205  tm = localtime_r(&now0, &tmpbuf);
206  av_bprint_strftime(&filename, s->url, tm);
207  if (!av_bprint_is_complete(&filename)) {
208  av_bprint_finalize(&filename, NULL);
209  return AVERROR(ENOMEM);
210  }
211  } else {
212  ret = ff_bprint_get_frame_filename(&filename, s->url, seg->segment_idx, 0);
213  if (ret < 0) {
214  av_bprint_finalize(&filename, NULL);
215  av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", s->url);
216  return ret;
217  }
218  }
219  ret = av_bprint_finalize(&filename, &new_name);
220  if (ret < 0)
221  return ret;
222  ff_format_set_url(oc, new_name);
223 
224  /* copy modified name in list entry */
225  size = strlen(av_basename(oc->url)) + 1;
226  if (seg->entry_prefix)
227  size += strlen(seg->entry_prefix);
228 
229  if ((ret = av_reallocp(&seg->cur_entry.filename, size)) < 0)
230  return ret;
231  snprintf(seg->cur_entry.filename, size, "%s%s",
232  seg->entry_prefix ? seg->entry_prefix : "",
233  av_basename(oc->url));
234 
235  return 0;
236 }
237 
239 {
240  SegmentContext *seg = s->priv_data;
241  AVFormatContext *oc = seg->avf;
242  int err = 0;
243 
244  if (write_header) {
246  seg->avf = NULL;
247  if ((err = segment_mux_init(s)) < 0)
248  return err;
249  oc = seg->avf;
250  }
251 
252  seg->segment_idx++;
253  if ((seg->segment_idx_wrap) && (seg->segment_idx % seg->segment_idx_wrap == 0))
254  seg->segment_idx_wrap_nb++;
255 
256  if ((err = set_segment_filename(s)) < 0)
257  return err;
258 
259  if ((err = s->io_open(s, &oc->pb, oc->url, AVIO_FLAG_WRITE, NULL)) < 0) {
260  av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", oc->url);
261  return err;
262  }
263  if (!seg->individual_header_trailer)
264  oc->pb->seekable = 0;
265 
266  if (oc->oformat->priv_class && oc->priv_data)
267  av_opt_set(oc->priv_data, "mpegts_flags", "+resend_headers", 0);
268 
269  if (write_header) {
272  av_dict_set(&options, "fflags", "-autobsf", 0);
273  err = avformat_write_header(oc, &options);
275  if (err < 0)
276  return err;
277  }
278 
279  seg->segment_frame_count = 0;
280  return 0;
281 }
282 
284 {
285  SegmentContext *seg = s->priv_data;
286  int ret;
287 
289  seg->temp_list_filename = av_asprintf(seg->use_rename ? "%s.tmp" : "%s", seg->list);
290  if (!seg->temp_list_filename)
291  return AVERROR(ENOMEM);
292  ret = s->io_open(s, &seg->list_pb, seg->temp_list_filename, AVIO_FLAG_WRITE, NULL);
293  if (ret < 0) {
294  av_log(s, AV_LOG_ERROR, "Failed to open segment list '%s'\n", seg->list);
295  return ret;
296  }
297 
298  if (seg->list_type == LIST_TYPE_M3U8 && seg->segment_list_entries) {
300  double max_duration = 0;
301 
302  avio_printf(seg->list_pb, "#EXTM3U\n");
303  avio_printf(seg->list_pb, "#EXT-X-VERSION:3\n");
304  avio_printf(seg->list_pb, "#EXT-X-MEDIA-SEQUENCE:%d\n", seg->segment_list_entries->index);
305  avio_printf(seg->list_pb, "#EXT-X-ALLOW-CACHE:%s\n",
306  seg->list_flags & SEGMENT_LIST_FLAG_CACHE ? "YES" : "NO");
307 
308  av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%d\n",
310 
311  for (entry = seg->segment_list_entries; entry; entry = entry->next)
312  max_duration = FFMAX(max_duration, entry->end_time - entry->start_time);
313  avio_printf(seg->list_pb, "#EXT-X-TARGETDURATION:%"PRId64"\n", (int64_t)ceil(max_duration));
314  } else if (seg->list_type == LIST_TYPE_FFCONCAT) {
315  avio_printf(seg->list_pb, "ffconcat version 1.0\n");
316  }
317 
318  return ret;
319 }
320 
321 static void segment_list_print_entry(AVIOContext *list_ioctx,
322  ListType list_type,
323  const SegmentListEntry *list_entry,
324  void *log_ctx)
325 {
326  switch (list_type) {
327  case LIST_TYPE_FLAT:
328  avio_printf(list_ioctx, "%s\n", list_entry->filename);
329  break;
330  case LIST_TYPE_CSV:
331  case LIST_TYPE_EXT:
332  print_csv_escaped_str(list_ioctx, list_entry->filename);
333  avio_printf(list_ioctx, ",%f,%f\n", list_entry->start_time, list_entry->end_time);
334  break;
335  case LIST_TYPE_M3U8:
336  avio_printf(list_ioctx, "#EXTINF:%f,\n%s\n",
337  list_entry->end_time - list_entry->start_time, list_entry->filename);
338  break;
339  case LIST_TYPE_FFCONCAT:
340  {
341  char *buf;
342  if (av_escape(&buf, list_entry->filename, NULL, AV_ESCAPE_MODE_AUTO, AV_ESCAPE_FLAG_WHITESPACE) < 0) {
343  av_log(log_ctx, AV_LOG_WARNING,
344  "Error writing list entry '%s' in list file\n", list_entry->filename);
345  return;
346  }
347  avio_printf(list_ioctx, "file %s\n", buf);
348  av_free(buf);
349  break;
350  }
351  default:
352  av_assert0(!"Invalid list type");
353  }
354 }
355 
356 static int segment_end(AVFormatContext *s, int write_trailer, int is_last)
357 {
358  SegmentContext *seg = s->priv_data;
359  AVFormatContext *oc = seg->avf;
360  int ret = 0;
361  AVTimecode tc;
362  AVRational rate;
363  AVDictionaryEntry *tcr;
364  char buf[AV_TIMECODE_STR_SIZE];
365  int i;
366  int err;
367 
368  if (!oc || !oc->pb)
369  return AVERROR(EINVAL);
370 
371  av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */
372  if (write_trailer)
373  ret = av_write_trailer(oc);
374 
375  if (ret < 0)
376  av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n",
377  oc->url);
378 
379  if (seg->list) {
380  if (seg->list_size || seg->list_type == LIST_TYPE_M3U8) {
381  SegmentListEntry *entry = av_mallocz(sizeof(*entry));
382  if (!entry) {
383  ret = AVERROR(ENOMEM);
384  goto end;
385  }
386 
387  /* append new element */
388  memcpy(entry, &seg->cur_entry, sizeof(*entry));
389  entry->filename = av_strdup(entry->filename);
390  if (!seg->segment_list_entries)
392  else
395 
396  /* drop first item */
397  if (seg->list_size && seg->segment_count >= seg->list_size) {
400  av_freep(&entry->filename);
401  av_freep(&entry);
402  }
403 
404  if ((ret = segment_list_open(s)) < 0)
405  goto end;
406  for (entry = seg->segment_list_entries; entry; entry = entry->next)
408  if (seg->list_type == LIST_TYPE_M3U8 && is_last)
409  avio_printf(seg->list_pb, "#EXT-X-ENDLIST\n");
410  ff_format_io_close(s, &seg->list_pb);
411  if (seg->use_rename)
412  ff_rename(seg->temp_list_filename, seg->list, s);
413  } else {
415  avio_flush(seg->list_pb);
416  }
417  }
418 
419  av_log(s, AV_LOG_VERBOSE, "segment:'%s' count:%d ended\n",
420  seg->avf->url, seg->segment_count);
421  seg->segment_count++;
422 
423  if (seg->increment_tc) {
424  tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
425  if (tcr) {
426  /* search the first video stream */
427  for (i = 0; i < s->nb_streams; i++) {
428  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
429  rate = s->streams[i]->avg_frame_rate;/* Get fps from the video stream */
430  err = av_timecode_init_from_string(&tc, rate, tcr->value, s);
431  if (err < 0) {
432  av_log(s, AV_LOG_WARNING, "Could not increment global timecode, error occurred during timecode creation.\n");
433  break;
434  }
435  tc.start += (int)((seg->cur_entry.end_time - seg->cur_entry.start_time) * av_q2d(rate));/* increment timecode */
436  av_dict_set(&s->metadata, "timecode",
437  av_timecode_make_string(&tc, buf, 0), 0);
438  break;
439  }
440  }
441  } else {
442  av_log(s, AV_LOG_WARNING, "Could not increment global timecode, no global timecode metadata found.\n");
443  }
444  for (i = 0; i < s->nb_streams; i++) {
445  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
446  char st_buf[AV_TIMECODE_STR_SIZE];
447  AVTimecode st_tc;
448  AVRational st_rate = s->streams[i]->avg_frame_rate;
449  AVDictionaryEntry *st_tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
450  if (st_tcr) {
451  if ((av_timecode_init_from_string(&st_tc, st_rate, st_tcr->value, s) < 0)) {
452  av_log(s, AV_LOG_WARNING, "Could not increment stream %d timecode, error occurred during timecode creation.\n", i);
453  continue;
454  }
455  st_tc.start += (int)((seg->cur_entry.end_time - seg->cur_entry.start_time) * av_q2d(st_rate)); // increment timecode
456  av_dict_set(&s->streams[i]->metadata, "timecode", av_timecode_make_string(&st_tc, st_buf, 0), 0);
457  }
458  }
459  }
460  }
461 
462 end:
463  ff_format_io_close(oc, &oc->pb);
464 
465  return ret;
466 }
467 
468 static int parse_times(void *log_ctx, int64_t **times, int *nb_times,
469  const char *times_str)
470 {
471  char *p;
472  int i, ret = 0;
473  char *times_str1 = av_strdup(times_str);
474  char *saveptr = NULL;
475 
476  if (!times_str1)
477  return AVERROR(ENOMEM);
478 
479 #define FAIL(err) ret = err; goto end
480 
481  *nb_times = 1;
482  for (p = times_str1; *p; p++)
483  if (*p == ',')
484  (*nb_times)++;
485 
486  *times = av_malloc_array(*nb_times, sizeof(**times));
487  if (!*times) {
488  av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced times array\n");
489  FAIL(AVERROR(ENOMEM));
490  }
491 
492  p = times_str1;
493  for (i = 0; i < *nb_times; i++) {
494  int64_t t;
495  char *tstr = av_strtok(p, ",", &saveptr);
496  p = NULL;
497 
498  if (!tstr || !tstr[0]) {
499  av_log(log_ctx, AV_LOG_ERROR, "Empty time specification in times list %s\n",
500  times_str);
501  FAIL(AVERROR(EINVAL));
502  }
503 
504  ret = av_parse_time(&t, tstr, 1);
505  if (ret < 0) {
506  av_log(log_ctx, AV_LOG_ERROR,
507  "Invalid time duration specification '%s' in times list %s\n", tstr, times_str);
508  FAIL(AVERROR(EINVAL));
509  }
510  (*times)[i] = t;
511 
512  /* check on monotonicity */
513  if (i && (*times)[i-1] > (*times)[i]) {
514  av_log(log_ctx, AV_LOG_ERROR,
515  "Specified time %f is smaller than the last time %f\n",
516  (float)((*times)[i])/1000000, (float)((*times)[i-1])/1000000);
517  FAIL(AVERROR(EINVAL));
518  }
519  }
520 
521 end:
522  av_free(times_str1);
523  return ret;
524 }
525 
526 static int parse_frames(void *log_ctx, int **frames, int *nb_frames,
527  const char *frames_str)
528 {
529  const char *p;
530  int i;
531 
532  *nb_frames = 1;
533  for (p = frames_str; *p; p++)
534  if (*p == ',')
535  (*nb_frames)++;
536 
537  *frames = av_malloc_array(*nb_frames, sizeof(**frames));
538  if (!*frames) {
539  av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced frames array\n");
540  return AVERROR(ENOMEM);
541  }
542 
543  p = frames_str;
544  for (i = 0; i < *nb_frames; i++) {
545  long int f;
546  char *tailptr;
547 
548  if (*p == '\0' || *p == ',') {
549  av_log(log_ctx, AV_LOG_ERROR, "Empty frame specification in frame list %s\n",
550  frames_str);
551  return AVERROR(EINVAL);
552  }
553  f = strtol(p, &tailptr, 10);
554  if (*tailptr != '\0' && *tailptr != ',' || f <= 0 || f >= INT_MAX) {
555  av_log(log_ctx, AV_LOG_ERROR,
556  "Invalid argument '%s', must be a positive integer < INT_MAX\n",
557  p);
558  return AVERROR(EINVAL);
559  }
560  if (*tailptr == ',')
561  tailptr++;
562  p = tailptr;
563  (*frames)[i] = f;
564 
565  /* check on monotonicity */
566  if (i && (*frames)[i-1] > (*frames)[i]) {
567  av_log(log_ctx, AV_LOG_ERROR,
568  "Specified frame %d is smaller than the last frame %d\n",
569  (*frames)[i], (*frames)[i-1]);
570  return AVERROR(EINVAL);
571  }
572  }
573 
574  return 0;
575 }
576 
578 {
579  int buf_size = 32768;
580  uint8_t *buf = av_malloc(buf_size);
581  if (!buf)
582  return AVERROR(ENOMEM);
583  *ctx = avio_alloc_context(buf, buf_size, 1, NULL, NULL, NULL, NULL);
584  if (!*ctx) {
585  av_free(buf);
586  return AVERROR(ENOMEM);
587  }
588  return 0;
589 }
590 
591 static void close_null_ctxp(AVIOContext **pb)
592 {
593  av_freep(&(*pb)->buffer);
594  avio_context_free(pb);
595 }
596 
598 {
599  SegmentContext *seg = s->priv_data;
600  int ret, i;
601 
602  seg->reference_stream_index = -1;
603  if (!strcmp(seg->reference_stream_specifier, "auto")) {
604  /* select first index of type with highest priority */
605  int type_index_map[AVMEDIA_TYPE_NB];
606  static const enum AVMediaType type_priority_list[] = {
612  };
613  enum AVMediaType type;
614 
615  for (i = 0; i < AVMEDIA_TYPE_NB; i++)
616  type_index_map[i] = -1;
617 
618  /* select first index for each type */
619  for (i = 0; i < s->nb_streams; i++) {
620  type = s->streams[i]->codecpar->codec_type;
621  if ((unsigned)type < AVMEDIA_TYPE_NB && type_index_map[type] == -1
622  /* ignore attached pictures/cover art streams */
623  && !(s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC))
624  type_index_map[type] = i;
625  }
626 
627  for (i = 0; i < FF_ARRAY_ELEMS(type_priority_list); i++) {
628  type = type_priority_list[i];
629  if ((seg->reference_stream_index = type_index_map[type]) >= 0)
630  break;
631  }
632  } else {
633  for (i = 0; i < s->nb_streams; i++) {
634  ret = avformat_match_stream_specifier(s, s->streams[i],
636  if (ret < 0)
637  return ret;
638  if (ret > 0) {
639  seg->reference_stream_index = i;
640  break;
641  }
642  }
643  }
644 
645  if (seg->reference_stream_index < 0) {
646  av_log(s, AV_LOG_ERROR, "Could not select stream matching identifier '%s'\n",
648  return AVERROR(EINVAL);
649  }
650 
651  return 0;
652 }
653 
655 {
656  SegmentContext *seg = s->priv_data;
657  SegmentListEntry *cur;
658 
659  ff_format_io_close(s, &seg->list_pb);
660  if (seg->avf) {
661  if (seg->is_nullctx)
662  close_null_ctxp(&seg->avf->pb);
663  else
664  ff_format_io_close(s, &seg->avf->pb);
666  seg->avf = NULL;
667  }
668  av_freep(&seg->times);
669  av_freep(&seg->frames);
670  av_freep(&seg->cur_entry.filename);
672 
673  cur = seg->segment_list_entries;
674  while (cur) {
675  SegmentListEntry *next = cur->next;
676  av_freep(&cur->filename);
677  av_free(cur);
678  cur = next;
679  }
680 }
681 
683 {
684  SegmentContext *seg = s->priv_data;
685  AVFormatContext *oc = seg->avf;
687  int ret;
688  int i;
689 
690  seg->segment_count = 0;
691  if (!seg->write_header_trailer)
692  seg->individual_header_trailer = 0;
693 
694  if (seg->header_filename) {
695  seg->write_header_trailer = 1;
696  seg->individual_header_trailer = 0;
697  }
698 
699  if (seg->initial_offset > 0) {
700  av_log(s, AV_LOG_WARNING, "NOTE: the option initial_offset is deprecated,"
701  "you can use output_ts_offset instead of it\n");
702  }
703 
704  if ((seg->time != 2000000) + !!seg->times_str + !!seg->frames_str > 1) {
706  "segment_time, segment_times, and segment_frames options "
707  "are mutually exclusive, select just one of them\n");
708  return AVERROR(EINVAL);
709  }
710 
711  if (seg->times_str || seg->frames_str)
712  seg->min_seg_duration = 0;
713 
714  if (seg->times_str) {
715  if ((ret = parse_times(s, &seg->times, &seg->nb_times, seg->times_str)) < 0)
716  return ret;
717  } else if (seg->frames_str) {
718  if ((ret = parse_frames(s, &seg->frames, &seg->nb_frames, seg->frames_str)) < 0)
719  return ret;
720  } else {
721  if (seg->use_clocktime) {
722  if (seg->time <= 0) {
723  av_log(s, AV_LOG_ERROR, "Invalid negative segment_time with segment_atclocktime option set\n");
724  return AVERROR(EINVAL);
725  }
726  seg->clocktime_offset = seg->time - (seg->clocktime_offset % seg->time);
727  }
728  if (seg->min_seg_duration > seg->time) {
729  av_log(s, AV_LOG_ERROR, "min_seg_duration cannot be greater than segment_time\n");
730  return AVERROR(EINVAL);
731  }
732  }
733 
734  if (seg->list) {
735  if (seg->list_type == LIST_TYPE_UNDEFINED) {
736  if (av_match_ext(seg->list, "csv" )) seg->list_type = LIST_TYPE_CSV;
737  else if (av_match_ext(seg->list, "ext" )) seg->list_type = LIST_TYPE_EXT;
738  else if (av_match_ext(seg->list, "m3u8")) seg->list_type = LIST_TYPE_M3U8;
739  else if (av_match_ext(seg->list, "ffcat,ffconcat")) seg->list_type = LIST_TYPE_FFCONCAT;
740  else seg->list_type = LIST_TYPE_FLAT;
741  }
742  if (!seg->list_size && seg->list_type != LIST_TYPE_M3U8) {
743  if ((ret = segment_list_open(s)) < 0)
744  return ret;
745  } else {
746  const char *proto = avio_find_protocol_name(seg->list);
747  seg->use_rename = proto && !strcmp(proto, "file");
748  }
749  }
750 
751  if (seg->list_type == LIST_TYPE_EXT)
752  av_log(s, AV_LOG_WARNING, "'ext' list type option is deprecated in favor of 'csv'\n");
753 
754  if ((ret = select_reference_stream(s)) < 0)
755  return ret;
756  av_log(s, AV_LOG_VERBOSE, "Selected stream id:%d type:%s\n",
758  av_get_media_type_string(s->streams[seg->reference_stream_index]->codecpar->codec_type));
759 
761 
762  seg->oformat = av_guess_format(seg->format, s->url, NULL);
763 
764  if (!seg->oformat)
766  if (seg->oformat->flags & AVFMT_NOFILE) {
767  av_log(s, AV_LOG_ERROR, "format %s not supported.\n",
768  seg->oformat->name);
769  return AVERROR(EINVAL);
770  }
771 
772  if ((ret = segment_mux_init(s)) < 0)
773  return ret;
774 
775  if ((ret = set_segment_filename(s)) < 0)
776  return ret;
777  oc = seg->avf;
778 
779  if (seg->write_header_trailer) {
780  if ((ret = s->io_open(s, &oc->pb,
781  seg->header_filename ? seg->header_filename : oc->url,
782  AVIO_FLAG_WRITE, NULL)) < 0) {
783  av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", oc->url);
784  return ret;
785  }
786  if (!seg->individual_header_trailer)
787  oc->pb->seekable = 0;
788  } else {
789  if ((ret = open_null_ctx(&oc->pb)) < 0)
790  return ret;
791  seg->is_nullctx = 1;
792  }
793 
795  av_dict_set(&options, "fflags", "-autobsf", 0);
797  if (av_dict_count(options)) {
799  "Some of the provided format options are not recognized\n");
801  return AVERROR(EINVAL);
802  }
804 
805  if (ret < 0) {
806  return ret;
807  }
808  seg->segment_frame_count = 0;
809 
810  av_assert0(s->nb_streams == oc->nb_streams);
813  if (ret < 0)
814  return ret;
815  seg->header_written = 1;
816  }
817 
818  for (i = 0; i < s->nb_streams; i++) {
819  AVStream *inner_st = oc->streams[i];
820  AVStream *outer_st = s->streams[i];
821  avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
822  }
823 
824  if (oc->avoid_negative_ts > 0 && s->avoid_negative_ts < 0)
825  s->avoid_negative_ts = 1;
826 
827  return ret;
828 }
829 
831 {
832  SegmentContext *seg = s->priv_data;
833  AVFormatContext *oc = seg->avf;
834  int ret;
835 
836  if (!seg->header_written) {
838  if (ret < 0)
839  return ret;
840  }
841 
842  if (!seg->write_header_trailer || seg->header_filename) {
843  if (seg->header_filename) {
844  av_write_frame(oc, NULL);
845  ff_format_io_close(oc, &oc->pb);
846  } else {
847  close_null_ctxp(&oc->pb);
848  seg->is_nullctx = 0;
849  }
850  if ((ret = oc->io_open(oc, &oc->pb, oc->url, AVIO_FLAG_WRITE, NULL)) < 0)
851  return ret;
852  if (!seg->individual_header_trailer)
853  oc->pb->seekable = 0;
854  }
855 
856  return 0;
857 }
858 
860 {
861  SegmentContext *seg = s->priv_data;
862  AVStream *st = s->streams[pkt->stream_index];
863  int64_t end_pts = INT64_MAX, offset, pkt_pts_avtb;
864  int start_frame = INT_MAX;
865  int ret;
866  struct tm ti;
867  int64_t usecs;
868  int64_t wrapped_val;
869 
870  if (!seg->avf || !seg->avf->pb)
871  return AVERROR(EINVAL);
872 
873  if (!st->codecpar->extradata_size) {
874  size_t pkt_extradata_size;
875  uint8_t *pkt_extradata = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &pkt_extradata_size);
876  if (pkt_extradata && pkt_extradata_size > 0) {
877  ret = ff_alloc_extradata(st->codecpar, pkt_extradata_size);
878  if (ret < 0) {
879  av_log(s, AV_LOG_WARNING, "Unable to add extradata to stream. Output segments may be invalid.\n");
880  goto calc_times;
881  }
882  memcpy(st->codecpar->extradata, pkt_extradata, pkt_extradata_size);
883  }
884  }
885 
886 calc_times:
887  if (seg->times) {
888  end_pts = seg->segment_count < seg->nb_times ?
889  seg->times[seg->segment_count] : INT64_MAX;
890  } else if (seg->frames) {
891  start_frame = seg->segment_count < seg->nb_frames ?
892  seg->frames[seg->segment_count] : INT_MAX;
893  } else {
894  if (seg->use_clocktime) {
895  int64_t avgt = av_gettime();
896  time_t sec = avgt / 1000000;
897  localtime_r(&sec, &ti);
898  usecs = (int64_t)(ti.tm_hour * 3600 + ti.tm_min * 60 + ti.tm_sec) * 1000000 + (avgt % 1000000);
899  wrapped_val = (usecs + seg->clocktime_offset) % seg->time;
900  if (wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration)
901  seg->cut_pending = 1;
902  seg->last_val = wrapped_val;
903  } else {
904  end_pts = seg->time * (seg->segment_count + 1);
905  }
906  }
907 
908  ff_dlog(s, "packet stream:%d pts:%s pts_time:%s duration_time:%s is_key:%d frame:%d\n",
912  pkt->stream_index == seg->reference_stream_index ? seg->frame_count : -1);
913 
916  pkt->pts != AV_NOPTS_VALUE) {
918  }
919 
921  end_pts += (INT64_MAX - end_pts >= seg->reference_stream_first_pts) ?
923  INT64_MAX - end_pts;
924  }
925 
926  if (pkt->pts != AV_NOPTS_VALUE)
927  pkt_pts_avtb = av_rescale_q(pkt->pts, st->time_base, AV_TIME_BASE_Q);
928 
929  if (pkt->stream_index == seg->reference_stream_index &&
931  (seg->segment_frame_count > 0 || seg->write_empty) &&
932  (seg->cut_pending || seg->frame_count >= start_frame ||
933  (pkt->pts != AV_NOPTS_VALUE &&
934  pkt_pts_avtb - seg->cur_entry.start_pts >= seg->min_seg_duration &&
936  end_pts - seg->time_delta, AV_TIME_BASE_Q) >= 0))) {
937  /* sanitize end time in case last packet didn't have a defined duration */
938  if (seg->cur_entry.last_duration == 0)
939  seg->cur_entry.end_time = (double)pkt->pts * av_q2d(st->time_base);
940 
941  if ((ret = segment_end(s, seg->individual_header_trailer, 0)) < 0)
942  goto fail;
943 
944  if ((ret = segment_start(s, seg->individual_header_trailer)) < 0)
945  goto fail;
946 
947  seg->cut_pending = 0;
952 
953  if (seg->times || (!seg->frames && !seg->use_clocktime) && seg->write_empty)
954  goto calc_times;
955  }
956 
957  if (pkt->stream_index == seg->reference_stream_index) {
958  if (pkt->pts != AV_NOPTS_VALUE)
959  seg->cur_entry.end_time =
960  FFMAX(seg->cur_entry.end_time, (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));
962  }
963 
964  if (seg->segment_frame_count == 0) {
965  av_log(s, AV_LOG_VERBOSE, "segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d\n",
966  seg->avf->url, pkt->stream_index,
968  }
969 
970  av_log(s, AV_LOG_DEBUG, "stream:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s",
971  pkt->stream_index,
975 
976  /* compute new timestamps */
979  if (pkt->pts != AV_NOPTS_VALUE)
980  pkt->pts += offset;
981  if (pkt->dts != AV_NOPTS_VALUE)
982  pkt->dts += offset;
983 
984  av_log(s, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",
987 
989  seg->initial_offset || seg->reset_timestamps ||
991 
992 fail:
993  /* Use st->index here as the packet returned from ff_write_chained()
994  * is blank if interleaving has been used. */
995  if (st->index == seg->reference_stream_index) {
996  seg->frame_count++;
997  seg->segment_frame_count++;
998  }
999 
1000  return ret;
1001 }
1002 
1004 {
1005  SegmentContext *seg = s->priv_data;
1006  AVFormatContext *oc = seg->avf;
1007  int ret;
1008 
1009  if (!oc)
1010  return 0;
1011 
1012  if (!seg->write_header_trailer) {
1013  if ((ret = segment_end(s, 0, 1)) < 0)
1014  return ret;
1015  if ((ret = open_null_ctx(&oc->pb)) < 0)
1016  return ret;
1017  seg->is_nullctx = 1;
1018  ret = av_write_trailer(oc);
1019  } else {
1020  ret = segment_end(s, 1, 1);
1021  }
1022  return ret;
1023 }
1024 
1026  const AVPacket *pkt)
1027 {
1028  SegmentContext *seg = s->priv_data;
1029  AVFormatContext *oc = seg->avf;
1030  if (ffofmt(oc->oformat)->check_bitstream) {
1031  AVStream *const ost = oc->streams[st->index];
1032  int ret = ffofmt(oc->oformat)->check_bitstream(oc, ost, pkt);
1033  if (ret == 1) {
1034  FFStream *const sti = ffstream(st);
1035  FFStream *const osti = ffstream(ost);
1036  sti->bsfc = osti->bsfc;
1037  osti->bsfc = NULL;
1038  }
1039  return ret;
1040  }
1041  return 1;
1042 }
1043 
1044 #define OFFSET(x) offsetof(SegmentContext, x)
1045 #define E AV_OPT_FLAG_ENCODING_PARAM
1046 static const AVOption options[] = {
1047  { "reference_stream", "set reference stream", OFFSET(reference_stream_specifier), AV_OPT_TYPE_STRING, {.str = "auto"}, 0, 0, E },
1048  { "segment_format", "set container format used for the segments", OFFSET(format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
1049  { "segment_format_options", "set list of options for the container format used for the segments", OFFSET(format_options), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, E },
1050  { "segment_list", "set the segment list filename", OFFSET(list), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
1051  { "segment_header_filename", "write a single file containing the header", OFFSET(header_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
1052 
1053  { "segment_list_flags","set flags affecting segment list generation", OFFSET(list_flags), AV_OPT_TYPE_FLAGS, {.i64 = SEGMENT_LIST_FLAG_CACHE }, 0, UINT_MAX, E, .unit = "list_flags"},
1054  { "cache", "allow list caching", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_LIST_FLAG_CACHE }, INT_MIN, INT_MAX, E, .unit = "list_flags"},
1055  { "live", "enable live-friendly list generation (useful for HLS)", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_LIST_FLAG_LIVE }, INT_MIN, INT_MAX, E, .unit = "list_flags"},
1056 
1057  { "segment_list_size", "set the maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
1058 
1059  { "segment_list_type", "set the segment list type", OFFSET(list_type), AV_OPT_TYPE_INT, {.i64 = LIST_TYPE_UNDEFINED}, -1, LIST_TYPE_NB-1, E, .unit = "list_type" },
1060  { "flat", "flat format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, E, .unit = "list_type" },
1061  { "csv", "csv format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_CSV }, INT_MIN, INT_MAX, E, .unit = "list_type" },
1062  { "ext", "extended format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_EXT }, INT_MIN, INT_MAX, E, .unit = "list_type" },
1063  { "ffconcat", "ffconcat format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_FFCONCAT }, INT_MIN, INT_MAX, E, .unit = "list_type" },
1064  { "m3u8", "M3U8 format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, .unit = "list_type" },
1065  { "hls", "Apple HTTP Live Streaming compatible", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, .unit = "list_type" },
1066 
1067  { "segment_atclocktime", "set segment to be cut at clocktime", OFFSET(use_clocktime), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E},
1068  { "segment_clocktime_offset", "set segment clocktime offset", OFFSET(clocktime_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, 86400000000LL, E},
1069  { "segment_clocktime_wrap_duration", "set segment clocktime wrapping duration", OFFSET(clocktime_wrap_duration), AV_OPT_TYPE_DURATION, {.i64 = INT64_MAX}, 0, INT64_MAX, E},
1070  { "segment_time", "set segment duration", OFFSET(time),AV_OPT_TYPE_DURATION, {.i64 = 2000000}, INT64_MIN, INT64_MAX, E },
1071  { "segment_time_delta","set approximation value used for the segment times", OFFSET(time_delta), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, E },
1072  { "min_seg_duration", "set minimum segment duration", OFFSET(min_seg_duration), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, E },
1073  { "segment_times", "set segment split time points", OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL}, 0, 0, E },
1074  { "segment_frames", "set segment split frame numbers", OFFSET(frames_str),AV_OPT_TYPE_STRING,{.str = NULL}, 0, 0, E },
1075  { "segment_wrap", "set number after which the index wraps", OFFSET(segment_idx_wrap), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
1076  { "segment_list_entry_prefix", "set base url prefix for segments", OFFSET(entry_prefix), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
1077  { "segment_start_number", "set the sequence number of the first segment", OFFSET(segment_idx), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
1078  { "segment_wrap_number", "set the number of wrap before the first segment", OFFSET(segment_idx_wrap_nb), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
1079  { "strftime", "set filename expansion with strftime at segment creation", OFFSET(use_strftime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
1080  { "increment_tc", "increment timecode between each segment", OFFSET(increment_tc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
1081  { "break_non_keyframes", "allow breaking segments on non-keyframes", OFFSET(break_non_keyframes), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
1082 
1083  { "individual_header_trailer", "write header/trailer to each segment", OFFSET(individual_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },
1084  { "write_header_trailer", "write a header to the first segment and a trailer to the last one", OFFSET(write_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },
1085  { "reset_timestamps", "reset timestamps at the beginning of each segment", OFFSET(reset_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
1086  { "initial_offset", "set initial timestamp offset", OFFSET(initial_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX, INT64_MAX, E },
1087  { "write_empty_segments", "allow writing empty 'filler' segments", OFFSET(write_empty), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
1088  { NULL },
1089 };
1090 
1091 static const AVClass seg_class = {
1092  .class_name = "(stream) segment muxer",
1093  .item_name = av_default_item_name,
1094  .option = options,
1095  .version = LIBAVUTIL_VERSION_INT,
1096 };
1097 
1098 #if CONFIG_SEGMENT_MUXER
1100  .p.name = "segment",
1101  .p.long_name = NULL_IF_CONFIG_SMALL("segment"),
1102  .p.flags = AVFMT_NOFILE|AVFMT_GLOBALHEADER,
1103  .p.priv_class = &seg_class,
1104  .priv_data_size = sizeof(SegmentContext),
1105  .init = seg_init,
1109  .deinit = seg_free,
1111 };
1112 #endif
1113 
1114 #if CONFIG_STREAM_SEGMENT_MUXER
1116  .p.name = "stream_segment,ssegment",
1117  .p.long_name = NULL_IF_CONFIG_SMALL("streaming segment muxer"),
1118  .p.flags = AVFMT_NOFILE,
1119  .p.priv_class = &seg_class,
1120  .priv_data_size = sizeof(SegmentContext),
1121  .init = seg_init,
1125  .deinit = seg_free,
1127 };
1128 #endif
SEGMENT_LIST_FLAG_LIVE
#define SEGMENT_LIST_FLAG_LIVE
Definition: segment.c:70
SegmentContext::write_header_trailer
int write_header_trailer
Set by a private option.
Definition: segment.c:114
SegmentListEntry::index
int index
Definition: segment.c:50
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
av_codec_get_id
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
LIST_TYPE_UNDEFINED
@ LIST_TYPE_UNDEFINED
Definition: segment.c:60
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
SegmentContext::clocktime_wrap_duration
int64_t clocktime_wrap_duration
Definition: segment.c:89
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
entry
#define entry
Definition: aom_film_grain_template.c:66
SegmentContext::min_seg_duration
int64_t min_seg_duration
minimum segment duration
Definition: segment.c:98
SegmentContext::avf
AVFormatContext * avf
Definition: segment.c:79
AVOutputFormat::name
const char * name
Definition: avformat.h:506
AVSTREAM_INIT_IN_WRITE_HEADER
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
Definition: avformat.h:2384
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
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
SegmentContext::list_pb
AVIOContext * list_pb
list file put-byte context
Definition: segment.c:96
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
FFStream::bsfc
struct AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:146
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
segment_start
static int segment_start(AVFormatContext *s, int write_header)
Definition: segment.c:238
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:670
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:37
LIST_TYPE_CSV
@ LIST_TYPE_CSV
Definition: segment.c:62
SegmentContext::use_clocktime
int use_clocktime
flag to cut segments at regular clock time
Definition: segment.c:87
avio_context_free
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:126
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
int64_t
long long int64_t
Definition: coverity.c:34
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
SegmentContext::list_type
int list_type
set the list type
Definition: segment.c:95
ff_stream_segment_muxer
const FFOutputFormat ff_stream_segment_muxer
SegmentContext::nb_frames
int nb_frames
number of elements in the frames array
Definition: segment.c:108
SegmentContext::segment_idx_wrap
int segment_idx_wrap
number after which the index wraps
Definition: segment.c:75
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1332
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:52
segment_mux_init
static int segment_mux_init(AVFormatContext *s)
Definition: segment.c:149
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, const 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:109
AVOption
AVOption.
Definition: opt.h:429
SegmentContext::segment_count
int segment_count
number of segment files already written
Definition: segment.c:77
SegmentContext::times_str
char * times_str
segment times specification string
Definition: segment.c:102
SegmentContext::break_non_keyframes
int break_non_keyframes
Definition: segment.c:122
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Underlying C type is int64_t.
Definition: opt.h:319
SegmentContext::frames_str
char * frames_str
segment frame numbers specification string
Definition: segment.c:106
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:576
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
mathematics.h
AVDictionary
Definition: dict.c:32
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FAIL
#define FAIL(err)
avformat_init_output
av_warn_unused_result int avformat_init_output(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and initialize the codec, but do not write the header.
Definition: mux.c:446
SegmentContext::cur_entry
SegmentListEntry cur_entry
Definition: segment.c:128
SegmentContext::list
char * list
filename for the segment list file
Definition: segment.c:82
SegmentListEntry::next
struct SegmentListEntry * next
Definition: segment.c:55
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:613
av_basename
const char * av_basename(const char *path)
Thread safe basename.
Definition: avstring.c:253
SegmentContext::time
int64_t time
segment duration
Definition: segment.c:97
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
SegmentContext::use_rename
int use_rename
Definition: segment.c:125
SegmentContext::is_nullctx
int is_nullctx
whether avf->pb is a nullctx
Definition: segment.c:86
segment_end
static int segment_end(AVFormatContext *s, int write_trailer, int is_last)
Definition: segment.c:356
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1534
SegmentListEntry
Definition: segment.c:49
SegmentContext::nb_times
int nb_times
number of elements in the times array
Definition: segment.c:104
parse_frames
static int parse_frames(void *log_ctx, int **frames, int *nb_frames, const char *frames_str)
Definition: segment.c:526
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:777
seg_write_header
static int seg_write_header(AVFormatContext *s)
Definition: segment.c:830
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:347
av_escape
int av_escape(char **dst, const char *src, const char *special_chars, enum AVEscapeMode mode, int flags)
Escape string in src, and put the escaped string in an allocated string in *dst, which must be freed ...
Definition: avstring.c:328
fail
#define fail()
Definition: checkasm.h:200
frames
if it could not because there are no more frames
Definition: filter_design.txt:267
timecode.h
SegmentContext::reference_stream_index
int reference_stream_index
Definition: segment.c:120
AVTimecode::start
int start
timecode frame start (first base frame number)
Definition: timecode.h:42
SegmentContext::oformat
const AVOutputFormat * oformat
Definition: segment.c:78
type
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 type
Definition: writing_filters.txt:86
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
ff_bprint_get_frame_filename
int ff_bprint_get_frame_filename(struct AVBPrint *buf, const char *path, int64_t number, int flags)
Return in 'buf' the path with 'd' replaced by a number.
Definition: utils.c:289
close_null_ctxp
static void close_null_ctxp(AVIOContext **pb)
Definition: segment.c:591
SegmentContext::cut_pending
int cut_pending
Definition: segment.c:91
AV_ESCAPE_FLAG_WHITESPACE
#define AV_ESCAPE_FLAG_WHITESPACE
Consider spaces special and escape them even in the middle of the string.
Definition: avstring.h:329
ff_rename
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap ffurl_move() and log if error happens.
Definition: avio.c:862
AVRational::num
int num
Numerator.
Definition: rational.h:59
select_reference_stream
static int select_reference_stream(AVFormatContext *s)
Definition: segment.c:597
seg_check_bitstream
static int seg_check_bitstream(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: segment.c:1025
SegmentContext::use_strftime
int use_strftime
flag to expand filename with strftime
Definition: segment.c:99
avassert.h
SegmentContext::reset_timestamps
int reset_timestamps
reset timestamps at the beginning of each segment
Definition: segment.c:117
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
SegmentContext::frame_count
int frame_count
total number of reference frames
Definition: segment.c:109
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1496
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
SegmentListEntry::offset_pts
int64_t offset_pts
Definition: segment.c:53
SegmentContext::format
char * format
format to use for output segment files
Definition: segment.c:80
seg_write_trailer
static int seg_write_trailer(struct AVFormatContext *s)
Definition: segment.c:1003
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1415
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:179
av_match_ext
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:41
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AVMEDIA_TYPE_NB
@ AVMEDIA_TYPE_NB
Definition: avutil.h:205
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
SegmentContext::write_empty
int write_empty
Definition: segment.c:123
SegmentListEntry::last_duration
int64_t last_duration
Definition: segment.c:56
ffofmt
static const FFOutputFormat * ffofmt(const AVOutputFormat *fmt)
Definition: mux.h:167
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
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:531
AVFormatContext::opaque
void * opaque
User data.
Definition: avformat.h:1823
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:202
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:467
SegmentListEntry::start_pts
int64_t start_pts
Definition: segment.c:52
time_internal.h
if
if(ret)
Definition: filter_design.txt:179
seg_init
static int seg_init(AVFormatContext *s)
Definition: segment.c:682
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:228
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
internal.h
SegmentContext::format_options
AVDictionary * format_options
Definition: segment.c:81
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:783
NULL
#define NULL
Definition: coverity.c:32
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:101
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
LIST_TYPE_EXT
@ LIST_TYPE_EXT
deprecated
Definition: segment.c:64
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Underlying C type is AVDictionary*.
Definition: opt.h:290
SegmentContext::frames
int * frames
list of frame number specification
Definition: segment.c:107
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1306
parseutils.h
list
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 list
Definition: filter_design.txt:25
options
Definition: swscale.c:43
FFOutputFormat
Definition: mux.h:61
double
double
Definition: af_crystalizer.c:132
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:592
time.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:184
SegmentContext::reference_stream_first_pts
int64_t reference_stream_first_pts
initial timestamp, expressed in microseconds
Definition: segment.c:121
set_segment_filename
static int set_segment_filename(AVFormatContext *s)
Definition: segment.c:189
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:534
av_bprint_strftime
void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm)
Append a formatted date and time to a print buffer.
Definition: bprint.c:166
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:1176
AV_ESCAPE_MODE_AUTO
@ AV_ESCAPE_MODE_AUTO
Use auto-selected escaping mode.
Definition: avstring.h:315
seg_write_packet
static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: segment.c:859
segment_list_open
static int segment_list_open(AVFormatContext *s)
Definition: segment.c:283
SegmentContext::clocktime_offset
int64_t clocktime_offset
Definition: segment.c:88
OFFSET
#define OFFSET(x)
Definition: segment.c:1044
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1320
AVOutputFormat::flags
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:525
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
SegmentContext::entry_prefix
char * entry_prefix
prefix to add to list entry filenames
Definition: segment.c:94
LIST_TYPE_FLAT
@ LIST_TYPE_FLAT
Definition: segment.c:61
SegmentContext::increment_tc
int increment_tc
flag to increment timecode if found
Definition: segment.c:100
print_csv_escaped_str
static void print_csv_escaped_str(AVIOContext *ctx, const char *str)
Definition: segment.c:133
SegmentContext::segment_list_entries_end
SegmentListEntry * segment_list_entries_end
Definition: segment.c:130
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
AVMediaType
AVMediaType
Definition: avutil.h:198
avformat_match_stream_specifier
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: avformat.c:614
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:94
av_codec_get_tag
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
FFStream
Definition: internal.h:128
localtime_r
#define localtime_r
Definition: time_internal.h:46
SegmentContext::time_delta
int64_t time_delta
Definition: segment.c:112
FFOutputFormat::check_bitstream
int(* check_bitstream)(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Set up any necessary bitstream filtering and extract any extra data needed for the global header.
Definition: mux.h:163
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1380
size
int size
Definition: twinvq_data.h:10344
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:188
SegmentContext
Definition: f_segment.c:33
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
seg_free
static void seg_free(AVFormatContext *s)
Definition: segment.c:654
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
LIST_TYPE_NB
@ LIST_TYPE_NB
Definition: segment.c:66
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:868
SegmentContext::header_written
int header_written
whether we've already called avformat_write_header
Definition: segment.c:92
ListType
ListType
Definition: segment.c:59
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:557
FFOutputFormat::interleave_packet
int(* interleave_packet)(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
A format-specific function for interleavement.
Definition: mux.h:102
SegmentContext::segment_frame_count
int segment_frame_count
number of reference frames in the segment
Definition: segment.c:110
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
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:564
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:233
LIST_TYPE_M3U8
@ LIST_TYPE_M3U8
Definition: segment.c:63
SegmentContext::segment_idx_wrap_nb
int segment_idx_wrap_nb
number of time the index has wrapped
Definition: segment.c:76
SegmentListEntry::end_time
double end_time
Definition: segment.c:51
SegmentContext::last_val
int64_t last_val
remember last time for wrap around detection
Definition: segment.c:90
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:1238
SegmentContext::segment_idx
int segment_idx
index of the segment file to write, starting from 0
Definition: segment.c:74
bprint.h
SegmentContext::reference_stream_specifier
char * reference_stream_specifier
reference stream specifier
Definition: segment.c:119
log.h
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:477
AVOutputFormat
Definition: avformat.h:505
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:551
SegmentListEntry::start_time
double start_time
Definition: segment.c:51
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:253
internal.h
AVERROR_MUXER_NOT_FOUND
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
Definition: error.h:62
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
check_bitstream
static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)
Definition: mux.c:1056
AVFormatContext::avoid_negative_ts
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1648
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:204
AVFormatContext::max_delay
int max_delay
Definition: avformat.h:1409
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:256
SegmentContext::list_size
int list_size
number of entries for the segment list file
Definition: segment.c:84
write_packet
static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
Definition: ffmpeg_mux.c:209
SegmentContext::segment_list_entries
SegmentListEntry * segment_list_entries
Definition: segment.c:129
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
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:81
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1283
avformat.h
E
#define E
Definition: segment.c:1045
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:750
AVRational::den
int den
Denominator.
Definition: rational.h:60
options
static const AVOption options[]
Definition: segment.c:1046
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
segment_list_print_entry
static void segment_list_print_entry(AVIOContext *list_ioctx, ListType list_type, const SegmentListEntry *list_entry, void *log_ctx)
Definition: segment.c:321
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
SegmentContext::header_filename
char * header_filename
filename to write the output header to
Definition: segment.c:115
AVFormatContext::io_open
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1864
SegmentContext::individual_header_trailer
int individual_header_trailer
Set by a private option.
Definition: segment.c:113
SegmentContext::list_flags
int list_flags
flags affecting list generation
Definition: segment.c:83
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AVPacket::stream_index
int stream_index
Definition: packet.h:560
seg_class
static const AVClass seg_class
Definition: segment.c:1091
SegmentContext::times
int64_t * times
list of segment interval specification
Definition: segment.c:103
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
SegmentContext::temp_list_filename
char * temp_list_filename
Definition: segment.c:126
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
av_guess_format
const 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:79
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
ff_stream_clone
AVStream * ff_stream_clone(AVFormatContext *dst_ctx, const AVStream *src)
Create a new stream and copy to it all parameters from a source stream, with the exception of the ind...
Definition: avformat.c:238
AVPacket
This structure stores compressed data.
Definition: packet.h:535
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
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:86
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:247
SEGMENT_LIST_FLAG_CACHE
#define SEGMENT_LIST_FLAG_CACHE
Definition: segment.c:69
AVFormatContext::io_close2
int(* io_close2)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
Definition: avformat.h:1874
parse_times
static int parse_times(void *log_ctx, int64_t **times, int *nb_times, const char *times_str)
Definition: segment.c:468
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:658
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
timestamp.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SegmentContext::initial_offset
int64_t initial_offset
initial timestamps offset, expressed in microseconds
Definition: segment.c:118
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
av_timecode_init_from_string
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:232
AVDictionaryEntry::value
char * value
Definition: dict.h:92
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:384
AVTimecode
Definition: timecode.h:41
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:95
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:887
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
ff_segment_muxer
const FFOutputFormat ff_segment_muxer
snprintf
#define snprintf
Definition: snprintf.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1292
ff_format_set_url
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: avformat.c:861
open_null_ctx
static int open_null_ctx(AVIOContext **ctx)
Definition: segment.c:577
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum_arg)
Load timecode string in buf.
Definition: timecode.c:104
LIST_TYPE_FFCONCAT
@ LIST_TYPE_FFCONCAT
Definition: segment.c:65
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:233
mux.h
SegmentListEntry::filename
char * filename
Definition: segment.c:54
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:1337