68 #define SEGMENT_LIST_FLAG_CACHE 1
69 #define SEGMENT_LIST_FLAG_LIVE 2
133 int needs_quoting = !!str[strcspn(str,
"\",\n\r")];
138 for (; *str; str++) {
202 struct tm *tm, tmpbuf;
288 double max_duration = 0;
301 avio_printf(seg->
list_pb,
"#EXT-X-TARGETDURATION:%"PRId64
"\n", (int64_t)ceil(max_duration));
332 "Error writing list entry '%s' in list file\n", list_entry->
filename);
376 memcpy(entry, &seg->
cur_entry,
sizeof(*entry));
420 av_log(s,
AV_LOG_WARNING,
"Could not increment timecode, error occurred during timecode creation.");
440 static int parse_times(
void *log_ctx, int64_t **times,
int *nb_times,
441 const char *times_str)
446 char *saveptr =
NULL;
451 #define FAIL(err) ret = err; goto end
454 for (p = times_str1; *p; p++)
465 for (i = 0; i < *nb_times; i++) {
467 char *tstr =
av_strtok(p,
",", &saveptr);
470 if (!tstr || !tstr[0]) {
479 "Invalid time duration specification '%s' in times list %s\n", tstr, times_str);
485 if (i && (*times)[i-1] > (*times)[i]) {
487 "Specified time %f is greater than the following time %f\n",
488 (
float)((*times)[i])/1000000, (
float)((*times)[i-1])/1000000);
499 const char *frames_str)
503 char *frames_str1 =
av_strdup(frames_str);
504 char *saveptr =
NULL;
509 #define FAIL(err) ret = err; goto end
512 for (p = frames_str1; *p; p++)
523 for (i = 0; i < *nb_frames; i++) {
526 char *fstr =
av_strtok(p,
",", &saveptr);
534 f = strtol(fstr, &tailptr, 10);
535 if (*tailptr || f <= 0 || f >= INT_MAX) {
537 "Invalid argument '%s', must be a positive integer <= INT64_MAX\n",
544 if (i && (*frames)[i-1] > (*frames)[i]) {
546 "Specified frame %d is greater than the following frame %d\n",
547 (*frames)[i], (*frames)[i-1]);
559 int buf_size = 32768;
586 static const enum AVMediaType type_priority_list[] = {
596 type_index_map[i] = -1;
601 if ((
unsigned)type < AVMEDIA_TYPE_NB && type_index_map[type] == -1
604 type_index_map[
type] = i;
608 type = type_priority_list[i];
661 "you can use output_ts_offset instead of it\n");
666 "segment_time, segment_times, and segment_frames options "
667 "are mutually exclusive, select just one of them\n");
683 "Invalid time duration specification '%s' for segment_time option\n",
688 if (seg->
time <= 0) {
689 av_log(s,
AV_LOG_ERROR,
"Invalid negative segment_time with segment_atclocktime option set\n");
718 seg->
use_rename = proto && !strcmp(proto,
"file");
767 "Some of the provided format options in '%s' are not recognized\n", seg->
format_options_str);
848 int64_t end_pts = INT64_MAX,
offset;
849 int start_frame = INT_MAX;
868 time_t sec = avgt / 1000000;
870 usecs = (int64_t)(ti.tm_hour * 3600 + ti.tm_min * 60 + ti.tm_sec) * 1000000 + (avgt % 1000000);
872 if (wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration)
880 ff_dlog(s,
"packet stream:%d pts:%s pts_time:%s duration_time:%s is_key:%d frame:%d\n",
921 av_log(s,
AV_LOG_VERBOSE,
"segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d\n",
926 av_log(s,
AV_LOG_DEBUG,
"stream:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s",
1017 #define OFFSET(x) offsetof(SegmentContext, x)
1018 #define E AV_OPT_FLAG_ENCODING_PARAM
1020 {
"reference_stream",
"set reference stream",
OFFSET(reference_stream_specifier),
AV_OPT_TYPE_STRING, {.str =
"auto"}, CHAR_MIN, CHAR_MAX,
E },
1022 {
"segment_format_options",
"set list of options for the container format used for the segments",
OFFSET(format_options_str),
AV_OPT_TYPE_STRING, {.str =
NULL}, 0, 0,
E },
1024 {
"segment_header_filename",
"write a single file containing the header",
OFFSET(header_filename),
AV_OPT_TYPE_STRING, {.str =
NULL}, 0, 0,
E },
1030 {
"segment_list_size",
"set the maximum number of playlist entries",
OFFSET(list_size),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
E },
1040 {
"segment_atclocktime",
"set segment to be cut at clocktime",
OFFSET(use_clocktime),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
E},
1041 {
"segment_clocktime_offset",
"set segment clocktime offset",
OFFSET(clocktime_offset),
AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, 86400000000LL,
E},
1042 {
"segment_clocktime_wrap_duration",
"set segment clocktime wrapping duration",
OFFSET(clocktime_wrap_duration),
AV_OPT_TYPE_DURATION, {.i64 = INT64_MAX}, 0, INT64_MAX,
E},
1044 {
"segment_time_delta",
"set approximation value used for the segment times",
OFFSET(time_delta),
AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, 0,
E },
1047 {
"segment_wrap",
"set number after which the index wraps",
OFFSET(segment_idx_wrap),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
E },
1049 {
"segment_start_number",
"set the sequence number of the first segment",
OFFSET(segment_idx),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
E },
1050 {
"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 },
1051 {
"strftime",
"set filename expansion with strftime at segment creation",
OFFSET(use_strftime),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1,
E },
1052 {
"increment_tc",
"increment timecode between each segment",
OFFSET(increment_tc),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1,
E },
1053 {
"break_non_keyframes",
"allow breaking segments on non-keyframes",
OFFSET(break_non_keyframes),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
E },
1055 {
"individual_header_trailer",
"write header/trailer to each segment",
OFFSET(individual_header_trailer),
AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1,
E },
1056 {
"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 },
1057 {
"reset_timestamps",
"reset timestamps at the begin of each segment",
OFFSET(reset_timestamps),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
E },
1058 {
"initial_offset",
"set initial timestamp offset",
OFFSET(initial_offset),
AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX, INT64_MAX,
E },
1059 {
"write_empty_segments",
"allow writing empty 'filler' segments",
OFFSET(write_empty),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
E },
1081 .priv_class = &seg_class,
1092 .
name =
"stream_segment,ssegment",
1102 .priv_class = &sseg_class,
struct SegmentListEntry * next
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
char * header_filename
filename to write the output header to
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
char * entry_prefix
prefix to add to list entry filenames
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
static av_cold int init(AVCodecContext *avctx)
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 ...
AVDictionary * format_options
static int segment_start(AVFormatContext *s, int write_header)
int segment_idx_wrap
number after which the index wraps
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
#define AVIO_FLAG_WRITE
write-only
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int segment_frame_count
number of reference frames in the segment
This struct describes the properties of an encoded stream.
static int parse_frames(void *log_ctx, int **frames, int *nb_frames, const char *frames_str)
static int seg_write_header(AVFormatContext *s)
static int segment_end(AVFormatContext *s, int write_trailer, int is_last)
int list_flags
flags affecting list generation
static int segment_mux_init(AVFormatContext *s)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static void close_null_ctxp(AVIOContext **pb)
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
static int seg_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
const char * av_basename(const char *path)
Thread safe basename.
Opaque data information usually continuous.
char temp_list_filename[1024]
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
timestamp utils, mostly useful for debugging/logging purposes
static av_cold int end(AVCodecContext *avctx)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
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.
static int seg_write_trailer(struct AVFormatContext *s)
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
AVStream ** streams
A list of all streams in the file.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int flags
Flags modifying the (de)muxer behaviour.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
int start
timecode frame start (first base frame number)
#define AV_LOG_VERBOSE
Detailed information.
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.
#define AVSTREAM_INIT_IN_WRITE_HEADER
stream parameters initialized in avformat_write_header
char * format
format to use for output segment files
static int select_reference_stream(AVFormatContext *s)
struct AVOutputFormat * oformat
The output container format.
int64_t initial_offset
initial timestamps offset, expressed in microseconds
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
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.
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
int individual_header_trailer
Set by a private option.
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
enum AVMediaType codec_type
General type of the encoded data.
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t * times
list of segment interval specification
static const uint8_t offset[127][2]
AVRational avg_frame_rate
Average framerate.
char * reference_stream_specifier
reference stream specifier
static int set_segment_filename(AVFormatContext *s)
int reference_stream_index
static int seg_init(AVFormatContext *s)
int nb_times
number of elments in the times array
static int segment_list_open(AVFormatContext *s)
int flags
A combination of AV_PKT_FLAG values.
int64_t last_val
remember last time for wrap around detection
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.
Use auto-selected escaping mode.
AVIOContext * list_pb
list file put-byte context
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
AVBSFContext ** bsfcs
bitstream filters to run on stream
static void print_csv_escaped_str(AVIOContext *ctx, const char *str)
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
char filename[1024]
input or output filename
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.
static struct tm * localtime_r(const time_t *clock, struct tm *result)
static int write_trailer(AVFormatContext *s1)
static const AVClass sseg_class
int use_strftime
flag to expand filename with strftime
int reset_timestamps
reset timestamps at the begin of each segment
int use_clocktime
flag to cut segments at regular clock time
int avoid_negative_ts
Avoid negative timestamps during muxing.
int increment_tc
flag to increment timecode if found
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...
Opaque data information usually sparse.
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.
#define FF_ARRAY_ELEMS(a)
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
int64_t av_gettime(void)
Get the current time in microseconds.
char * list
filename for the segment list file
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
char * frames_str
segment frame numbers specification string
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
char * av_strdup(const char *s)
Duplicate a string.
AVStreamInternal * internal
An opaque field for libavformat internal usage.
static void seg_free(AVFormatContext *s)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int header_written
whether we've already called avformat_write_header
AVIOContext * pb
I/O context.
void avio_w8(AVIOContext *s, int b)
int64_t time
segment duration
int list_type
set the list type
AVOutputFormat ff_segment_muxer
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
int segment_idx
index of the segment file to write, starting from 0
static const char * format
Describe the class of an AVClass context structure.
int * frames
list of frame number specification
Rational number (pair of numerator and denominator).
char * time_str
segment duration specification string
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
SegmentListEntry * segment_list_entries
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.
int nb_frames
number of elments in the frames array
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
int write_header_trailer
Set by a private option.
char * format_options_str
format options to use for output segment files
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()...
static void segment_list_print_entry(AVIOContext *list_ioctx, ListType list_type, const SegmentListEntry *list_entry, void *log_ctx)
static const AVClass seg_class
void av_opt_free(void *obj)
Free all allocated objects in obj.
int64_t clocktime_wrap_duration
int disposition
AV_DISPOSITION_* bit field.
#define SEGMENT_LIST_FLAG_CACHE
int pts_wrap_bits
number of bits in pts (used for wrapping control)
static int parse_times(void *log_ctx, int64_t **times, int *nb_times, const char *times_str)
int segment_idx_wrap_nb
number of time the index has wraped
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
void * priv_data
Format private data.
static const AVOption options[]
#define AV_ESCAPE_FLAG_WHITESPACE
Consider spaces special and escape them even in the middle of the string.
static void write_header(FFV1Context *f)
AVOutputFormat ff_stream_segment_muxer
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
static int open_null_ctx(AVIOContext **ctx)
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
int segment_count
number of segment files already written
AVCodecParameters * codecpar
char * times_str
segment times specification string
#define av_malloc_array(a, b)
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
SegmentListEntry cur_entry
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
int list_size
number of entries for the segment list file
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
This structure stores compressed data.
int frame_count
total number of reference frames
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
#define SEGMENT_LIST_FLAG_LIVE
SegmentListEntry * segment_list_entries_end
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_NOPTS_VALUE
Undefined timestamp value.
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
#define AV_TIMECODE_STR_SIZE