2011-10-02 21:05:29 +00:00
/*
* Copyright ( c ) 2011 , Luca Barbato
*
2013-08-15 21:12:51 +00:00
* This file is part of FFmpeg .
2011-10-02 21:05:29 +00:00
*
2013-08-15 21:12:51 +00:00
* FFmpeg is free software ; you can redistribute it and / or
2011-10-02 21:05:29 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
2013-08-15 21:12:51 +00:00
* FFmpeg is distributed in the hope that it will be useful ,
2011-10-02 21:05:29 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
2013-08-15 21:12:51 +00:00
* License along with FFmpeg ; if not , write to the Free Software
2011-10-02 21:05:29 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2012-08-15 20:20:16 +00:00
/**
* @ file generic segmenter
2012-08-15 09:06:34 +00:00
* M3U8 specification can be find here :
2013-01-22 19:17:00 +00:00
* @ url { http : //tools.ietf.org/id/draft-pantos-http-live-streaming}
2012-08-15 20:20:16 +00:00
*/
2012-12-09 19:26:30 +00:00
/* #define DEBUG */
2011-10-02 21:05:29 +00:00
# include <float.h>
# include "avformat.h"
# include "internal.h"
2012-12-10 23:14:22 +00:00
# include "libavutil/avassert.h"
2011-10-02 21:05:29 +00:00
# include "libavutil/log.h"
# include "libavutil/opt.h"
# include "libavutil/avstring.h"
# include "libavutil/parseutils.h"
# include "libavutil/mathematics.h"
2012-11-29 12:45:50 +00:00
# include "libavutil/timestamp.h"
2011-10-02 21:05:29 +00:00
2012-12-10 23:14:22 +00:00
typedef struct SegmentListEntry {
int index ;
double start_time , end_time ;
2013-02-05 23:19:52 +00:00
int64_t start_pts ;
2013-07-05 12:28:38 +00:00
int64_t offset_pts ;
2013-11-22 11:49:05 +00:00
char * filename ;
2012-12-10 23:14:22 +00:00
struct SegmentListEntry * next ;
} SegmentListEntry ;
2012-01-13 22:29:09 +00:00
typedef enum {
2012-08-15 22:16:28 +00:00
LIST_TYPE_UNDEFINED = - 1 ,
2012-01-13 22:29:09 +00:00
LIST_TYPE_FLAT = 0 ,
2012-08-16 16:13:17 +00:00
LIST_TYPE_CSV ,
2012-08-15 09:06:34 +00:00
LIST_TYPE_M3U8 ,
2012-09-14 21:31:47 +00:00
LIST_TYPE_EXT , ///< deprecated
2013-02-21 18:33:26 +00:00
LIST_TYPE_FFCONCAT ,
2012-01-13 22:29:09 +00:00
LIST_TYPE_NB ,
} ListType ;
2012-09-01 16:01:51 +00:00
# define SEGMENT_LIST_FLAG_CACHE 1
# define SEGMENT_LIST_FLAG_LIVE 2
2011-10-02 21:05:29 +00:00
typedef struct {
const AVClass * class ; /**< Class for private options. */
2012-08-15 20:12:11 +00:00
int segment_idx ; ///< index of the segment file to write, starting from 0
int segment_idx_wrap ; ///< number after which the index wraps
2014-02-05 13:59:00 +00:00
int segment_idx_wrap_nb ; ///< number of time the index has wraped
2012-08-15 20:12:11 +00:00
int segment_count ; ///< number of segment files already written
2012-10-03 21:15:35 +00:00
AVOutputFormat * oformat ;
2011-10-02 21:05:29 +00:00
AVFormatContext * avf ;
2012-01-14 10:00:16 +00:00
char * format ; ///< format to use for output segment files
char * list ; ///< filename for the segment list file
2012-09-01 16:01:51 +00:00
int list_flags ; ///< flags affecting list generation
2012-01-14 10:00:16 +00:00
int list_size ; ///< number of entries for the segment list file
2014-04-29 13:42:04 +00:00
char * entry_prefix ; ///< prefix to add to list entry filenames
2012-01-13 22:29:09 +00:00
ListType list_type ; ///< set the list type
2012-01-17 19:04:14 +00:00
AVIOContext * list_pb ; ///< list file put-byte context
2012-07-08 15:26:33 +00:00
char * time_str ; ///< segment duration specification string
int64_t time ; ///< segment duration
2012-12-09 19:26:30 +00:00
2012-01-28 21:36:38 +00:00
char * times_str ; ///< segment times specification string
int64_t * times ; ///< list of segment interval specification
int nb_times ; ///< number of elments in the times array
2012-12-09 19:26:30 +00:00
char * frames_str ; ///< segment frame numbers specification string
int * frames ; ///< list of frame number specification
int nb_frames ; ///< number of elments in the frames array
int frame_count ;
2012-01-28 21:21:43 +00:00
int64_t time_delta ;
2012-10-02 21:49:46 +00:00
int individual_header_trailer ; /**< Set by a private option. */
2012-10-02 21:59:35 +00:00
int write_header_trailer ; /**< Set by a private option. */
2012-11-29 12:45:50 +00:00
int reset_timestamps ; ///< reset timestamps at the begin of each segment
2013-07-05 12:28:38 +00:00
int64_t initial_offset ; ///< initial timestamps offset, expressed in microseconds
2012-12-22 20:49:06 +00:00
char * reference_stream_specifier ; ///< reference stream specifier
int reference_stream_index ;
2012-12-10 23:14:22 +00:00
SegmentListEntry cur_entry ;
2012-12-20 13:20:19 +00:00
SegmentListEntry * segment_list_entries ;
SegmentListEntry * segment_list_entries_end ;
2012-12-13 20:19:25 +00:00
int is_first_pkt ; ///< tells if it is the first packet in the segment
2011-10-02 21:05:29 +00:00
} SegmentContext ;
2012-09-01 14:12:29 +00:00
static void print_csv_escaped_str ( AVIOContext * ctx , const char * str )
{
2012-09-14 16:26:50 +00:00
int needs_quoting = ! ! str [ strcspn ( str , " \" , \n \r " ) ] ;
2012-09-01 14:12:29 +00:00
2012-09-14 16:26:50 +00:00
if ( needs_quoting )
2012-09-01 14:12:29 +00:00
avio_w8 ( ctx , ' " ' ) ;
2012-09-09 19:27:13 +00:00
for ( ; * str ; str + + ) {
if ( * str = = ' " ' )
2012-09-01 14:12:29 +00:00
avio_w8 ( ctx , ' " ' ) ;
2012-09-09 19:27:13 +00:00
avio_w8 ( ctx , * str ) ;
2012-09-01 14:12:29 +00:00
}
2012-09-14 16:26:50 +00:00
if ( needs_quoting )
2012-09-01 14:12:29 +00:00
avio_w8 ( ctx , ' " ' ) ;
}
2012-10-03 21:15:35 +00:00
static int segment_mux_init ( AVFormatContext * s )
2011-10-02 21:05:29 +00:00
{
2012-01-13 22:27:09 +00:00
SegmentContext * seg = s - > priv_data ;
2012-10-03 21:15:35 +00:00
AVFormatContext * oc ;
int i ;
seg - > avf = oc = avformat_alloc_context ( ) ;
if ( ! oc )
return AVERROR ( ENOMEM ) ;
oc - > oformat = seg - > oformat ;
oc - > interrupt_callback = s - > interrupt_callback ;
2013-03-18 18:06:45 +00:00
av_dict_copy ( & oc - > metadata , s - > metadata , 0 ) ;
2012-10-03 21:15:35 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st ;
2012-11-17 16:39:51 +00:00
AVCodecContext * icodec , * ocodec ;
2012-10-03 21:15:35 +00:00
if ( ! ( st = avformat_new_stream ( oc , NULL ) ) )
return AVERROR ( ENOMEM ) ;
2012-11-17 16:39:51 +00:00
icodec = s - > streams [ i ] - > codec ;
ocodec = st - > codec ;
avcodec_copy_context ( ocodec , icodec ) ;
if ( ! oc - > oformat - > codec_tag | |
av_codec_get_id ( oc - > oformat - > codec_tag , icodec - > codec_tag ) = = ocodec - > codec_id | |
av_codec_get_tag ( oc - > oformat - > codec_tag , icodec - > codec_id ) < = 0 ) {
ocodec - > codec_tag = icodec - > codec_tag ;
} else {
ocodec - > codec_tag = 0 ;
}
2012-10-03 21:15:35 +00:00
st - > sample_aspect_ratio = s - > streams [ i ] - > sample_aspect_ratio ;
}
return 0 ;
}
2012-12-13 10:37:50 +00:00
static int set_segment_filename ( AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
AVFormatContext * oc = seg - > avf ;
2013-11-22 11:49:05 +00:00
size_t size ;
2012-12-13 10:37:50 +00:00
if ( seg - > segment_idx_wrap )
seg - > segment_idx % = seg - > segment_idx_wrap ;
if ( av_get_frame_filename ( oc - > filename , sizeof ( oc - > filename ) ,
s - > filename , seg - > segment_idx ) < 0 ) {
av_log ( oc , AV_LOG_ERROR , " Invalid segment filename template '%s' \n " , s - > filename ) ;
return AVERROR ( EINVAL ) ;
}
2013-11-22 11:49:05 +00:00
/* copy modified name in list entry */
size = strlen ( av_basename ( oc - > filename ) ) + 1 ;
2014-04-29 13:42:04 +00:00
if ( seg - > entry_prefix )
size + = strlen ( seg - > entry_prefix ) ;
2013-11-22 11:49:05 +00:00
seg - > cur_entry . filename = av_mallocz ( size ) ;
if ( ! seg - > cur_entry . filename )
return AVERROR ( ENOMEM ) ;
snprintf ( seg - > cur_entry . filename , size , " %s%s " ,
2014-04-29 13:42:04 +00:00
seg - > entry_prefix ? seg - > entry_prefix : " " ,
2013-11-22 11:49:05 +00:00
av_basename ( oc - > filename ) ) ;
2012-12-13 10:37:50 +00:00
return 0 ;
}
2012-10-02 21:49:46 +00:00
static int segment_start ( AVFormatContext * s , int write_header )
2011-10-02 21:05:29 +00:00
{
2012-11-17 15:35:51 +00:00
SegmentContext * seg = s - > priv_data ;
AVFormatContext * oc = seg - > avf ;
2011-10-02 21:05:29 +00:00
int err = 0 ;
2012-10-02 21:49:46 +00:00
if ( write_header ) {
avformat_free_context ( oc ) ;
2012-11-17 15:35:51 +00:00
seg - > avf = NULL ;
2012-10-02 21:49:46 +00:00
if ( ( err = segment_mux_init ( s ) ) < 0 )
return err ;
2012-11-17 15:35:51 +00:00
oc = seg - > avf ;
2012-10-02 21:49:46 +00:00
}
2012-10-03 21:15:35 +00:00
2012-11-17 16:20:29 +00:00
seg - > segment_idx + + ;
2014-02-05 13:59:00 +00:00
if ( ( seg - > segment_idx_wrap ) & & ( seg - > segment_idx % seg - > segment_idx_wrap = = 0 ) )
seg - > segment_idx_wrap_nb + + ;
2012-12-13 10:37:50 +00:00
if ( ( err = set_segment_filename ( s ) ) < 0 )
return err ;
2011-10-02 21:05:29 +00:00
if ( ( err = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
2013-11-25 18:20:11 +00:00
& s - > interrupt_callback , NULL ) ) < 0 ) {
av_log ( s , AV_LOG_ERROR , " Failed to open segment '%s' \n " , oc - > filename ) ;
2011-10-02 21:05:29 +00:00
return err ;
2013-11-25 18:20:11 +00:00
}
2011-10-02 21:05:29 +00:00
2012-10-02 21:51:46 +00:00
if ( oc - > oformat - > priv_class & & oc - > priv_data )
2012-10-04 12:28:30 +00:00
av_opt_set ( oc - > priv_data , " resend_headers " , " 1 " , 0 ) ; /* mpegts specific */
2012-10-02 21:51:46 +00:00
2012-10-02 21:49:46 +00:00
if ( write_header ) {
if ( ( err = avformat_write_header ( oc , NULL ) ) < 0 )
return err ;
}
2011-10-02 21:05:29 +00:00
2012-12-13 20:19:25 +00:00
seg - > is_first_pkt = 1 ;
2011-10-02 21:05:29 +00:00
return 0 ;
}
2012-08-15 21:21:41 +00:00
static int segment_list_open ( AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
2012-08-15 21:14:34 +00:00
int ret ;
ret = avio_open2 ( & seg - > list_pb , seg - > list , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , NULL ) ;
2013-11-25 18:20:11 +00:00
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Failed to open segment list '%s' \n " , seg - > list ) ;
2012-08-15 21:14:34 +00:00
return ret ;
2013-11-25 18:20:11 +00:00
}
2012-08-15 09:06:34 +00:00
2012-12-20 13:20:19 +00:00
if ( seg - > list_type = = LIST_TYPE_M3U8 & & seg - > segment_list_entries ) {
SegmentListEntry * entry ;
double max_duration = 0 ;
2012-08-15 09:06:34 +00:00
avio_printf ( seg - > list_pb , " #EXTM3U \n " ) ;
2012-09-01 15:13:26 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-VERSION:3 \n " ) ;
2012-12-20 13:20:19 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-MEDIA-SEQUENCE:%d \n " , seg - > segment_list_entries - > index ) ;
2013-02-03 10:12:49 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-ALLOW-CACHE:%s \n " ,
seg - > list_flags & SEGMENT_LIST_FLAG_CACHE ? " YES " : " NO " ) ;
2012-12-20 13:20:19 +00:00
2014-04-30 18:12:17 +00:00
av_log ( s , AV_LOG_VERBOSE , " EXT-X-MEDIA-SEQUENCE:%d \n " ,
seg - > segment_list_entries - > index ) ;
2012-12-20 13:20:19 +00:00
for ( entry = seg - > segment_list_entries ; entry ; entry = entry - > next )
max_duration = FFMAX ( max_duration , entry - > end_time - entry - > start_time ) ;
avio_printf ( seg - > list_pb , " #EXT-X-TARGETDURATION:% " PRId64 " \n " , ( int64_t ) ceil ( max_duration ) ) ;
2013-02-21 18:33:26 +00:00
} else if ( seg - > list_type = = LIST_TYPE_FFCONCAT ) {
avio_printf ( seg - > list_pb , " ffconcat version 1.0 \n " ) ;
2012-08-15 09:06:34 +00:00
}
2012-08-15 21:14:34 +00:00
return ret ;
2012-08-15 21:21:41 +00:00
}
2012-12-10 23:14:22 +00:00
static void segment_list_print_entry ( AVIOContext * list_ioctx ,
ListType list_type ,
2013-02-21 18:33:26 +00:00
const SegmentListEntry * list_entry ,
void * log_ctx )
2012-12-10 23:14:22 +00:00
{
switch ( list_type ) {
case LIST_TYPE_FLAT :
avio_printf ( list_ioctx , " %s \n " , list_entry - > filename ) ;
break ;
case LIST_TYPE_CSV :
case LIST_TYPE_EXT :
print_csv_escaped_str ( list_ioctx , list_entry - > filename ) ;
avio_printf ( list_ioctx , " ,%f,%f \n " , list_entry - > start_time , list_entry - > end_time ) ;
break ;
case LIST_TYPE_M3U8 :
avio_printf ( list_ioctx , " #EXTINF:%f, \n %s \n " ,
list_entry - > end_time - list_entry - > start_time , list_entry - > filename ) ;
break ;
2013-02-21 18:33:26 +00:00
case LIST_TYPE_FFCONCAT :
{
char * buf ;
if ( av_escape ( & buf , list_entry - > filename , NULL , AV_ESCAPE_MODE_AUTO , AV_ESCAPE_FLAG_WHITESPACE ) < 0 ) {
av_log ( log_ctx , AV_LOG_WARNING ,
" Error writing list entry '%s' in list file \n " , list_entry - > filename ) ;
return ;
}
avio_printf ( list_ioctx , " file %s \n " , buf ) ;
av_free ( buf ) ;
break ;
}
2012-12-10 23:14:22 +00:00
default :
av_assert0 ( ! " Invalid list type " ) ;
}
}
2013-01-22 23:23:47 +00:00
static int segment_end ( AVFormatContext * s , int write_trailer , int is_last )
2011-10-02 21:05:29 +00:00
{
2012-01-13 22:24:13 +00:00
SegmentContext * seg = s - > priv_data ;
AVFormatContext * oc = seg - > avf ;
2011-10-02 21:05:29 +00:00
int ret = 0 ;
2012-10-04 12:28:30 +00:00
av_write_frame ( oc , NULL ) ; /* Flush any buffered data (fragmented mp4) */
2012-10-02 21:49:46 +00:00
if ( write_trailer )
2012-10-05 14:14:06 +00:00
ret = av_write_trailer ( oc ) ;
2011-10-02 21:05:29 +00:00
2012-01-12 22:24:27 +00:00
if ( ret < 0 )
2012-01-13 22:24:13 +00:00
av_log ( s , AV_LOG_ERROR , " Failure occurred when ending segment '%s' \n " ,
2012-01-12 22:24:27 +00:00
oc - > filename ) ;
2012-01-13 23:16:55 +00:00
if ( seg - > list ) {
2012-12-20 13:20:19 +00:00
if ( seg - > list_size | | seg - > list_type = = LIST_TYPE_M3U8 ) {
SegmentListEntry * entry = av_mallocz ( sizeof ( * entry ) ) ;
if ( ! entry ) {
ret = AVERROR ( ENOMEM ) ;
goto end ;
}
/* append new element */
memcpy ( entry , & seg - > cur_entry , sizeof ( * entry ) ) ;
if ( ! seg - > segment_list_entries )
seg - > segment_list_entries = seg - > segment_list_entries_end = entry ;
else
seg - > segment_list_entries_end - > next = entry ;
seg - > segment_list_entries_end = entry ;
/* drop first item */
if ( seg - > list_size & & seg - > segment_count > seg - > list_size ) {
entry = seg - > segment_list_entries ;
seg - > segment_list_entries = seg - > segment_list_entries - > next ;
2013-11-22 11:49:05 +00:00
av_free ( entry - > filename ) ;
2012-12-20 13:20:19 +00:00
av_freep ( & entry ) ;
}
2013-01-23 17:19:42 +00:00
avio_close ( seg - > list_pb ) ;
2012-08-15 21:21:41 +00:00
if ( ( ret = segment_list_open ( s ) ) < 0 )
2012-01-13 23:16:55 +00:00
goto end ;
2012-12-20 13:20:19 +00:00
for ( entry = seg - > segment_list_entries ; entry ; entry = entry - > next )
2013-02-21 18:33:26 +00:00
segment_list_print_entry ( seg - > list_pb , seg - > list_type , entry , s ) ;
2013-01-22 23:23:47 +00:00
if ( seg - > list_type = = LIST_TYPE_M3U8 & & is_last )
2012-12-20 13:20:19 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-ENDLIST \n " ) ;
} else {
2013-02-21 18:33:26 +00:00
segment_list_print_entry ( seg - > list_pb , seg - > list_type , & seg - > cur_entry , s ) ;
2012-01-13 23:16:55 +00:00
}
2012-01-17 19:04:14 +00:00
avio_flush ( seg - > list_pb ) ;
2012-01-13 23:16:55 +00:00
}
2013-10-15 10:53:40 +00:00
av_log ( s , AV_LOG_VERBOSE , " segment:'%s' count:%d ended \n " ,
seg - > avf - > filename , seg - > segment_count ) ;
seg - > segment_count + + ;
2012-01-13 23:16:55 +00:00
end :
2011-10-02 21:05:29 +00:00
avio_close ( oc - > pb ) ;
return ret ;
}
2012-01-28 21:36:38 +00:00
static int parse_times ( void * log_ctx , int64_t * * times , int * nb_times ,
const char * times_str )
{
char * p ;
int i , ret = 0 ;
char * times_str1 = av_strdup ( times_str ) ;
char * saveptr = NULL ;
if ( ! times_str1 )
return AVERROR ( ENOMEM ) ;
# define FAIL(err) ret = err; goto end
* nb_times = 1 ;
for ( p = times_str1 ; * p ; p + + )
if ( * p = = ' , ' )
( * nb_times ) + + ;
2014-05-05 21:11:04 +00:00
* times = av_malloc_array ( * nb_times , sizeof ( * * times ) ) ;
2012-01-28 21:36:38 +00:00
if ( ! * times ) {
av_log ( log_ctx , AV_LOG_ERROR , " Could not allocate forced times array \n " ) ;
FAIL ( AVERROR ( ENOMEM ) ) ;
}
p = times_str1 ;
for ( i = 0 ; i < * nb_times ; i + + ) {
int64_t t ;
char * tstr = av_strtok ( p , " , " , & saveptr ) ;
p = NULL ;
2012-12-09 19:39:27 +00:00
if ( ! tstr | | ! tstr [ 0 ] ) {
av_log ( log_ctx , AV_LOG_ERROR , " Empty time specification in times list %s \n " ,
times_str ) ;
FAIL ( AVERROR ( EINVAL ) ) ;
}
2012-01-28 21:36:38 +00:00
ret = av_parse_time ( & t , tstr , 1 ) ;
if ( ret < 0 ) {
av_log ( log_ctx , AV_LOG_ERROR ,
2012-12-09 19:39:27 +00:00
" Invalid time duration specification '%s' in times list %s \n " , tstr , times_str ) ;
2012-01-28 21:36:38 +00:00
FAIL ( AVERROR ( EINVAL ) ) ;
}
( * times ) [ i ] = t ;
/* check on monotonicity */
if ( i & & ( * times ) [ i - 1 ] > ( * times ) [ i ] ) {
av_log ( log_ctx , AV_LOG_ERROR ,
" Specified time %f is greater than the following time %f \n " ,
( float ) ( ( * times ) [ i ] ) / 1000000 , ( float ) ( ( * times ) [ i - 1 ] ) / 1000000 ) ;
FAIL ( AVERROR ( EINVAL ) ) ;
}
}
end :
av_free ( times_str1 ) ;
return ret ;
}
2012-12-09 19:26:30 +00:00
static int parse_frames ( void * log_ctx , int * * frames , int * nb_frames ,
const char * frames_str )
{
char * p ;
int i , ret = 0 ;
char * frames_str1 = av_strdup ( frames_str ) ;
char * saveptr = NULL ;
if ( ! frames_str1 )
return AVERROR ( ENOMEM ) ;
# define FAIL(err) ret = err; goto end
* nb_frames = 1 ;
for ( p = frames_str1 ; * p ; p + + )
if ( * p = = ' , ' )
( * nb_frames ) + + ;
2014-05-05 21:11:04 +00:00
* frames = av_malloc_array ( * nb_frames , sizeof ( * * frames ) ) ;
2012-12-09 19:26:30 +00:00
if ( ! * frames ) {
av_log ( log_ctx , AV_LOG_ERROR , " Could not allocate forced frames array \n " ) ;
FAIL ( AVERROR ( ENOMEM ) ) ;
}
p = frames_str1 ;
for ( i = 0 ; i < * nb_frames ; i + + ) {
long int f ;
char * tailptr ;
char * fstr = av_strtok ( p , " , " , & saveptr ) ;
p = NULL ;
if ( ! fstr ) {
av_log ( log_ctx , AV_LOG_ERROR , " Empty frame specification in frame list %s \n " ,
frames_str ) ;
FAIL ( AVERROR ( EINVAL ) ) ;
}
f = strtol ( fstr , & tailptr , 10 ) ;
if ( * tailptr | | f < = 0 | | f > = INT_MAX ) {
av_log ( log_ctx , AV_LOG_ERROR ,
" Invalid argument '%s', must be a positive integer <= INT64_MAX \n " ,
fstr ) ;
FAIL ( AVERROR ( EINVAL ) ) ;
}
( * frames ) [ i ] = f ;
/* check on monotonicity */
if ( i & & ( * frames ) [ i - 1 ] > ( * frames ) [ i ] ) {
av_log ( log_ctx , AV_LOG_ERROR ,
" Specified frame %d is greater than the following frame %d \n " ,
( * frames ) [ i ] , ( * frames ) [ i - 1 ] ) ;
FAIL ( AVERROR ( EINVAL ) ) ;
}
}
end :
av_free ( frames_str1 ) ;
return ret ;
}
2012-10-02 21:59:35 +00:00
static int open_null_ctx ( AVIOContext * * ctx )
{
int buf_size = 32768 ;
uint8_t * buf = av_malloc ( buf_size ) ;
if ( ! buf )
return AVERROR ( ENOMEM ) ;
* ctx = avio_alloc_context ( buf , buf_size , AVIO_FLAG_WRITE , NULL , NULL , NULL , NULL ) ;
if ( ! * ctx ) {
av_free ( buf ) ;
return AVERROR ( ENOMEM ) ;
}
return 0 ;
}
static void close_null_ctx ( AVIOContext * pb )
{
av_free ( pb - > buffer ) ;
av_free ( pb ) ;
}
2013-01-16 18:52:58 +00:00
static int select_reference_stream ( AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
int ret , i ;
seg - > reference_stream_index = - 1 ;
if ( ! strcmp ( seg - > reference_stream_specifier , " auto " ) ) {
/* select first index of type with highest priority */
int type_index_map [ AVMEDIA_TYPE_NB ] ;
static const enum AVMediaType type_priority_list [ ] = {
AVMEDIA_TYPE_VIDEO ,
AVMEDIA_TYPE_AUDIO ,
AVMEDIA_TYPE_SUBTITLE ,
AVMEDIA_TYPE_DATA ,
AVMEDIA_TYPE_ATTACHMENT
} ;
enum AVMediaType type ;
for ( i = 0 ; i < AVMEDIA_TYPE_NB ; i + + )
type_index_map [ i ] = - 1 ;
/* select first index for each type */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
type = s - > streams [ i ] - > codec - > codec_type ;
2013-01-16 19:10:12 +00:00
if ( ( unsigned ) type < AVMEDIA_TYPE_NB & & type_index_map [ type ] = = - 1
/* ignore attached pictures/cover art streams */
& & ! ( s - > streams [ i ] - > disposition & AV_DISPOSITION_ATTACHED_PIC ) )
2013-01-16 18:52:58 +00:00
type_index_map [ type ] = i ;
}
for ( i = 0 ; i < FF_ARRAY_ELEMS ( type_priority_list ) ; i + + ) {
type = type_priority_list [ i ] ;
if ( ( seg - > reference_stream_index = type_index_map [ type ] ) > = 0 )
break ;
}
} else {
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
ret = avformat_match_stream_specifier ( s , s - > streams [ i ] ,
seg - > reference_stream_specifier ) ;
if ( ret < 0 )
2013-01-23 17:50:21 +00:00
return ret ;
2013-01-16 18:52:58 +00:00
if ( ret > 0 ) {
seg - > reference_stream_index = i ;
break ;
}
}
}
if ( seg - > reference_stream_index < 0 ) {
av_log ( s , AV_LOG_ERROR , " Could not select stream matching identifier '%s' \n " ,
seg - > reference_stream_specifier ) ;
return AVERROR ( EINVAL ) ;
}
return 0 ;
}
2011-10-02 21:05:29 +00:00
static int seg_write_header ( AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
2012-10-03 21:15:35 +00:00
AVFormatContext * oc = NULL ;
2013-01-16 18:52:58 +00:00
int ret ;
2011-10-02 21:05:29 +00:00
2012-08-15 20:12:11 +00:00
seg - > segment_count = 0 ;
2012-10-02 21:59:35 +00:00
if ( ! seg - > write_header_trailer )
seg - > individual_header_trailer = 0 ;
2012-07-08 15:26:33 +00:00
2012-12-09 19:26:30 +00:00
if ( ! ! seg - > time_str + ! ! seg - > times_str + ! ! seg - > frames_str > 1 ) {
2012-07-08 15:26:33 +00:00
av_log ( s , AV_LOG_ERROR ,
2012-12-09 19:26:30 +00:00
" segment_time, segment_times, and segment_frames options "
" are mutually exclusive, select just one of them \n " ) ;
2012-01-28 21:36:38 +00:00
return AVERROR ( EINVAL ) ;
}
if ( seg - > times_str ) {
if ( ( ret = parse_times ( s , & seg - > times , & seg - > nb_times , seg - > times_str ) ) < 0 )
return ret ;
2012-12-09 19:26:30 +00:00
} else if ( seg - > frames_str ) {
if ( ( ret = parse_frames ( s , & seg - > frames , & seg - > nb_frames , seg - > frames_str ) ) < 0 )
return ret ;
2012-01-28 21:36:38 +00:00
} else {
/* set default value if not specified */
if ( ! seg - > time_str )
seg - > time_str = av_strdup ( " 2 " ) ;
if ( ( ret = av_parse_time ( & seg - > time , seg - > time_str , 1 ) ) < 0 ) {
av_log ( s , AV_LOG_ERROR ,
" Invalid time duration specification '%s' for segment_time option \n " ,
seg - > time_str ) ;
return ret ;
}
2012-07-08 15:26:33 +00:00
}
2011-10-02 21:05:29 +00:00
2012-08-15 22:16:28 +00:00
if ( seg - > list ) {
if ( seg - > list_type = = LIST_TYPE_UNDEFINED ) {
2012-08-16 16:13:17 +00:00
if ( av_match_ext ( seg - > list , " csv " ) ) seg - > list_type = LIST_TYPE_CSV ;
else if ( av_match_ext ( seg - > list , " ext " ) ) seg - > list_type = LIST_TYPE_EXT ;
2012-08-15 22:16:28 +00:00
else if ( av_match_ext ( seg - > list , " m3u8 " ) ) seg - > list_type = LIST_TYPE_M3U8 ;
2013-02-21 18:33:26 +00:00
else if ( av_match_ext ( seg - > list , " ffcat,ffconcat " ) ) seg - > list_type = LIST_TYPE_FFCONCAT ;
2012-08-15 22:16:28 +00:00
else seg - > list_type = LIST_TYPE_FLAT ;
}
2012-08-15 21:21:41 +00:00
if ( ( ret = segment_list_open ( s ) ) < 0 )
2012-04-27 18:09:30 +00:00
goto fail ;
2012-08-15 22:16:28 +00:00
}
2012-08-16 16:13:17 +00:00
if ( seg - > list_type = = LIST_TYPE_EXT )
av_log ( s , AV_LOG_WARNING , " 'ext' list type option is deprecated in favor of 'csv' \n " ) ;
2011-10-02 21:05:29 +00:00
2013-01-16 18:52:58 +00:00
if ( ( ret = select_reference_stream ( s ) ) < 0 )
2012-12-22 20:49:06 +00:00
goto fail ;
av_log ( s , AV_LOG_VERBOSE , " Selected stream id:%d type:%s \n " ,
seg - > reference_stream_index ,
av_get_media_type_string ( s - > streams [ seg - > reference_stream_index ] - > codec - > codec_type ) ) ;
2011-10-02 21:05:29 +00:00
2012-10-03 21:15:35 +00:00
seg - > oformat = av_guess_format ( seg - > format , s - > filename , NULL ) ;
2011-10-02 21:05:29 +00:00
2012-10-03 21:15:35 +00:00
if ( ! seg - > oformat ) {
2011-10-02 21:05:29 +00:00
ret = AVERROR_MUXER_NOT_FOUND ;
goto fail ;
}
2012-10-03 21:15:35 +00:00
if ( seg - > oformat - > flags & AVFMT_NOFILE ) {
2011-10-02 21:05:29 +00:00
av_log ( s , AV_LOG_ERROR , " format %s not supported. \n " ,
2012-11-05 19:25:25 +00:00
seg - > oformat - > name ) ;
2011-10-02 21:05:29 +00:00
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2012-10-03 21:15:35 +00:00
if ( ( ret = segment_mux_init ( s ) ) < 0 )
goto fail ;
oc = seg - > avf ;
2011-10-02 21:05:29 +00:00
2012-12-13 10:37:50 +00:00
if ( ( ret = set_segment_filename ( s ) ) < 0 )
2011-10-02 21:05:29 +00:00
goto fail ;
2012-10-02 21:59:35 +00:00
if ( seg - > write_header_trailer ) {
if ( ( ret = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
2013-11-25 18:20:11 +00:00
& s - > interrupt_callback , NULL ) ) < 0 ) {
av_log ( s , AV_LOG_ERROR , " Failed to open segment '%s' \n " , oc - > filename ) ;
2012-10-02 21:59:35 +00:00
goto fail ;
2013-11-25 18:20:11 +00:00
}
2012-10-02 21:59:35 +00:00
} else {
if ( ( ret = open_null_ctx ( & oc - > pb ) ) < 0 )
goto fail ;
}
2011-10-02 21:05:29 +00:00
if ( ( ret = avformat_write_header ( oc , NULL ) ) < 0 ) {
avio_close ( oc - > pb ) ;
goto fail ;
}
2012-12-13 20:19:25 +00:00
seg - > is_first_pkt = 1 ;
2011-10-02 21:05:29 +00:00
2012-10-06 10:07:26 +00:00
if ( oc - > avoid_negative_ts > 0 & & s - > avoid_negative_ts < 0 )
s - > avoid_negative_ts = 1 ;
2012-10-02 21:59:35 +00:00
if ( ! seg - > write_header_trailer ) {
close_null_ctx ( oc - > pb ) ;
if ( ( ret = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , NULL ) ) < 0 )
goto fail ;
}
2011-10-02 21:05:29 +00:00
fail :
if ( ret ) {
if ( seg - > list )
2013-01-23 17:19:42 +00:00
avio_close ( seg - > list_pb ) ;
2012-10-03 21:15:35 +00:00
if ( seg - > avf )
avformat_free_context ( seg - > avf ) ;
2011-10-02 21:05:29 +00:00
}
return ret ;
}
static int seg_write_packet ( AVFormatContext * s , AVPacket * pkt )
{
SegmentContext * seg = s - > priv_data ;
2012-02-25 23:39:32 +00:00
AVStream * st = s - > streams [ pkt - > stream_index ] ;
2013-07-05 12:28:38 +00:00
int64_t end_pts = INT64_MAX , offset ;
2012-12-09 19:26:30 +00:00
int start_frame = INT_MAX ;
2011-10-02 21:05:29 +00:00
int ret ;
2012-01-28 21:36:38 +00:00
if ( seg - > times ) {
2013-10-15 12:54:25 +00:00
end_pts = seg - > segment_count < seg - > nb_times ?
seg - > times [ seg - > segment_count ] : INT64_MAX ;
2012-12-09 19:26:30 +00:00
} else if ( seg - > frames ) {
start_frame = seg - > segment_count < = seg - > nb_frames ?
2013-10-15 12:54:25 +00:00
seg - > frames [ seg - > segment_count ] : INT_MAX ;
2012-01-28 21:36:38 +00:00
} else {
2013-10-15 12:54:25 +00:00
end_pts = seg - > time * ( seg - > segment_count + 1 ) ;
2012-01-28 21:36:38 +00:00
}
2012-12-09 19:26:30 +00:00
av_dlog ( s , " packet stream:%d pts:%s pts_time:%s is_key:%d frame:%d \n " ,
pkt - > stream_index , av_ts2str ( pkt - > pts ) , av_ts2timestr ( pkt - > pts , & st - > time_base ) ,
pkt - > flags & AV_PKT_FLAG_KEY ,
pkt - > stream_index = = seg - > reference_stream_index ? seg - > frame_count : - 1 ) ;
2012-12-22 20:49:06 +00:00
if ( pkt - > stream_index = = seg - > reference_stream_index & &
2012-12-09 19:26:30 +00:00
pkt - > flags & AV_PKT_FLAG_KEY & &
( seg - > frame_count > = start_frame | |
( pkt - > pts ! = AV_NOPTS_VALUE & &
av_compare_ts ( pkt - > pts , st - > time_base ,
end_pts - seg - > time_delta , AV_TIME_BASE_Q ) > = 0 ) ) ) {
2013-10-15 13:17:22 +00:00
if ( ( ret = segment_end ( s , seg - > individual_header_trailer , 0 ) ) < 0 )
goto fail ;
2011-10-02 21:05:29 +00:00
2013-10-15 13:17:22 +00:00
if ( ( ret = segment_start ( s , seg - > individual_header_trailer ) ) < 0 )
2011-10-02 21:05:29 +00:00
goto fail ;
2014-02-05 13:59:00 +00:00
seg - > cur_entry . index = seg - > segment_idx + seg - > segment_idx_wrap * seg - > segment_idx_wrap_nb ;
2012-12-10 23:14:22 +00:00
seg - > cur_entry . start_time = ( double ) pkt - > pts * av_q2d ( st - > time_base ) ;
seg - > cur_entry . start_pts = av_rescale_q ( pkt - > pts , st - > time_base , AV_TIME_BASE_Q ) ;
2012-01-13 22:29:09 +00:00
} else if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
2012-12-10 23:14:22 +00:00
seg - > cur_entry . end_time =
FFMAX ( seg - > cur_entry . end_time , ( double ) ( pkt - > pts + pkt - > duration ) * av_q2d ( st - > time_base ) ) ;
2011-10-02 21:05:29 +00:00
}
2012-12-13 20:19:25 +00:00
if ( seg - > is_first_pkt ) {
2013-12-17 09:43:32 +00:00
av_log ( s , AV_LOG_VERBOSE , " segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d \n " ,
2012-12-13 20:19:25 +00:00
seg - > avf - > filename , pkt - > stream_index ,
2012-12-09 19:26:30 +00:00
av_ts2str ( pkt - > pts ) , av_ts2timestr ( pkt - > pts , & st - > time_base ) , seg - > frame_count ) ;
2012-12-13 20:19:25 +00:00
seg - > is_first_pkt = 0 ;
}
2013-07-05 12:31:29 +00:00
av_log ( s , AV_LOG_DEBUG , " stream:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s " ,
pkt - > stream_index ,
av_ts2timestr ( seg - > cur_entry . start_pts , & AV_TIME_BASE_Q ) ,
av_ts2str ( pkt - > pts ) , av_ts2timestr ( pkt - > pts , & st - > time_base ) ,
av_ts2str ( pkt - > dts ) , av_ts2timestr ( pkt - > dts , & st - > time_base ) ) ;
/* compute new timestamps */
offset = av_rescale_q ( seg - > initial_offset - ( seg - > reset_timestamps ? seg - > cur_entry . start_pts : 0 ) ,
AV_TIME_BASE_Q , st - > time_base ) ;
if ( pkt - > pts ! = AV_NOPTS_VALUE )
pkt - > pts + = offset ;
if ( pkt - > dts ! = AV_NOPTS_VALUE )
pkt - > dts + = offset ;
av_log ( s , AV_LOG_DEBUG , " -> pts:%s pts_time:%s dts:%s dts_time:%s \n " ,
av_ts2str ( pkt - > pts ) , av_ts2timestr ( pkt - > pts , & st - > time_base ) ,
av_ts2str ( pkt - > dts ) , av_ts2timestr ( pkt - > dts , & st - > time_base ) ) ;
2012-11-29 12:45:50 +00:00
2014-01-21 19:06:49 +00:00
ret = ff_write_chained ( seg - > avf , pkt - > stream_index , pkt , s ) ;
2011-10-02 21:05:29 +00:00
fail :
2012-12-09 19:26:30 +00:00
if ( pkt - > stream_index = = seg - > reference_stream_index )
seg - > frame_count + + ;
2011-10-02 21:05:29 +00:00
return ret ;
}
static int seg_write_trailer ( struct AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
AVFormatContext * oc = seg - > avf ;
2012-12-20 13:20:19 +00:00
SegmentListEntry * cur , * next ;
2012-10-02 21:59:35 +00:00
int ret ;
if ( ! seg - > write_header_trailer ) {
2013-01-22 23:23:47 +00:00
if ( ( ret = segment_end ( s , 0 , 1 ) ) < 0 )
2012-10-09 00:49:42 +00:00
goto fail ;
2012-10-02 21:59:35 +00:00
open_null_ctx ( & oc - > pb ) ;
2012-10-09 00:49:42 +00:00
ret = av_write_trailer ( oc ) ;
2012-10-02 21:59:35 +00:00
close_null_ctx ( oc - > pb ) ;
} else {
2013-01-22 23:23:47 +00:00
ret = segment_end ( s , 1 , 1 ) ;
2012-10-02 21:59:35 +00:00
}
2012-10-11 12:28:18 +00:00
fail :
2011-10-02 21:05:29 +00:00
if ( seg - > list )
2013-01-23 17:19:42 +00:00
avio_close ( seg - > list_pb ) ;
2012-07-08 15:26:33 +00:00
av_opt_free ( seg ) ;
2012-01-28 21:36:38 +00:00
av_freep ( & seg - > times ) ;
2012-12-09 19:26:30 +00:00
av_freep ( & seg - > frames ) ;
2012-07-08 15:26:33 +00:00
2012-12-20 13:20:19 +00:00
cur = seg - > segment_list_entries ;
while ( cur ) {
next = cur - > next ;
2013-11-22 11:49:05 +00:00
av_free ( cur - > filename ) ;
2012-12-20 13:20:19 +00:00
av_free ( cur ) ;
cur = next ;
}
2011-10-02 21:05:29 +00:00
avformat_free_context ( oc ) ;
return ret ;
}
# define OFFSET(x) offsetof(SegmentContext, x)
# define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options [ ] = {
2012-12-22 20:49:06 +00:00
{ " reference_stream " , " set reference stream " , OFFSET ( reference_stream_specifier ) , AV_OPT_TYPE_STRING , { . str = " auto " } , CHAR_MIN , CHAR_MAX , E } ,
2012-01-14 10:00:16 +00:00
{ " segment_format " , " set container format used for the segments " , OFFSET ( format ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
{ " segment_list " , " set the segment list filename " , OFFSET ( list ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2012-09-01 16:01:51 +00:00
{ " 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 , " list_flags " } ,
{ " cache " , " allow list caching " , 0 , AV_OPT_TYPE_CONST , { . i64 = SEGMENT_LIST_FLAG_CACHE } , INT_MIN , INT_MAX , E , " list_flags " } ,
{ " live " , " enable live-friendly list generation (useful for HLS) " , 0 , AV_OPT_TYPE_CONST , { . i64 = SEGMENT_LIST_FLAG_LIVE } , INT_MIN , INT_MAX , E , " list_flags " } ,
2012-09-05 12:26:01 +00:00
{ " segment_list_size " , " set the maximum number of playlist entries " , OFFSET ( list_size ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , E } ,
2012-12-14 10:44:31 +00:00
2012-09-05 12:26:01 +00:00
{ " 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 , " list_type " } ,
2012-12-14 10:44:31 +00:00
{ " flat " , " flat format " , 0 , AV_OPT_TYPE_CONST , { . i64 = LIST_TYPE_FLAT } , INT_MIN , INT_MAX , E , " list_type " } ,
{ " csv " , " csv format " , 0 , AV_OPT_TYPE_CONST , { . i64 = LIST_TYPE_CSV } , INT_MIN , INT_MAX , E , " list_type " } ,
{ " ext " , " extended format " , 0 , AV_OPT_TYPE_CONST , { . i64 = LIST_TYPE_EXT } , INT_MIN , INT_MAX , E , " list_type " } ,
2013-02-21 18:33:26 +00:00
{ " ffconcat " , " ffconcat format " , 0 , AV_OPT_TYPE_CONST , { . i64 = LIST_TYPE_FFCONCAT } , INT_MIN , INT_MAX , E , " list_type " } ,
2012-12-14 10:44:31 +00:00
{ " m3u8 " , " M3U8 format " , 0 , AV_OPT_TYPE_CONST , { . i64 = LIST_TYPE_M3U8 } , INT_MIN , INT_MAX , E , " list_type " } ,
{ " hls " , " Apple HTTP Live Streaming compatible " , 0 , AV_OPT_TYPE_CONST , { . i64 = LIST_TYPE_M3U8 } , INT_MIN , INT_MAX , E , " list_type " } ,
2012-01-28 21:36:38 +00:00
{ " segment_time " , " set segment duration " , OFFSET ( time_str ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2013-07-05 12:33:33 +00:00
{ " segment_time_delta " , " set approximation value used for the segment times " , OFFSET ( time_delta ) , AV_OPT_TYPE_DURATION , { . i64 = 0 } , 0 , 0 , E } ,
2012-01-28 21:36:38 +00:00
{ " segment_times " , " set segment split time points " , OFFSET ( times_str ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2012-12-09 19:26:30 +00:00
{ " segment_frames " , " set segment split frame numbers " , OFFSET ( frames_str ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2012-09-05 12:26:01 +00:00
{ " segment_wrap " , " set number after which the index wraps " , OFFSET ( segment_idx_wrap ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , E } ,
2014-04-29 13:42:04 +00:00
{ " segment_list_entry_prefix " , " set base url prefix for segments " , OFFSET ( entry_prefix ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2012-12-09 17:21:00 +00:00
{ " segment_start_number " , " set the sequence number of the first segment " , OFFSET ( segment_idx ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , E } ,
2014-02-05 13:59:00 +00:00
{ " 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 } ,
2012-11-29 12:45:50 +00:00
2012-10-02 21:49:46 +00:00
{ " individual_header_trailer " , " write header/trailer to each segment " , OFFSET ( individual_header_trailer ) , AV_OPT_TYPE_INT , { . i64 = 1 } , 0 , 1 , E } ,
2012-10-02 21:59:35 +00:00
{ " write_header_trailer " , " write a header to the first segment and a trailer to the last one " , OFFSET ( write_header_trailer ) , AV_OPT_TYPE_INT , { . i64 = 1 } , 0 , 1 , E } ,
2012-11-29 12:45:50 +00:00
{ " reset_timestamps " , " reset timestamps at the begin of each segment " , OFFSET ( reset_timestamps ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , 1 , E } ,
2013-07-05 12:28:38 +00:00
{ " initial_offset " , " set initial timestamp offset " , OFFSET ( initial_offset ) , AV_OPT_TYPE_DURATION , { . i64 = 0 } , - INT64_MAX , INT64_MAX , E } ,
2011-10-02 21:05:29 +00:00
{ NULL } ,
} ;
static const AVClass seg_class = {
. class_name = " segment muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
AVOutputFormat ff_segment_muxer = {
. name = " segment " ,
2012-07-24 01:23:48 +00:00
. long_name = NULL_IF_CONFIG_SMALL ( " segment " ) ,
2011-10-02 21:05:29 +00:00
. priv_data_size = sizeof ( SegmentContext ) ,
2012-11-17 16:12:43 +00:00
. flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER ,
2011-10-02 21:05:29 +00:00
. write_header = seg_write_header ,
. write_packet = seg_write_packet ,
. write_trailer = seg_write_trailer ,
. priv_class = & seg_class ,
} ;
2012-01-13 14:38:13 +00:00
static const AVClass sseg_class = {
. class_name = " stream_segment muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
AVOutputFormat ff_stream_segment_muxer = {
. name = " stream_segment,ssegment " ,
. long_name = NULL_IF_CONFIG_SMALL ( " streaming segment muxer " ) ,
. priv_data_size = sizeof ( SegmentContext ) ,
. flags = AVFMT_NOFILE ,
. write_header = seg_write_header ,
. write_packet = seg_write_packet ,
. write_trailer = seg_write_trailer ,
. priv_class = & sseg_class ,
} ;