2011-10-02 21:05:29 +00:00
/*
* Copyright ( c ) 2011 , Luca Barbato
*
* This file is part of Libav .
*
* Libav is free software ; you can redistribute it and / or
* 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 .
*
* Libav is distributed in the hope that it will be useful ,
* 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
* License along with Libav ; if not , write to the Free Software
* 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 :
* @ url { http : //tools.ietf.org/id/draft-pantos-http-live-streaming-08.txt}
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"
# 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-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
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
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
2012-08-15 21:14:34 +00:00
double list_max_segment_time ; ///< max segment time in the current list
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
char * time_delta_str ; ///< approximation value duration used for the segment times
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
2012-12-22 20:49:06 +00:00
char * reference_stream_specifier ; ///< reference stream specifier
int reference_stream_index ;
2012-01-13 22:29:09 +00:00
double start_time , end_time ;
2012-11-29 12:45:50 +00:00
int64_t start_pts , start_dts ;
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 ;
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 ;
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 ) ;
}
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 + + ;
2012-12-13 10:37:50 +00:00
if ( ( err = set_segment_filename ( s ) ) < 0 )
return err ;
2012-11-17 15:35:51 +00:00
seg - > segment_count + + ;
2011-10-02 21:05:29 +00:00
if ( ( err = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , NULL ) ) < 0 )
return err ;
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 ) ;
if ( ret < 0 )
return ret ;
seg - > list_max_segment_time = 0 ;
2012-08-15 09:06:34 +00:00
if ( seg - > list_type = = LIST_TYPE_M3U8 ) {
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-11-17 16:21:43 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-MEDIA-SEQUENCE:%d \n " , seg - > segment_idx ) ;
2012-09-01 16:01:51 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-ALLOWCACHE:%d \n " ,
! ! ( seg - > list_flags & SEGMENT_LIST_FLAG_CACHE ) ) ;
if ( seg - > list_flags & SEGMENT_LIST_FLAG_LIVE )
avio_printf ( seg - > list_pb ,
" #EXT-X-TARGETDURATION:% " PRId64 " \n " , seg - > time / 1000000 ) ;
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
}
static void segment_list_close ( AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
2012-08-15 09:06:34 +00:00
if ( seg - > list_type = = LIST_TYPE_M3U8 ) {
2012-09-01 16:01:51 +00:00
if ( ! ( seg - > list_flags & SEGMENT_LIST_FLAG_LIVE ) )
avio_printf ( seg - > list_pb , " #EXT-X-TARGETDURATION:%d \n " ,
( int ) ceil ( seg - > list_max_segment_time ) ) ;
2012-08-15 09:06:34 +00:00
avio_printf ( seg - > list_pb , " #EXT-X-ENDLIST \n " ) ;
}
2012-08-15 21:21:41 +00:00
avio_close ( seg - > list_pb ) ;
}
2012-10-05 14:14:06 +00:00
static int segment_end ( AVFormatContext * s , int write_trailer )
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-08-15 20:12:11 +00:00
if ( seg - > list_size & & ! ( seg - > segment_count % seg - > list_size ) ) {
2012-08-15 21:21:41 +00:00
segment_list_close ( s ) ;
if ( ( ret = segment_list_open ( s ) ) < 0 )
2012-01-13 23:16:55 +00:00
goto end ;
}
2012-01-13 22:29:09 +00:00
if ( seg - > list_type = = LIST_TYPE_FLAT ) {
avio_printf ( seg - > list_pb , " %s \n " , oc - > filename ) ;
2012-09-14 21:31:47 +00:00
} else if ( seg - > list_type = = LIST_TYPE_CSV | | seg - > list_type = = LIST_TYPE_EXT ) {
2012-09-01 14:12:29 +00:00
print_csv_escaped_str ( seg - > list_pb , oc - > filename ) ;
avio_printf ( seg - > list_pb , " ,%f,%f \n " , seg - > start_time , seg - > end_time ) ;
2012-08-15 09:06:34 +00:00
} else if ( seg - > list_type = = LIST_TYPE_M3U8 ) {
avio_printf ( seg - > list_pb , " #EXTINF:%f, \n %s \n " ,
seg - > end_time - seg - > start_time , oc - > filename ) ;
2012-01-13 22:29:09 +00:00
}
2012-08-15 21:14:34 +00:00
seg - > list_max_segment_time = FFMAX ( seg - > end_time - seg - > start_time , seg - > list_max_segment_time ) ;
2012-01-17 19:04:14 +00:00
avio_flush ( seg - > list_pb ) ;
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 ) + + ;
* times = av_malloc ( sizeof ( * * times ) * * nb_times ) ;
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 ) + + ;
* frames = av_malloc ( sizeof ( * * frames ) * * nb_frames ) ;
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 ) ;
}
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 ;
2011-10-02 21:05:29 +00:00
int ret , i ;
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 ) ;
}
2012-12-09 19:26:30 +00:00
if ( ( seg - > list_flags & SEGMENT_LIST_FLAG_LIVE ) & & ( seg - > times_str | | seg - > frames_str ) ) {
2012-09-01 16:01:51 +00:00
av_log ( s , AV_LOG_ERROR ,
2012-12-09 19:26:30 +00:00
" segment_flags +live and segment_times or segment_frames options are mutually exclusive: "
" specify segment_time option if you want a live-friendly list \n " ) ;
2012-09-01 16:01:51 +00:00
return AVERROR ( EINVAL ) ;
}
2012-01-28 21:36:38 +00:00
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-01-28 21:21:43 +00:00
if ( seg - > time_delta_str ) {
if ( ( ret = av_parse_time ( & seg - > time_delta , seg - > time_delta_str , 1 ) ) < 0 ) {
av_log ( s , AV_LOG_ERROR ,
" Invalid time duration specification '%s' for delta option \n " ,
seg - > time_delta_str ) ;
return ret ;
}
}
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 ;
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
2012-12-22 20:49:06 +00:00
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 ;
if ( ( unsigned ) type < AVMEDIA_TYPE_NB & & type_index_map [ type ] = = - 1 )
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 )
goto fail ;
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 ) ;
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2011-10-02 21:05:29 +00:00
2012-12-22 20:49:06 +00:00
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-08-15 20:12:11 +00:00
seg - > segment_count + + ;
2011-10-02 21:05:29 +00:00
2012-10-02 21:59:35 +00:00
if ( seg - > write_header_trailer ) {
if ( ( ret = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , NULL ) ) < 0 )
goto fail ;
} 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 )
2012-08-15 21:21:41 +00:00
segment_list_close ( s ) ;
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 ;
AVFormatContext * oc = seg - > avf ;
2012-02-25 23:39:32 +00:00
AVStream * st = s - > streams [ pkt - > stream_index ] ;
2012-12-09 19:26:30 +00:00
int64_t end_pts = INT64_MAX ;
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 ) {
2012-08-15 20:12:11 +00:00
end_pts = seg - > segment_count < = seg - > nb_times ?
seg - > times [ seg - > segment_count - 1 ] : INT64_MAX ;
2012-12-09 19:26:30 +00:00
} else if ( seg - > frames ) {
start_frame = seg - > segment_count < = seg - > nb_frames ?
seg - > frames [ seg - > segment_count - 1 ] : INT_MAX ;
2012-01-28 21:36:38 +00:00
} else {
2012-08-15 20:12:11 +00:00
end_pts = seg - > time * seg - > segment_count ;
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 ) ) ) {
2012-10-05 14:14:06 +00:00
ret = segment_end ( s , seg - > individual_header_trailer ) ;
2011-10-02 21:05:29 +00:00
if ( ! ret )
2012-10-02 21:49:46 +00:00
ret = segment_start ( s , seg - > individual_header_trailer ) ;
2011-10-02 21:05:29 +00:00
if ( ret )
goto fail ;
2012-10-03 21:15:35 +00:00
oc = seg - > avf ;
2012-01-13 22:29:09 +00:00
seg - > start_time = ( double ) pkt - > pts * av_q2d ( st - > time_base ) ;
2012-11-29 12:45:50 +00:00
seg - > start_pts = av_rescale_q ( pkt - > pts , st - > time_base , AV_TIME_BASE_Q ) ;
seg - > start_dts = pkt - > dts ! = AV_NOPTS_VALUE ?
av_rescale_q ( pkt - > dts , st - > time_base , AV_TIME_BASE_Q ) : seg - > start_pts ;
2012-01-13 22:29:09 +00:00
} else if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
seg - > end_time = FFMAX ( seg - > 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 ) {
2012-12-09 19:26:30 +00:00
av_log ( s , AV_LOG_DEBUG , " 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 ;
}
2012-11-29 12:45:50 +00:00
if ( seg - > reset_timestamps ) {
av_log ( s , AV_LOG_DEBUG , " start_pts:%s pts:%s start_dts:%s dts:%s " ,
av_ts2timestr ( seg - > start_pts , & AV_TIME_BASE_Q ) , av_ts2timestr ( pkt - > pts , & st - > time_base ) ,
av_ts2timestr ( seg - > start_dts , & AV_TIME_BASE_Q ) , av_ts2timestr ( pkt - > dts , & st - > time_base ) ) ;
/* compute new timestamps */
if ( pkt - > pts ! = AV_NOPTS_VALUE )
pkt - > pts - = av_rescale_q ( seg - > start_pts , AV_TIME_BASE_Q , st - > time_base ) ;
if ( pkt - > dts ! = AV_NOPTS_VALUE )
pkt - > dts - = av_rescale_q ( seg - > start_dts , AV_TIME_BASE_Q , st - > time_base ) ;
av_log ( s , AV_LOG_DEBUG , " -> pts:%s dts:%s \n " ,
av_ts2timestr ( pkt - > pts , & st - > time_base ) , av_ts2timestr ( pkt - > dts , & st - > time_base ) ) ;
}
2012-02-25 23:39:32 +00:00
ret = ff_write_chained ( oc , 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
if ( ret < 0 ) {
if ( seg - > list )
2012-01-17 19:04:14 +00:00
avio_close ( seg - > list_pb ) ;
2011-10-02 21:05:29 +00:00
avformat_free_context ( oc ) ;
}
return ret ;
}
static int seg_write_trailer ( struct AVFormatContext * s )
{
SegmentContext * seg = s - > priv_data ;
AVFormatContext * oc = seg - > avf ;
2012-10-02 21:59:35 +00:00
int ret ;
if ( ! seg - > write_header_trailer ) {
2012-10-11 12:28:18 +00:00
if ( ( ret = segment_end ( s , 0 ) ) < 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 {
2012-10-05 14:52:13 +00:00
ret = segment_end ( s , 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 )
2012-08-15 21:21:41 +00:00
segment_list_close ( s ) ;
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
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 " } ,
{ " 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 } ,
2012-01-28 21:21:43 +00:00
{ " segment_time_delta " , " set approximation value used for the segment times " , OFFSET ( time_delta_str ) , AV_OPT_TYPE_STRING , { . str = " 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 } ,
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 } ,
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 } ,
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 ,
} ;