2001-07-22 16:18:56 +02:00
/*
2008-01-16 23:14:26 +01:00
* various utility functions for use within FFmpeg
2002-05-26 00:34:32 +02:00
* Copyright ( c ) 2000 , 2001 , 2002 Fabrice Bellard
2001-07-22 16:18:56 +02:00
*
2006-10-07 17:30:46 +02:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 00:34:32 +02:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 17:30:46 +02:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 16:18:56 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 16:18:56 +02:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 00:34:32 +02:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 16:18:56 +02:00
*
2002-05-26 00:34:32 +02:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 17:30:46 +02:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 23:43:26 +01:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 16:18:56 +02:00
*/
2011-03-15 13:11:57 +01:00
2014-01-16 01:53:03 +01:00
# undef NDEBUG
# include <assert.h>
# include <stdarg.h>
2013-11-23 21:32:55 +01:00
# include <stdint.h>
2014-01-16 01:53:03 +01:00
# include "config.h"
2012-01-05 10:14:07 +01:00
# include "libavutil/avassert.h"
2008-05-09 13:56:36 +02:00
# include "libavutil/avstring.h"
2014-01-16 01:53:03 +01:00
# include "libavutil/dict.h"
# include "libavutil/internal.h"
2011-06-04 13:58:23 +02:00
# include "libavutil/mathematics.h"
2014-01-16 01:53:03 +01:00
# include "libavutil/opt.h"
2011-11-07 22:32:21 +01:00
# include "libavutil/parseutils.h"
2014-01-16 01:53:03 +01:00
# include "libavutil/pixdesc.h"
2012-07-27 16:28:36 +02:00
# include "libavutil/time.h"
2012-05-13 22:22:35 +02:00
# include "libavutil/timestamp.h"
2014-01-16 01:53:03 +01:00
# include "libavcodec/bytestream.h"
# include "libavcodec/internal.h"
2014-01-26 23:35:38 +01:00
# include "libavcodec/raw.h"
2014-01-16 01:53:03 +01:00
2010-03-06 23:36:36 +01:00
# include "audiointerleave.h"
2014-01-16 01:53:03 +01:00
# include "avformat.h"
# include "avio_internal.h"
# include "id3v2.h"
# include "internal.h"
# include "metadata.h"
2010-03-05 23:31:45 +01:00
# if CONFIG_NETWORK
# include "network.h"
# endif
2014-01-16 01:53:03 +01:00
# include "riff.h"
# include "url.h"
2004-01-13 23:02:49 +01:00
2005-06-28 14:55:08 +02:00
/**
2010-04-20 16:45:34 +02:00
* @ file
2008-01-16 23:14:26 +01:00
* various utility functions for use within FFmpeg
2005-06-28 14:55:08 +02:00
*/
2008-08-08 20:40:50 +02:00
unsigned avformat_version ( void )
{
2011-12-22 03:06:06 +01:00
av_assert0 ( LIBAVFORMAT_VERSION_MICRO > = 100 ) ;
2008-08-08 20:40:50 +02:00
return LIBAVFORMAT_VERSION_INT ;
}
2010-01-03 15:31:25 +01:00
const char * avformat_configuration ( void )
2009-11-18 18:15:17 +01:00
{
2011-03-17 17:01:10 +01:00
return FFMPEG_CONFIGURATION ;
2009-11-18 18:15:17 +01:00
}
2010-01-03 15:31:25 +01:00
const char * avformat_license ( void )
2009-11-18 18:15:17 +01:00
{
# define LICENSE_PREFIX "libavformat license: "
2011-03-17 16:57:37 +01:00
return LICENSE_PREFIX FFMPEG_LICENSE + sizeof ( LICENSE_PREFIX ) - 1 ;
2009-11-18 18:15:17 +01:00
}
2012-04-03 23:34:53 +02:00
# define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
2012-03-07 22:13:39 +01:00
static int is_relative ( int64_t ts ) {
2012-04-03 23:34:53 +02:00
return ts > ( RELATIVE_TS_BASE - ( 1LL < < 48 ) ) ;
2012-03-07 22:13:39 +01:00
}
2012-12-02 19:27:21 +01:00
/**
* Wrap a given time stamp , if there is an indication for an overflow
*
* @ param st stream
* @ param timestamp the time stamp to wrap
* @ return resulting time stamp
*/
static int64_t wrap_timestamp ( AVStream * st , int64_t timestamp )
{
2012-12-16 01:07:53 +01:00
if ( st - > pts_wrap_behavior ! = AV_PTS_WRAP_IGNORE & &
2012-12-02 19:27:21 +01:00
st - > pts_wrap_reference ! = AV_NOPTS_VALUE & & timestamp ! = AV_NOPTS_VALUE ) {
if ( st - > pts_wrap_behavior = = AV_PTS_WRAP_ADD_OFFSET & &
timestamp < st - > pts_wrap_reference )
2014-01-26 23:35:38 +01:00
return timestamp + ( 1ULL < < st - > pts_wrap_bits ) ;
2012-12-02 19:27:21 +01:00
else if ( st - > pts_wrap_behavior = = AV_PTS_WRAP_SUB_OFFSET & &
timestamp > = st - > pts_wrap_reference )
2014-01-26 23:35:38 +01:00
return timestamp - ( 1ULL < < st - > pts_wrap_bits ) ;
2012-12-02 19:27:21 +01:00
}
return timestamp ;
}
2013-03-12 15:26:35 +01:00
MAKE_ACCESSORS ( AVStream , stream , AVRational , r_frame_rate )
2013-09-28 17:52:45 +02:00
MAKE_ACCESSORS ( AVFormatContext , format , AVCodec * , video_codec )
MAKE_ACCESSORS ( AVFormatContext , format , AVCodec * , audio_codec )
MAKE_ACCESSORS ( AVFormatContext , format , AVCodec * , subtitle_codec )
2013-12-29 22:42:33 +01:00
MAKE_ACCESSORS ( AVFormatContext , format , int , metadata_header_padding )
2014-01-19 16:12:07 +01:00
MAKE_ACCESSORS ( AVFormatContext , format , void * , opaque )
MAKE_ACCESSORS ( AVFormatContext , format , av_format_control_message , control_message_cb )
2013-03-12 15:26:35 +01:00
2014-05-19 20:16:01 +02:00
int64_t av_stream_get_end_pts ( const AVStream * st )
{
return st - > pts . val ;
}
2014-04-13 19:20:17 +02:00
void av_format_inject_global_side_data ( AVFormatContext * s )
{
int i ;
s - > internal - > inject_global_side_data = 1 ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
st - > inject_global_side_data = 1 ;
}
}
2014-05-07 05:52:58 +02:00
static const AVCodec * find_decoder ( AVFormatContext * s , AVStream * st , enum AVCodecID codec_id )
2013-09-28 17:07:47 +02:00
{
if ( st - > codec - > codec )
return st - > codec - > codec ;
2014-01-26 23:35:38 +01:00
switch ( st - > codec - > codec_type ) {
2013-09-28 17:52:45 +02:00
case AVMEDIA_TYPE_VIDEO :
2014-01-26 23:35:38 +01:00
if ( s - > video_codec ) return s - > video_codec ;
2013-09-28 17:52:45 +02:00
break ;
case AVMEDIA_TYPE_AUDIO :
2014-01-26 23:35:38 +01:00
if ( s - > audio_codec ) return s - > audio_codec ;
2013-09-28 17:52:45 +02:00
break ;
case AVMEDIA_TYPE_SUBTITLE :
2014-01-26 23:35:38 +01:00
if ( s - > subtitle_codec ) return s - > subtitle_codec ;
2013-09-28 17:52:45 +02:00
break ;
}
2013-09-28 17:07:47 +02:00
return avcodec_find_decoder ( codec_id ) ;
}
2013-08-08 22:39:49 +02:00
int av_format_get_probe_score ( const AVFormatContext * s )
{
return s - > probe_score ;
}
2013-02-19 17:20:35 +01:00
/* an arbitrarily chosen "sane" max packet size -- 50M */
# define SANE_CHUNK_SIZE (50000000)
2001-07-22 16:18:56 +02:00
2011-12-19 11:46:34 +01:00
int ffio_limit ( AVIOContext * s , int size )
2005-05-26 22:17:12 +02:00
{
2014-01-26 23:35:38 +01:00
if ( s - > maxsize > = 0 ) {
2011-12-16 05:54:03 +01:00
int64_t remaining = s - > maxsize - avio_tell ( s ) ;
2014-01-26 23:35:38 +01:00
if ( remaining < size ) {
int64_t newsize = avio_size ( s ) ;
if ( ! s - > maxsize | | s - > maxsize < newsize )
s - > maxsize = newsize - ! newsize ;
2011-12-16 15:40:21 +01:00
remaining = s - > maxsize - avio_tell ( s ) ;
2011-12-25 04:48:26 +01:00
remaining = FFMAX ( remaining , 0 ) ;
2011-12-16 15:40:21 +01:00
}
2014-01-26 23:35:38 +01:00
if ( s - > maxsize > = 0 & & remaining + 1 < size ) {
2012-11-23 18:10:02 +01:00
av_log ( NULL , remaining ? AV_LOG_ERROR : AV_LOG_DEBUG , " Truncating packet of size %d to % " PRId64 " \n " , size , remaining + 1 ) ;
2014-01-26 23:35:38 +01:00
size = remaining + 1 ;
2011-12-16 15:46:45 +01:00
}
2011-12-16 05:54:03 +01:00
}
2011-12-19 11:46:34 +01:00
return size ;
}
2014-01-16 01:53:03 +01:00
/* Read the data in sane-sized chunks and append to pkt.
* Return the number of bytes read or an error . */
2013-02-19 17:20:35 +01:00
static int append_packet_chunked ( AVIOContext * s , AVPacket * pkt , int size )
2011-12-19 11:46:34 +01:00
{
2013-04-23 15:53:49 +02:00
int64_t orig_pos = pkt - > pos ; // av_grow_packet might reset pos
2013-02-19 17:20:35 +01:00
int orig_size = pkt - > size ;
2013-03-16 17:03:41 +01:00
int ret ;
2013-02-19 17:20:35 +01:00
do {
int prev_size = pkt - > size ;
int read_size ;
2014-01-16 01:53:03 +01:00
/* When the caller requests a lot of data, limit it to the amount
* left in file or SANE_CHUNK_SIZE when it is not known . */
2013-03-16 15:12:21 +01:00
read_size = size ;
if ( read_size > SANE_CHUNK_SIZE / 10 ) {
read_size = ffio_limit ( s , read_size ) ;
// If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
if ( s - > maxsize < 0 )
read_size = FFMIN ( read_size , SANE_CHUNK_SIZE ) ;
}
2011-12-16 05:54:03 +01:00
2013-02-19 17:20:35 +01:00
ret = av_grow_packet ( pkt , read_size ) ;
if ( ret < 0 )
break ;
2005-05-26 22:17:12 +02:00
2013-02-19 17:20:35 +01:00
ret = avio_read ( s , pkt - > data + prev_size , read_size ) ;
if ( ret ! = read_size ) {
av_shrink_packet ( pkt , prev_size + FFMAX ( ret , 0 ) ) ;
break ;
}
2005-05-26 22:17:12 +02:00
2013-02-19 17:20:35 +01:00
size - = read_size ;
} while ( size > 0 ) ;
2013-03-16 15:12:21 +01:00
if ( size > 0 )
pkt - > flags | = AV_PKT_FLAG_CORRUPT ;
2005-05-26 22:17:12 +02:00
2013-02-19 17:20:35 +01:00
pkt - > pos = orig_pos ;
if ( ! pkt - > size )
2005-05-26 22:17:12 +02:00
av_free_packet ( pkt ) ;
2013-02-19 17:20:35 +01:00
return pkt - > size > orig_size ? pkt - > size - orig_size : ret ;
}
int av_get_packet ( AVIOContext * s , AVPacket * pkt , int size )
{
av_init_packet ( pkt ) ;
pkt - > data = NULL ;
pkt - > size = 0 ;
pkt - > pos = avio_tell ( s ) ;
2005-05-26 22:17:12 +02:00
2013-02-19 17:20:35 +01:00
return append_packet_chunked ( s , pkt , size ) ;
2005-05-26 22:17:12 +02:00
}
2011-02-20 11:04:12 +01:00
int av_append_packet ( AVIOContext * s , AVPacket * pkt , int size )
2010-11-21 11:24:48 +01:00
{
if ( ! pkt - > size )
return av_get_packet ( s , pkt , size ) ;
2013-02-19 17:20:35 +01:00
return append_packet_chunked ( s , pkt , size ) ;
2010-11-21 11:24:48 +01:00
}
2006-09-04 11:57:47 +02:00
int av_filename_number_test ( const char * filename )
2002-05-20 18:28:47 +02:00
{
char buf [ 1024 ] ;
2014-01-16 01:53:03 +01:00
return filename & &
( av_get_frame_filename ( buf , sizeof ( buf ) , filename , 1 ) > = 0 ) ;
2002-05-20 18:28:47 +02:00
}
2014-01-26 23:35:38 +01:00
AVInputFormat * av_probe_input_format3 ( AVProbeData * pd , int is_opened ,
int * score_ret )
2002-05-20 18:28:47 +02:00
{
2010-10-06 22:21:07 +02:00
AVProbeData lpd = * pd ;
2010-11-13 09:55:15 +01:00
AVInputFormat * fmt1 = NULL , * fmt ;
2014-01-26 23:35:38 +01:00
int score , nodat = 0 , score_max = 0 ;
2012-11-13 22:20:44 +01:00
const static uint8_t zerobuffer [ AVPROBE_PADDING_SIZE ] ;
if ( ! lpd . buf )
lpd . buf = zerobuffer ;
2002-05-20 18:28:47 +02:00
2010-10-06 22:21:07 +02:00
if ( lpd . buf_size > 10 & & ff_id3v2_match ( lpd . buf , ID3v2_DEFAULT_MAGIC ) ) {
int id3len = ff_id3v2_tag_len ( lpd . buf ) ;
if ( lpd . buf_size > id3len + 16 ) {
2014-01-16 01:53:03 +01:00
lpd . buf + = id3len ;
2010-10-06 22:21:07 +02:00
lpd . buf_size - = id3len ;
2014-05-12 20:41:32 +02:00
} else if ( id3len > = PROBE_BUF_MAX ) {
nodat = 2 ;
2014-01-26 23:35:38 +01:00
} else
2011-11-23 21:56:16 +01:00
nodat = 1 ;
2010-10-06 22:21:07 +02:00
}
2002-05-20 18:28:47 +02:00
fmt = NULL ;
2010-11-13 09:55:15 +01:00
while ( ( fmt1 = av_iformat_next ( fmt1 ) ) ) {
2007-01-19 23:52:59 +01:00
if ( ! is_opened = = ! ( fmt1 - > flags & AVFMT_NOFILE ) )
2002-05-20 18:28:47 +02:00
continue ;
score = 0 ;
2002-05-24 04:09:40 +02:00
if ( fmt1 - > read_probe ) {
2010-10-06 22:21:07 +02:00
score = fmt1 - > read_probe ( & lpd ) ;
2014-05-12 20:42:37 +02:00
if ( fmt1 - > extensions & & av_match_ext ( lpd . filename , fmt1 - > extensions ) ) {
if ( nodat = = 0 ) score = FFMAX ( score , 1 ) ;
else if ( nodat = = 1 ) score = FFMAX ( score , AVPROBE_SCORE_EXTENSION / 2 - 1 ) ;
else score = FFMAX ( score , AVPROBE_SCORE_EXTENSION ) ;
}
2002-05-24 04:09:40 +02:00
} else if ( fmt1 - > extensions ) {
2014-01-16 01:53:03 +01:00
if ( av_match_ext ( lpd . filename , fmt1 - > extensions ) )
2013-03-25 16:12:51 +01:00
score = AVPROBE_SCORE_EXTENSION ;
2005-12-17 19:14:38 +01:00
}
2011-03-04 01:12:17 +01:00
if ( score > score_max ) {
score_max = score ;
2014-01-26 23:35:38 +01:00
fmt = fmt1 ;
} else if ( score = = score_max )
2008-04-15 15:50:02 +02:00
fmt = NULL ;
2002-05-20 18:28:47 +02:00
}
2014-05-12 20:41:32 +02:00
if ( nodat = = 1 )
2013-05-05 12:29:56 +02:00
score_max = FFMIN ( AVPROBE_SCORE_EXTENSION / 2 - 1 , score_max ) ;
2014-01-26 23:35:38 +01:00
* score_ret = score_max ;
2011-10-26 03:37:24 +02:00
2002-05-20 18:28:47 +02:00
return fmt ;
}
2011-03-04 01:12:17 +01:00
AVInputFormat * av_probe_input_format2 ( AVProbeData * pd , int is_opened , int * score_max )
{
int score_ret ;
2014-01-26 23:35:38 +01:00
AVInputFormat * fmt = av_probe_input_format3 ( pd , is_opened , & score_ret ) ;
if ( score_ret > * score_max ) {
* score_max = score_ret ;
2011-03-04 01:12:17 +01:00
return fmt ;
2014-01-26 23:35:38 +01:00
} else
2011-03-04 01:12:17 +01:00
return NULL ;
}
2014-01-16 01:53:03 +01:00
AVInputFormat * av_probe_input_format ( AVProbeData * pd , int is_opened )
{
int score = 0 ;
2007-03-27 21:28:40 +02:00
return av_probe_input_format2 ( pd , is_opened , & score ) ;
}
2014-01-16 01:53:03 +01:00
static int set_codec_from_probe_data ( AVFormatContext * s , AVStream * st ,
2014-01-26 23:35:38 +01:00
AVProbeData * pd )
2008-07-12 15:25:26 +02:00
{
2010-05-22 23:52:02 +02:00
static const struct {
2014-01-16 01:53:03 +01:00
const char * name ;
enum AVCodecID id ;
enum AVMediaType type ;
2010-05-22 23:52:02 +02:00
} fmt_id_type [ ] = {
2014-01-16 01:53:03 +01:00
{ " aac " , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO } ,
{ " ac3 " , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO } ,
{ " dts " , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO } ,
{ " eac3 " , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO } ,
{ " h264 " , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO } ,
2014-02-03 11:35:19 +01:00
{ " hevc " , AV_CODEC_ID_HEVC , AVMEDIA_TYPE_VIDEO } ,
2014-01-26 23:35:38 +01:00
{ " loas " , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO } ,
2014-01-16 01:53:03 +01:00
{ " m4v " , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO } ,
{ " mp3 " , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO } ,
2012-08-05 11:11:04 +02:00
{ " mpegvideo " , AV_CODEC_ID_MPEG2VIDEO , AVMEDIA_TYPE_VIDEO } ,
2010-05-22 23:52:02 +02:00
{ 0 }
} ;
2011-03-04 01:12:17 +01:00
int score ;
AVInputFormat * fmt = av_probe_input_format3 ( pd , 1 , & score ) ;
2008-07-12 15:25:26 +02:00
2012-09-23 01:06:07 +02:00
if ( fmt & & st - > request_probe < = score ) {
2010-05-22 23:52:02 +02:00
int i ;
2014-01-16 01:53:03 +01:00
av_log ( s , AV_LOG_DEBUG ,
" Probe with size=%d, packets=%d detected %s with score=%d \n " ,
pd - > buf_size , MAX_PROBE_PACKETS - st - > probe_packets ,
fmt - > name , score ) ;
2010-05-22 23:52:02 +02:00
for ( i = 0 ; fmt_id_type [ i ] . name ; i + + ) {
if ( ! strcmp ( fmt - > name , fmt_id_type [ i ] . name ) ) {
st - > codec - > codec_id = fmt_id_type [ i ] . id ;
st - > codec - > codec_type = fmt_id_type [ i ] . type ;
break ;
}
2008-08-25 17:39:43 +02:00
}
2008-07-12 15:25:26 +02:00
}
2011-03-04 01:12:17 +01:00
return score ;
2008-07-12 15:25:26 +02:00
}
2002-05-20 18:28:47 +02:00
/************************************************************/
/* input media file */
2001-09-25 01:25:28 +02:00
2014-01-26 23:35:38 +01:00
int av_demuxer_open ( AVFormatContext * ic ) {
2011-04-30 21:35:48 +02:00
int err ;
if ( ic - > iformat - > read_header ) {
2012-01-28 04:23:26 +01:00
err = ic - > iformat - > read_header ( ic ) ;
2011-04-30 21:35:48 +02:00
if ( err < 0 )
return err ;
}
if ( ic - > pb & & ! ic - > data_offset )
ic - > data_offset = avio_tell ( ic - > pb ) ;
return 0 ;
}
2013-08-08 22:39:49 +02:00
int av_probe_input_buffer2 ( AVIOContext * pb , AVInputFormat * * fmt ,
2010-03-14 23:40:16 +01:00
const char * filename , void * logctx ,
unsigned int offset , unsigned int max_probe_size )
{
2014-01-13 22:37:31 +01:00
AVProbeData pd = { filename ? filename : " " } ;
2014-01-13 11:56:59 +01:00
uint8_t * buf = NULL ;
2012-12-10 01:00:16 +01:00
uint8_t * mime_type ;
2012-12-04 19:49:51 +01:00
int ret = 0 , probe_size , buf_offset = 0 ;
2013-08-29 01:07:57 +02:00
int score = 0 ;
2010-03-14 23:40:16 +01:00
2014-01-16 01:53:03 +01:00
if ( ! max_probe_size )
2010-03-14 23:40:16 +01:00
max_probe_size = PROBE_BUF_MAX ;
2014-01-26 23:35:38 +01:00
else if ( max_probe_size < PROBE_BUF_MIN ) {
2013-01-16 12:53:01 +01:00
av_log ( logctx , AV_LOG_ERROR ,
" Specified probe size value %u cannot be < %u \n " , max_probe_size , PROBE_BUF_MIN ) ;
2010-03-14 23:40:16 +01:00
return AVERROR ( EINVAL ) ;
}
2014-01-16 01:53:03 +01:00
if ( offset > = max_probe_size )
2010-03-14 23:40:16 +01:00
return AVERROR ( EINVAL ) ;
2012-12-11 09:34:47 +01:00
if ( ! * fmt & & pb - > av_class & & av_opt_get ( pb , " mime_type " , AV_OPT_SEARCH_CHILDREN , & mime_type ) > = 0 & & mime_type ) {
2012-12-10 01:00:16 +01:00
if ( ! av_strcasecmp ( mime_type , " audio/aacp " ) ) {
2012-12-09 20:24:49 +01:00
* fmt = av_find_input_format ( " aac " ) ;
}
2012-12-11 08:51:34 +01:00
av_freep ( & mime_type ) ;
2012-12-09 18:42:07 +01:00
}
2014-01-16 01:53:03 +01:00
for ( probe_size = PROBE_BUF_MIN ; probe_size < = max_probe_size & & ! * fmt ;
probe_size = FFMIN ( probe_size < < 1 ,
FFMAX ( max_probe_size , probe_size + 1 ) ) ) {
2013-08-29 01:07:57 +02:00
score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0 ;
2010-03-14 23:40:16 +01:00
2014-01-16 01:53:03 +01:00
/* Read probe data. */
2013-09-18 18:12:36 +02:00
if ( ( ret = av_reallocp ( & buf , probe_size + AVPROBE_PADDING_SIZE ) ) < 0 )
return ret ;
2014-01-26 23:35:38 +01:00
if ( ( ret = avio_read ( pb , buf + buf_offset ,
probe_size - buf_offset ) ) < 0 ) {
2014-01-16 01:53:03 +01:00
/* Fail if error was not end of file, otherwise, lower score. */
2010-03-14 23:40:16 +01:00
if ( ret ! = AVERROR_EOF ) {
av_free ( buf ) ;
return ret ;
}
score = 0 ;
2014-01-16 01:53:03 +01:00
ret = 0 ; /* error was end of file, nothing read */
2010-03-14 23:40:16 +01:00
}
2014-01-13 22:14:02 +01:00
buf_offset + = ret ;
2014-01-13 22:17:12 +01:00
if ( buf_offset < offset )
continue ;
2014-01-13 22:14:02 +01:00
pd . buf_size = buf_offset - offset ;
2010-03-14 23:40:16 +01:00
pd . buf = & buf [ offset ] ;
memset ( pd . buf + pd . buf_size , 0 , AVPROBE_PADDING_SIZE ) ;
2014-01-16 01:53:03 +01:00
/* Guess file format. */
2010-03-14 23:40:16 +01:00
* fmt = av_probe_input_format2 ( & pd , 1 , & score ) ;
2014-01-16 01:53:03 +01:00
if ( * fmt ) {
/* This can only be true in the last iteration. */
2014-01-26 23:35:38 +01:00
if ( score < = AVPROBE_SCORE_RETRY ) {
2014-01-16 01:53:03 +01:00
av_log ( logctx , AV_LOG_WARNING ,
2014-01-26 23:35:38 +01:00
" Format %s detected only with low score of %d, "
" misdetection possible! \n " , ( * fmt ) - > name , score ) ;
2014-01-16 01:53:03 +01:00
} else
av_log ( logctx , AV_LOG_DEBUG ,
2014-01-26 23:35:38 +01:00
" Format %s probed with size=%d and score=%d \n " ,
( * fmt ) - > name , probe_size , score ) ;
2013-11-09 16:59:10 +01:00
#if 0
FILE * f = fopen ( " probestat.tmp " , " ab " ) ;
fprintf ( f , " probe_size:%d format:%s score:%d filename:%s \n " , probe_size , ( * fmt ) - > name , score , filename ) ;
fclose ( f ) ;
# endif
2010-03-14 23:40:16 +01:00
}
}
2010-03-26 02:12:14 +01:00
if ( ! * fmt ) {
2010-04-08 11:02:27 +02:00
av_free ( buf ) ;
2010-03-26 02:12:14 +01:00
return AVERROR_INVALIDDATA ;
}
2014-01-16 01:53:03 +01:00
/* Rewind. Reuse probe buffer to avoid seeking. */
2014-01-13 22:17:12 +01:00
ret = ffio_rewind_with_probe_data ( pb , & buf , buf_offset ) ;
2010-03-14 23:40:16 +01:00
2013-08-29 01:07:57 +02:00
return ret < 0 ? ret : score ;
2010-03-14 23:40:16 +01:00
}
2013-08-08 22:39:49 +02:00
int av_probe_input_buffer ( AVIOContext * pb , AVInputFormat * * fmt ,
const char * filename , void * logctx ,
unsigned int offset , unsigned int max_probe_size )
{
int ret = av_probe_input_buffer2 ( pb , fmt , filename , logctx , offset , max_probe_size ) ;
return ret < 0 ? ret : 0 ;
}
2014-01-16 01:53:03 +01:00
/* Open input file and probe the format if necessary. */
static int init_input ( AVFormatContext * s , const char * filename ,
AVDictionary * * options )
2011-05-22 08:37:25 +02:00
{
int ret ;
2014-01-16 01:53:03 +01:00
AVProbeData pd = { filename , NULL , 0 } ;
2012-10-10 21:41:20 +02:00
int score = AVPROBE_SCORE_RETRY ;
2011-05-22 08:37:25 +02:00
if ( s - > pb ) {
s - > flags | = AVFMT_FLAG_CUSTOM_IO ;
if ( ! s - > iformat )
2014-01-26 23:35:38 +01:00
return av_probe_input_buffer2 ( s - > pb , & s - > iformat , filename ,
2014-01-27 23:09:38 +01:00
s , 0 , s - > format_probesize ) ;
2011-05-22 08:37:25 +02:00
else if ( s - > iformat - > flags & AVFMT_NOFILE )
2011-06-22 18:25:49 +02:00
av_log ( s , AV_LOG_WARNING , " Custom AVIOContext makes no sense and "
" will be ignored with AVFMT_NOFILE format. \n " ) ;
2011-05-22 08:37:25 +02:00
return 0 ;
2001-07-22 16:18:56 +02:00
}
2014-01-16 01:53:03 +01:00
if ( ( s - > iformat & & s - > iformat - > flags & AVFMT_NOFILE ) | |
2012-10-10 21:41:20 +02:00
( ! s - > iformat & & ( s - > iformat = av_probe_input_format2 ( & pd , 0 , & score ) ) ) )
2013-08-08 22:39:49 +02:00
return score ;
2011-05-22 08:37:25 +02:00
2012-03-25 11:58:55 +02:00
if ( ( ret = avio_open2 ( & s - > pb , filename , AVIO_FLAG_READ | s - > avio_flags ,
2011-11-05 12:30:21 +01:00
& s - > interrupt_callback , options ) ) < 0 )
2011-08-23 03:47:24 +02:00
return ret ;
2011-05-22 08:37:25 +02:00
if ( s - > iformat )
return 0 ;
2014-01-26 23:35:38 +01:00
return av_probe_input_buffer2 ( s - > pb , & s - > iformat , filename ,
2014-01-27 23:09:38 +01:00
s , 0 , s - > format_probesize ) ;
2011-05-22 08:37:25 +02:00
}
2012-02-25 18:05:55 +01:00
static AVPacket * add_to_pktbuf ( AVPacketList * * packet_buffer , AVPacket * pkt ,
2014-01-16 01:53:03 +01:00
AVPacketList * * plast_pktl )
{
2012-02-25 18:05:55 +01:00
AVPacketList * pktl = av_mallocz ( sizeof ( AVPacketList ) ) ;
if ( ! pktl )
return NULL ;
if ( * packet_buffer )
( * plast_pktl ) - > next = pktl ;
else
* packet_buffer = pktl ;
2014-01-16 01:53:03 +01:00
/* Add the packet in the buffered packet list. */
2012-02-25 18:05:55 +01:00
* plast_pktl = pktl ;
2014-01-16 01:53:03 +01:00
pktl - > pkt = * pkt ;
2012-02-25 18:05:55 +01:00
return & pktl - > pkt ;
}
2013-03-08 17:28:42 +01:00
int avformat_queue_attached_pictures ( AVFormatContext * s )
2012-03-18 17:34:14 +01:00
{
int i ;
for ( i = 0 ; i < s - > nb_streams ; i + + )
2012-03-18 17:35:49 +01:00
if ( s - > streams [ i ] - > disposition & AV_DISPOSITION_ATTACHED_PIC & &
s - > streams [ i ] - > discard < AVDISCARD_ALL ) {
2012-03-18 17:34:14 +01:00
AVPacket copy = s - > streams [ i ] - > attached_pic ;
2014-01-16 01:53:03 +01:00
copy . buf = av_buffer_ref ( copy . buf ) ;
2012-10-31 08:53:18 +01:00
if ( ! copy . buf )
return AVERROR ( ENOMEM ) ;
2014-01-16 01:53:03 +01:00
add_to_pktbuf ( & s - > raw_packet_buffer , & copy ,
& s - > raw_packet_buffer_end ) ;
2012-03-18 17:34:14 +01:00
}
2012-10-31 08:53:18 +01:00
return 0 ;
2012-03-18 17:34:14 +01:00
}
2014-01-16 01:53:03 +01:00
int avformat_open_input ( AVFormatContext * * ps , const char * filename ,
AVInputFormat * fmt , AVDictionary * * options )
2011-05-22 08:37:25 +02:00
{
AVFormatContext * s = * ps ;
2012-03-18 17:34:14 +01:00
int ret = 0 ;
2011-05-22 08:37:25 +02:00
AVDictionary * tmp = NULL ;
2012-02-25 09:53:35 +01:00
ID3v2ExtraMeta * id3v2_extra_meta = NULL ;
2011-05-22 08:37:25 +02:00
if ( ! s & & ! ( s = avformat_alloc_context ( ) ) )
return AVERROR ( ENOMEM ) ;
2014-01-26 23:35:38 +01:00
if ( ! s - > av_class ) {
2012-11-23 18:10:02 +01:00
av_log ( NULL , AV_LOG_ERROR , " Input context has not been properly allocated by avformat_alloc_context() and is not NULL either \n " ) ;
2012-04-18 13:49:07 +02:00
return AVERROR ( EINVAL ) ;
}
2011-05-22 08:37:25 +02:00
if ( fmt )
s - > iformat = fmt ;
if ( options )
av_dict_copy ( & tmp , * options , 0 ) ;
if ( ( ret = av_opt_set_dict ( s , & tmp ) ) < 0 )
goto fail ;
2011-11-05 12:30:21 +01:00
if ( ( ret = init_input ( s , filename , & tmp ) ) < 0 )
2011-05-22 08:37:25 +02:00
goto fail ;
2013-08-08 22:39:49 +02:00
s - > probe_score = ret ;
2012-11-20 22:04:14 +01:00
avio_skip ( s - > pb , s - > skip_initial_bytes ) ;
2011-05-22 08:37:25 +02:00
2014-01-16 01:53:03 +01:00
/* Check filename in case an image number is expected. */
2011-05-22 08:37:25 +02:00
if ( s - > iformat - > flags & AVFMT_NEEDNUMBER ) {
if ( ! av_filename_number_test ( filename ) ) {
ret = AVERROR ( EINVAL ) ;
2001-09-25 01:25:28 +02:00
goto fail ;
2002-05-20 18:28:47 +02:00
}
2011-05-22 08:37:25 +02:00
}
s - > duration = s - > start_time = AV_NOPTS_VALUE ;
2012-06-15 19:58:11 +02:00
av_strlcpy ( s - > filename , filename ? filename : " " , sizeof ( s - > filename ) ) ;
2011-05-22 08:37:25 +02:00
2014-01-16 01:53:03 +01:00
/* Allocate private data. */
2011-05-22 08:37:25 +02:00
if ( s - > iformat - > priv_data_size > 0 ) {
if ( ! ( s - > priv_data = av_mallocz ( s - > iformat - > priv_data_size ) ) ) {
ret = AVERROR ( ENOMEM ) ;
2010-03-14 23:40:16 +01:00
goto fail ;
2002-11-18 18:17:27 +01:00
}
2011-05-22 08:37:25 +02:00
if ( s - > iformat - > priv_class ) {
2014-01-16 01:53:03 +01:00
* ( const AVClass * * ) s - > priv_data = s - > iformat - > priv_class ;
2011-05-22 08:37:25 +02:00
av_opt_set_defaults ( s - > priv_data ) ;
if ( ( ret = av_opt_set_dict ( s - > priv_data , & tmp ) ) < 0 )
goto fail ;
}
2002-05-20 18:28:47 +02:00
}
2011-05-22 08:37:25 +02:00
/* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
if ( s - > pb )
2014-04-18 06:49:40 +02:00
ff_id3v2_read ( s , ID3v2_DEFAULT_MAGIC , & id3v2_extra_meta , 0 ) ;
2005-12-17 19:14:38 +01:00
2011-06-18 04:40:18 +02:00
if ( ! ( s - > flags & AVFMT_FLAG_PRIV_OPT ) & & s - > iformat - > read_header )
2012-01-12 13:20:36 +01:00
if ( ( ret = s - > iformat - > read_header ( s ) ) < 0 )
2003-10-29 15:20:56 +01:00
goto fail ;
2011-05-22 08:37:25 +02:00
2012-09-25 02:45:46 +02:00
if ( id3v2_extra_meta ) {
2013-06-16 20:49:51 +02:00
if ( ! strcmp ( s - > iformat - > name , " mp3 " ) | | ! strcmp ( s - > iformat - > name , " aac " ) | |
! strcmp ( s - > iformat - > name , " tta " ) ) {
2014-01-26 23:35:38 +01:00
if ( ( ret = ff_id3v2_parse_apic ( s , & id3v2_extra_meta ) ) < 0 )
2012-09-25 02:45:46 +02:00
goto fail ;
} else
2012-09-25 07:42:32 +02:00
av_log ( s , AV_LOG_DEBUG , " demuxer does not support additional id3 data, skipping \n " ) ;
2012-09-25 02:45:46 +02:00
}
2012-02-25 09:53:35 +01:00
ff_id3v2_free_extra_meta ( & id3v2_extra_meta ) ;
2013-03-08 17:28:42 +01:00
if ( ( ret = avformat_queue_attached_pictures ( s ) ) < 0 )
2012-10-31 08:53:18 +01:00
goto fail ;
2012-02-25 18:05:55 +01:00
2011-06-18 04:40:18 +02:00
if ( ! ( s - > flags & AVFMT_FLAG_PRIV_OPT ) & & s - > pb & & ! s - > data_offset )
2011-05-22 08:37:25 +02:00
s - > data_offset = avio_tell ( s - > pb ) ;
s - > raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE ;
if ( options ) {
av_dict_free ( options ) ;
* options = tmp ;
2003-01-11 06:02:14 +01:00
}
2011-05-22 08:37:25 +02:00
* ps = s ;
2002-05-20 18:28:47 +02:00
return 0 ;
2005-12-17 19:14:38 +01:00
2011-05-22 08:37:25 +02:00
fail :
2012-02-25 09:53:35 +01:00
ff_id3v2_free_extra_meta ( & id3v2_extra_meta ) ;
2011-05-22 08:37:25 +02:00
av_dict_free ( & tmp ) ;
if ( s - > pb & & ! ( s - > flags & AVFMT_FLAG_CUSTOM_IO ) )
avio_close ( s - > pb ) ;
avformat_free_context ( s ) ;
* ps = NULL ;
return ret ;
2001-07-22 16:18:56 +02:00
}
2003-10-29 15:20:56 +01:00
/*******************************************************/
2013-01-02 01:15:06 +01:00
static void force_codec_ids ( AVFormatContext * s , AVStream * st )
{
2014-01-26 23:35:38 +01:00
switch ( st - > codec - > codec_type ) {
2013-01-02 01:15:06 +01:00
case AVMEDIA_TYPE_VIDEO :
2014-01-26 23:35:38 +01:00
if ( s - > video_codec_id )
st - > codec - > codec_id = s - > video_codec_id ;
2013-01-02 01:15:06 +01:00
break ;
case AVMEDIA_TYPE_AUDIO :
2014-01-26 23:35:38 +01:00
if ( s - > audio_codec_id )
st - > codec - > codec_id = s - > audio_codec_id ;
2013-01-02 01:15:06 +01:00
break ;
case AVMEDIA_TYPE_SUBTITLE :
2014-01-26 23:35:38 +01:00
if ( s - > subtitle_codec_id )
st - > codec - > codec_id = s - > subtitle_codec_id ;
2013-01-02 01:15:06 +01:00
break ;
}
}
2013-09-12 10:39:22 +02:00
static int probe_codec ( AVFormatContext * s , AVStream * st , const AVPacket * pkt )
2012-06-05 01:07:48 +02:00
{
2014-01-26 23:35:38 +01:00
if ( st - > request_probe > 0 ) {
2012-06-05 01:07:48 +02:00
AVProbeData * pd = & st - > probe_data ;
2012-06-05 22:43:44 +02:00
int end ;
av_log ( s , AV_LOG_DEBUG , " probing stream %d pp:%d \n " , st - > index , st - > probe_packets ) ;
2012-06-05 01:07:48 +02:00
- - st - > probe_packets ;
2012-06-05 01:58:48 +02:00
if ( pkt ) {
2012-07-26 01:05:01 +02:00
uint8_t * new_buf = av_realloc ( pd - > buf , pd - > buf_size + pkt - > size + AVPROBE_PADDING_SIZE ) ;
2014-01-26 23:35:38 +01:00
if ( ! new_buf ) {
2013-09-17 13:09:24 +02:00
av_log ( s , AV_LOG_WARNING ,
" Failed to reallocate probe buffer for stream %d \n " ,
st - > index ) ;
2012-07-26 01:05:01 +02:00
goto no_packet ;
2013-09-17 13:09:24 +02:00
}
2012-07-26 01:05:01 +02:00
pd - > buf = new_buf ;
2014-01-16 01:53:03 +01:00
memcpy ( pd - > buf + pd - > buf_size , pkt - > data , pkt - > size ) ;
2012-06-05 01:58:48 +02:00
pd - > buf_size + = pkt - > size ;
2014-01-16 01:53:03 +01:00
memset ( pd - > buf + pd - > buf_size , 0 , AVPROBE_PADDING_SIZE ) ;
2012-06-05 01:58:48 +02:00
} else {
2012-07-26 01:05:01 +02:00
no_packet :
2012-06-05 01:58:48 +02:00
st - > probe_packets = 0 ;
2012-09-07 16:27:21 +02:00
if ( ! pd - > buf_size ) {
2014-01-26 23:35:38 +01:00
av_log ( s , AV_LOG_WARNING ,
2014-01-16 01:53:03 +01:00
" nothing to probe for stream %d \n " , st - > index ) ;
2012-09-07 16:27:21 +02:00
}
2012-06-05 01:58:48 +02:00
}
2012-06-05 01:07:48 +02:00
2012-06-05 22:43:44 +02:00
end = s - > raw_packet_buffer_remaining_size < = 0
2014-01-26 23:35:38 +01:00
| | st - > probe_packets < = 0 ;
2012-06-05 22:43:44 +02:00
2014-01-26 23:35:38 +01:00
if ( end | | av_log2 ( pd - > buf_size ) ! = av_log2 ( pd - > buf_size - pkt - > size ) ) {
int score = set_codec_from_probe_data ( s , st , pd ) ;
2014-02-02 23:48:37 +01:00
if ( ( st - > codec - > codec_id ! = AV_CODEC_ID_NONE & & score > AVPROBE_SCORE_STREAM_RETRY )
2014-01-26 23:35:38 +01:00
| | end ) {
2014-01-16 01:53:03 +01:00
pd - > buf_size = 0 ;
2012-06-05 01:07:48 +02:00
av_freep ( & pd - > buf ) ;
2014-01-26 23:35:38 +01:00
st - > request_probe = - 1 ;
if ( st - > codec - > codec_id ! = AV_CODEC_ID_NONE ) {
2012-06-05 22:43:44 +02:00
av_log ( s , AV_LOG_DEBUG , " probed stream %d \n " , st - > index ) ;
2014-01-26 23:35:38 +01:00
} else
2012-06-05 22:43:44 +02:00
av_log ( s , AV_LOG_WARNING , " probed stream %d failed \n " , st - > index ) ;
2012-06-05 01:07:48 +02:00
}
2013-01-02 01:15:58 +01:00
force_codec_ids ( s , st ) ;
2012-06-05 01:07:48 +02:00
}
}
2013-09-12 10:39:22 +02:00
return 0 ;
2012-06-05 01:07:48 +02:00
}
2013-12-04 14:34:05 +01:00
static int update_wrap_reference ( AVFormatContext * s , AVStream * st , int stream_index , AVPacket * pkt )
{
int64_t ref = pkt - > dts ;
int i , pts_wrap_behavior ;
int64_t pts_wrap_reference ;
AVProgram * first_program ;
if ( ref = = AV_NOPTS_VALUE )
ref = pkt - > pts ;
if ( st - > pts_wrap_reference ! = AV_NOPTS_VALUE | | st - > pts_wrap_bits > = 63 | | ref = = AV_NOPTS_VALUE | | ! s - > correct_ts_overflow )
return 0 ;
2014-01-26 23:35:38 +01:00
ref & = ( 1LL < < st - > pts_wrap_bits ) - 1 ;
2013-12-04 14:34:05 +01:00
// reference time stamp should be 60 s before first time stamp
pts_wrap_reference = ref - av_rescale ( 60 , st - > time_base . den , st - > time_base . num ) ;
// if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
2014-01-26 23:35:38 +01:00
pts_wrap_behavior = ( ref < ( 1LL < < st - > pts_wrap_bits ) - ( 1LL < < st - > pts_wrap_bits - 3 ) ) | |
( ref < ( 1LL < < st - > pts_wrap_bits ) - av_rescale ( 60 , st - > time_base . den , st - > time_base . num ) ) ?
2013-12-04 14:34:05 +01:00
AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET ;
first_program = av_find_program_from_stream ( s , NULL , stream_index ) ;
if ( ! first_program ) {
int default_stream_index = av_find_default_stream_index ( s ) ;
if ( s - > streams [ default_stream_index ] - > pts_wrap_reference = = AV_NOPTS_VALUE ) {
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2013-12-04 14:34:05 +01:00
s - > streams [ i ] - > pts_wrap_reference = pts_wrap_reference ;
s - > streams [ i ] - > pts_wrap_behavior = pts_wrap_behavior ;
}
}
else {
st - > pts_wrap_reference = s - > streams [ default_stream_index ] - > pts_wrap_reference ;
st - > pts_wrap_behavior = s - > streams [ default_stream_index ] - > pts_wrap_behavior ;
}
}
else {
AVProgram * program = first_program ;
while ( program ) {
if ( program - > pts_wrap_reference ! = AV_NOPTS_VALUE ) {
pts_wrap_reference = program - > pts_wrap_reference ;
pts_wrap_behavior = program - > pts_wrap_behavior ;
break ;
}
program = av_find_program_from_stream ( s , program , stream_index ) ;
}
// update every program with differing pts_wrap_reference
program = first_program ;
2014-01-26 23:35:38 +01:00
while ( program ) {
2013-12-04 14:34:05 +01:00
if ( program - > pts_wrap_reference ! = pts_wrap_reference ) {
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < program - > nb_stream_indexes ; i + + ) {
2013-12-04 14:34:05 +01:00
s - > streams [ program - > stream_index [ i ] ] - > pts_wrap_reference = pts_wrap_reference ;
s - > streams [ program - > stream_index [ i ] ] - > pts_wrap_behavior = pts_wrap_behavior ;
}
program - > pts_wrap_reference = pts_wrap_reference ;
program - > pts_wrap_behavior = pts_wrap_behavior ;
}
program = av_find_program_from_stream ( s , program , stream_index ) ;
}
}
return 1 ;
}
2012-03-04 21:41:59 +01:00
int ff_read_packet ( AVFormatContext * s , AVPacket * pkt )
2003-11-10 19:37:55 +01:00
{
2013-09-12 10:39:22 +02:00
int ret , i , err ;
2007-12-19 11:56:17 +01:00
AVStream * st ;
2008-07-12 20:42:00 +02:00
2014-01-16 01:53:03 +01:00
for ( ; ; ) {
2008-07-12 20:42:00 +02:00
AVPacketList * pktl = s - > raw_packet_buffer ;
if ( pktl ) {
* pkt = pktl - > pkt ;
2014-01-16 01:53:03 +01:00
st = s - > streams [ pkt - > stream_index ] ;
2014-01-26 23:35:38 +01:00
if ( s - > raw_packet_buffer_remaining_size < = 0 )
2013-09-17 12:37:04 +02:00
if ( ( err = probe_codec ( s , st , NULL ) ) < 0 )
return err ;
2014-01-26 23:35:38 +01:00
if ( st - > request_probe < = 0 ) {
2014-01-16 01:53:03 +01:00
s - > raw_packet_buffer = pktl - > next ;
2009-06-25 20:48:57 +02:00
s - > raw_packet_buffer_remaining_size + = pkt - > size ;
2008-07-12 20:42:00 +02:00
av_free ( pktl ) ;
return 0 ;
}
}
2012-09-20 20:00:39 +02:00
pkt - > data = NULL ;
pkt - > size = 0 ;
2008-07-12 20:43:02 +02:00
av_init_packet ( pkt ) ;
2014-01-16 01:53:03 +01:00
ret = s - > iformat - > read_packet ( s , pkt ) ;
2009-05-31 02:24:06 +02:00
if ( ret < 0 ) {
if ( ! pktl | | ret = = AVERROR ( EAGAIN ) )
return ret ;
2012-06-05 01:58:48 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
st = s - > streams [ i ] ;
2014-01-16 01:53:03 +01:00
if ( st - > probe_packets )
2013-09-12 10:39:22 +02:00
if ( ( err = probe_codec ( s , st , NULL ) ) < 0 )
return err ;
2012-06-05 22:43:44 +02:00
av_assert0 ( st - > request_probe < = 0 ) ;
2012-06-05 01:58:48 +02:00
}
2009-05-31 02:24:06 +02:00
continue ;
}
2011-04-20 03:25:48 +02:00
2011-07-24 16:28:33 +02:00
if ( ( s - > flags & AVFMT_FLAG_DISCARD_CORRUPT ) & &
( pkt - > flags & AV_PKT_FLAG_CORRUPT ) ) {
av_log ( s , AV_LOG_WARNING ,
" Dropped corrupted packet (stream = %d) \n " ,
pkt - > stream_index ) ;
2011-10-18 12:00:48 +02:00
av_free_packet ( pkt ) ;
2011-07-24 16:28:33 +02:00
continue ;
}
2014-01-26 23:35:38 +01:00
if ( pkt - > stream_index > = ( unsigned ) s - > nb_streams ) {
2011-10-12 01:04:12 +02:00
av_log ( s , AV_LOG_ERROR , " Invalid stream index %d \n " , pkt - > stream_index ) ;
continue ;
}
2014-01-16 01:53:03 +01:00
st = s - > streams [ pkt - > stream_index ] ;
2013-12-04 02:00:23 +01:00
if ( update_wrap_reference ( s , st , pkt - > stream_index , pkt ) & & st - > pts_wrap_behavior = = AV_PTS_WRAP_SUB_OFFSET ) {
// correct first time stamps to negative values
if ( ! is_relative ( st - > first_dts ) )
st - > first_dts = wrap_timestamp ( st , st - > first_dts ) ;
if ( ! is_relative ( st - > start_time ) )
st - > start_time = wrap_timestamp ( st , st - > start_time ) ;
if ( ! is_relative ( st - > cur_dts ) )
st - > cur_dts = wrap_timestamp ( st , st - > cur_dts ) ;
}
2012-12-02 19:27:21 +01:00
pkt - > dts = wrap_timestamp ( st , pkt - > dts ) ;
pkt - > pts = wrap_timestamp ( st , pkt - > pts ) ;
2007-12-19 11:56:17 +01:00
2012-09-07 13:16:04 +02:00
force_codec_ids ( s , st ) ;
2012-08-17 00:08:51 +02:00
/* TODO: audio: time filter; video: frame reordering (pts != dts) */
if ( s - > use_wallclock_as_timestamps )
pkt - > dts = pkt - > pts = av_rescale_q ( av_gettime ( ) , AV_TIME_BASE_Q , st - > time_base ) ;
2007-12-19 11:56:17 +01:00
2014-01-26 23:35:38 +01:00
if ( ! pktl & & st - > request_probe < = 0 )
2008-07-14 22:31:17 +02:00
return ret ;
2008-08-07 00:17:38 +02:00
add_to_pktbuf ( & s - > raw_packet_buffer , pkt , & s - > raw_packet_buffer_end ) ;
2009-06-25 20:48:57 +02:00
s - > raw_packet_buffer_remaining_size - = pkt - > size ;
2008-07-14 22:31:17 +02:00
2013-09-12 10:39:22 +02:00
if ( ( err = probe_codec ( s , st , pkt ) ) < 0 )
return err ;
2008-07-12 20:42:00 +02:00
}
2003-11-10 19:37:55 +01:00
}
2012-03-04 21:41:59 +01:00
# if FF_API_READ_PACKET
int av_read_packet ( AVFormatContext * s , AVPacket * pkt )
{
return ff_read_packet ( s , pkt ) ;
}
# endif
2003-11-10 19:37:55 +01:00
/**********************************************************/
2012-03-04 04:06:15 +01:00
static int determinable_frame_size ( AVCodecContext * avctx )
{
2012-08-07 22:45:46 +02:00
if ( /*avctx->codec_id == AV_CODEC_ID_AAC ||*/
avctx - > codec_id = = AV_CODEC_ID_MP1 | |
avctx - > codec_id = = AV_CODEC_ID_MP2 | |
avctx - > codec_id = = AV_CODEC_ID_MP3 /* ||
avctx - > codec_id = = AV_CODEC_ID_CELT */ )
2012-03-04 04:06:15 +01:00
return 1 ;
return 0 ;
}
2005-06-28 14:55:08 +02:00
/**
2008-01-16 23:14:26 +01:00
* Get the number of samples of an audio frame . Return - 1 on error .
2005-06-28 14:55:08 +02:00
*/
2012-10-01 00:49:16 +02:00
int ff_get_audio_frame_size ( AVCodecContext * enc , int size , int mux )
2003-11-10 19:37:55 +01:00
{
int frame_size ;
2012-02-27 21:54:41 +01:00
/* give frame_size priority if demuxing */
if ( ! mux & & enc - > frame_size > 1 )
return enc - > frame_size ;
2006-07-07 19:50:09 +02:00
2012-02-27 21:54:41 +01:00
if ( ( frame_size = av_get_audio_frame_duration ( enc , size ) ) > 0 )
return frame_size ;
2012-08-21 01:02:13 +02:00
/* Fall back on using frame_size if muxing. */
2012-02-27 21:54:41 +01:00
if ( enc - > frame_size > 1 )
return enc - > frame_size ;
2013-01-06 19:15:16 +01:00
//For WMA we currently have no other means to calculate duration thus we
//do it here by assuming CBR, which is true for all known cases.
2014-01-26 23:35:38 +01:00
if ( ! mux & & enc - > bit_rate > 0 & & size > 0 & & enc - > sample_rate > 0 & & enc - > block_align > 1 ) {
2013-01-06 19:15:16 +01:00
if ( enc - > codec_id = = AV_CODEC_ID_WMAV1 | | enc - > codec_id = = AV_CODEC_ID_WMAV2 )
return ( ( int64_t ) size * 8 * enc - > sample_rate ) / enc - > bit_rate ;
}
2012-02-27 21:54:41 +01:00
return - 1 ;
2003-11-10 19:37:55 +01:00
}
2005-06-28 14:55:08 +02:00
/**
2008-01-16 23:14:26 +01:00
* Return the frame duration in seconds . Return 0 if not available .
2005-06-28 14:55:08 +02:00
*/
2012-10-01 00:49:16 +02:00
void ff_compute_frame_duration ( int * pnum , int * pden , AVStream * st ,
AVCodecParserContext * pc , AVPacket * pkt )
2003-11-10 19:37:55 +01:00
{
int frame_size ;
* pnum = 0 ;
* pden = 0 ;
2014-01-16 01:53:03 +01:00
switch ( st - > codec - > codec_type ) {
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_VIDEO :
2011-12-01 02:44:19 +01:00
if ( st - > r_frame_rate . num & & ! pc ) {
2011-11-28 10:02:21 +01:00
* pnum = st - > r_frame_rate . den ;
* pden = st - > r_frame_rate . num ;
2014-01-16 01:53:03 +01:00
} else if ( st - > time_base . num * 1000LL > st - > time_base . den ) {
2005-04-30 23:43:59 +02:00
* pnum = st - > time_base . num ;
* pden = st - > time_base . den ;
2014-01-16 01:53:03 +01:00
} else if ( st - > codec - > time_base . num * 1000LL > st - > codec - > time_base . den ) {
2005-07-18 00:24:36 +02:00
* pnum = st - > codec - > time_base . num ;
* pden = st - > codec - > time_base . den ;
2005-05-06 22:26:50 +02:00
if ( pc & & pc - > repeat_pict ) {
2012-11-23 14:05:36 +01:00
if ( * pnum > INT_MAX / ( 1 + pc - > repeat_pict ) )
* pden / = 1 + pc - > repeat_pict ;
else
* pnum * = 1 + pc - > repeat_pict ;
2005-05-06 22:26:50 +02:00
}
2014-01-16 01:53:03 +01:00
/* If this codec can be interlaced or progressive then we need
* a parser to compute duration of a packet . Thus if we have
* no parser in such case leave duration undefined . */
if ( st - > codec - > ticks_per_frame > 1 & & ! pc )
2010-04-10 00:39:39 +02:00
* pnum = * pden = 0 ;
2003-11-10 19:37:55 +01:00
}
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_AUDIO :
2012-10-01 00:49:16 +02:00
frame_size = ff_get_audio_frame_size ( st - > codec , pkt - > size , 0 ) ;
2011-01-06 04:30:19 +01:00
if ( frame_size < = 0 | | st - > codec - > sample_rate < = 0 )
2003-11-10 19:37:55 +01:00
break ;
* pnum = frame_size ;
2005-07-18 00:24:36 +02:00
* pden = st - > codec - > sample_rate ;
2003-11-10 19:37:55 +01:00
break ;
default :
break ;
}
}
2014-01-26 23:35:38 +01:00
static int is_intra_only ( AVCodecContext * enc ) {
2012-08-21 13:47:43 +02:00
const AVCodecDescriptor * desc ;
2012-08-11 16:09:44 +02:00
2014-01-26 23:35:38 +01:00
if ( enc - > codec_type ! = AVMEDIA_TYPE_VIDEO )
2004-10-22 03:51:17 +02:00
return 1 ;
2012-08-11 16:09:44 +02:00
desc = av_codec_get_codec_descriptor ( enc ) ;
if ( ! desc ) {
desc = avcodec_descriptor_get ( enc - > codec_id ) ;
av_codec_set_codec_descriptor ( enc , desc ) ;
2004-10-22 03:51:17 +02:00
}
2012-08-11 16:09:44 +02:00
if ( desc )
return ! ! ( desc - > props & AV_CODEC_PROP_INTRA_ONLY ) ;
2004-10-22 03:51:17 +02:00
return 0 ;
}
2012-08-04 15:35:53 +02:00
static int has_decode_delay_been_guessed ( AVStream * st )
{
2014-01-26 23:35:38 +01:00
if ( st - > codec - > codec_id ! = AV_CODEC_ID_H264 ) return 1 ;
if ( ! st - > info ) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
2012-09-26 04:53:03 +02:00
return 1 ;
2012-08-04 15:35:53 +02:00
# if CONFIG_H264_DECODER
2014-01-26 23:35:38 +01:00
if ( st - > codec - > has_b_frames & &
2012-08-04 15:35:53 +02:00
avpriv_h264_has_num_reorder_frames ( st - > codec ) = = st - > codec - > has_b_frames )
return 1 ;
# endif
2014-01-26 23:35:38 +01:00
if ( st - > codec - > has_b_frames < 3 )
2012-08-04 15:38:05 +02:00
return st - > nb_decoded_frames > = 7 ;
2014-01-26 23:35:38 +01:00
else if ( st - > codec - > has_b_frames < 4 )
2012-08-04 15:38:05 +02:00
return st - > nb_decoded_frames > = 18 ;
2012-08-04 15:35:53 +02:00
else
2012-08-04 15:38:05 +02:00
return st - > nb_decoded_frames > = 20 ;
2012-08-04 15:35:53 +02:00
}
2012-03-06 03:56:25 +01:00
static AVPacketList * get_next_pkt ( AVFormatContext * s , AVStream * st , AVPacketList * pktl )
{
if ( pktl - > next )
return pktl - > next ;
2014-01-03 23:27:28 +01:00
if ( pktl = = s - > packet_buffer_end )
return s - > parse_queue ;
2012-03-06 03:56:25 +01:00
return NULL ;
}
2014-02-22 13:04:18 +01:00
static int64_t select_from_pts_buffer ( AVStream * st , int64_t * pts_buffer , int64_t dts ) {
int onein_oneout = st - > codec - > codec_id ! = AV_CODEC_ID_H264 & &
st - > codec - > codec_id ! = AV_CODEC_ID_HEVC ;
if ( ! onein_oneout ) {
int delay = st - > codec - > has_b_frames ;
int i ;
if ( dts = = AV_NOPTS_VALUE ) {
int64_t best_score = INT64_MAX ;
for ( i = 0 ; i < delay ; i + + ) {
if ( st - > pts_reorder_error_count [ i ] ) {
int64_t score = st - > pts_reorder_error [ i ] / st - > pts_reorder_error_count [ i ] ;
if ( score < best_score ) {
best_score = score ;
dts = pts_buffer [ i ] ;
}
}
}
} else {
for ( i = 0 ; i < delay ; i + + ) {
if ( pts_buffer [ i ] ! = AV_NOPTS_VALUE ) {
int64_t diff = FFABS ( pts_buffer [ i ] - dts )
+ ( uint64_t ) st - > pts_reorder_error [ i ] ;
diff = FFMAX ( diff , st - > pts_reorder_error [ i ] ) ;
st - > pts_reorder_error [ i ] = diff ;
st - > pts_reorder_error_count [ i ] + + ;
if ( st - > pts_reorder_error_count [ i ] > 250 ) {
st - > pts_reorder_error [ i ] > > = 1 ;
st - > pts_reorder_error_count [ i ] > > = 1 ;
}
}
}
}
}
if ( dts = = AV_NOPTS_VALUE )
dts = pts_buffer [ 0 ] ;
return dts ;
}
2007-09-03 09:56:26 +02:00
static void update_initial_timestamps ( AVFormatContext * s , int stream_index ,
2012-12-02 19:27:21 +01:00
int64_t dts , int64_t pts , AVPacket * pkt )
2007-09-03 09:56:26 +02:00
{
2014-01-16 01:53:03 +01:00
AVStream * st = s - > streams [ stream_index ] ;
2014-01-26 23:35:38 +01:00
AVPacketList * pktl = s - > packet_buffer ? s - > packet_buffer : s - > parse_queue ;
2012-10-11 21:16:09 +02:00
int64_t pts_buffer [ MAX_REORDER_DELAY + 1 ] ;
2012-09-26 22:52:33 +02:00
int64_t shift ;
2012-09-26 22:54:57 +02:00
int i , delay ;
2007-08-05 00:46:13 +02:00
2014-01-16 01:53:03 +01:00
if ( st - > first_dts ! = AV_NOPTS_VALUE | |
dts = = AV_NOPTS_VALUE | |
2014-01-26 23:35:38 +01:00
st - > cur_dts = = AV_NOPTS_VALUE | |
is_relative ( dts ) )
2007-08-05 00:46:13 +02:00
return ;
2014-01-26 23:35:38 +01:00
delay = st - > codec - > has_b_frames ;
st - > first_dts = dts - ( st - > cur_dts - RELATIVE_TS_BASE ) ;
2014-01-16 01:53:03 +01:00
st - > cur_dts = dts ;
2014-01-26 23:35:38 +01:00
shift = st - > first_dts - RELATIVE_TS_BASE ;
2007-08-05 00:46:13 +02:00
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < MAX_REORDER_DELAY + 1 ; i + + )
2012-09-26 22:54:57 +02:00
pts_buffer [ i ] = AV_NOPTS_VALUE ;
2012-03-07 22:13:39 +01:00
if ( is_relative ( pts ) )
2012-09-26 22:52:33 +02:00
pts + = shift ;
2012-03-07 22:13:39 +01:00
2014-01-26 23:35:38 +01:00
for ( ; pktl ; pktl = get_next_pkt ( s , st , pktl ) ) {
2014-01-16 01:53:03 +01:00
if ( pktl - > pkt . stream_index ! = stream_index )
2007-08-05 00:46:13 +02:00
continue ;
2014-01-26 23:35:38 +01:00
if ( is_relative ( pktl - > pkt . pts ) )
2012-09-26 22:52:33 +02:00
pktl - > pkt . pts + = shift ;
2007-08-05 00:46:13 +02:00
2014-01-26 23:35:38 +01:00
if ( is_relative ( pktl - > pkt . dts ) )
2012-09-26 22:52:33 +02:00
pktl - > pkt . dts + = shift ;
2007-08-05 00:54:46 +02:00
2014-01-16 01:53:03 +01:00
if ( st - > start_time = = AV_NOPTS_VALUE & & pktl - > pkt . pts ! = AV_NOPTS_VALUE )
st - > start_time = pktl - > pkt . pts ;
2012-09-26 22:54:57 +02:00
2014-01-26 23:35:38 +01:00
if ( pktl - > pkt . pts ! = AV_NOPTS_VALUE & & delay < = MAX_REORDER_DELAY & & has_decode_delay_been_guessed ( st ) ) {
pts_buffer [ 0 ] = pktl - > pkt . pts ;
for ( i = 0 ; i < delay & & pts_buffer [ i ] > pts_buffer [ i + 1 ] ; i + + )
FFSWAP ( int64_t , pts_buffer [ i ] , pts_buffer [ i + 1 ] ) ;
2014-02-22 13:04:18 +01:00
pktl - > pkt . dts = select_from_pts_buffer ( st , pts_buffer , pktl - > pkt . dts ) ;
2012-09-26 22:54:57 +02:00
}
2007-08-05 00:46:13 +02:00
}
2012-12-02 19:27:21 +01:00
2007-09-03 09:56:26 +02:00
if ( st - > start_time = = AV_NOPTS_VALUE )
st - > start_time = pts ;
2007-08-05 00:46:13 +02:00
}
2012-02-28 00:07:07 +01:00
static void update_initial_durations ( AVFormatContext * s , AVStream * st ,
int stream_index , int duration )
2008-02-15 21:32:32 +01:00
{
2014-01-26 23:35:38 +01:00
AVPacketList * pktl = s - > packet_buffer ? s - > packet_buffer : s - > parse_queue ;
int64_t cur_dts = RELATIVE_TS_BASE ;
2008-06-03 02:50:22 +02:00
2014-01-16 01:53:03 +01:00
if ( st - > first_dts ! = AV_NOPTS_VALUE ) {
2013-12-31 08:36:14 +01:00
if ( st - > update_initial_durations_done )
return ;
st - > update_initial_durations_done = 1 ;
2014-01-16 01:53:03 +01:00
cur_dts = st - > first_dts ;
2014-01-26 23:35:38 +01:00
for ( ; pktl ; pktl = get_next_pkt ( s , st , pktl ) ) {
2014-01-16 01:53:03 +01:00
if ( pktl - > pkt . stream_index = = stream_index ) {
if ( pktl - > pkt . pts ! = pktl - > pkt . dts | |
pktl - > pkt . dts ! = AV_NOPTS_VALUE | |
pktl - > pkt . duration )
2008-06-03 02:50:22 +02:00
break ;
2012-02-28 00:07:07 +01:00
cur_dts - = duration ;
2008-06-03 02:50:22 +02:00
}
}
2014-01-26 23:35:38 +01:00
if ( pktl & & pktl - > pkt . dts ! = st - > first_dts ) {
2013-09-28 04:06:13 +02:00
av_log ( s , AV_LOG_DEBUG , " first_dts %s not matching first dts %s (pts %s, duration %d) in the queue \n " ,
av_ts2str ( st - > first_dts ) , av_ts2str ( pktl - > pkt . dts ) , av_ts2str ( pktl - > pkt . pts ) , pktl - > pkt . duration ) ;
2012-05-14 17:14:44 +02:00
return ;
}
2014-01-26 23:35:38 +01:00
if ( ! pktl ) {
2013-01-03 00:15:16 +01:00
av_log ( s , AV_LOG_DEBUG , " first_dts %s but no packet with dts in the queue \n " , av_ts2str ( st - > first_dts ) ) ;
2012-05-14 17:14:44 +02:00
return ;
}
2014-01-26 23:35:38 +01:00
pktl = s - > packet_buffer ? s - > packet_buffer : s - > parse_queue ;
2008-06-03 02:50:22 +02:00
st - > first_dts = cur_dts ;
2014-01-26 23:35:38 +01:00
} else if ( st - > cur_dts ! = RELATIVE_TS_BASE )
2008-06-03 02:50:22 +02:00
return ;
2008-02-15 21:32:32 +01:00
2014-01-26 23:35:38 +01:00
for ( ; pktl ; pktl = get_next_pkt ( s , st , pktl ) ) {
2014-01-16 01:53:03 +01:00
if ( pktl - > pkt . stream_index ! = stream_index )
2008-02-15 21:32:32 +01:00
continue ;
2014-01-16 01:53:03 +01:00
if ( pktl - > pkt . pts = = pktl - > pkt . dts & &
2014-01-26 23:35:38 +01:00
( pktl - > pkt . dts = = AV_NOPTS_VALUE | | pktl - > pkt . dts = = st - > first_dts ) & &
2014-01-16 01:53:03 +01:00
! pktl - > pkt . duration ) {
pktl - > pkt . dts = cur_dts ;
if ( ! st - > codec - > has_b_frames )
pktl - > pkt . pts = cur_dts ;
2012-03-06 03:56:25 +01:00
// if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2012-02-28 00:07:07 +01:00
pktl - > pkt . duration = duration ;
2014-01-16 01:53:03 +01:00
} else
2008-02-15 21:32:32 +01:00
break ;
2012-03-02 06:22:20 +01:00
cur_dts = pktl - > pkt . dts + pktl - > pkt . duration ;
2008-02-15 21:32:32 +01:00
}
2014-01-26 23:35:38 +01:00
if ( ! pktl )
2014-01-16 01:53:03 +01:00
st - > cur_dts = cur_dts ;
2008-02-15 21:32:32 +01:00
}
2005-12-17 19:14:38 +01:00
static void compute_pkt_fields ( AVFormatContext * s , AVStream * st ,
2003-11-10 19:37:55 +01:00
AVCodecParserContext * pc , AVPacket * pkt )
{
2007-03-17 15:27:01 +01:00
int num , den , presentation_delayed , delay , i ;
2007-04-13 09:50:04 +02:00
int64_t offset ;
2014-01-03 17:44:15 +01:00
AVRational duration ;
2014-02-22 12:21:28 +01:00
int onein_oneout = st - > codec - > codec_id ! = AV_CODEC_ID_H264 & &
st - > codec - > codec_id ! = AV_CODEC_ID_HEVC ;
2005-12-17 19:14:38 +01:00
2010-03-31 14:55:16 +02:00
if ( s - > flags & AVFMT_FLAG_NOFILLIN )
return ;
2014-03-03 01:55:18 +01:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & & pkt - > dts ! = AV_NOPTS_VALUE ) {
if ( pkt - > dts = = pkt - > pts & & st - > last_dts_for_order_check ! = AV_NOPTS_VALUE ) {
if ( st - > last_dts_for_order_check < = pkt - > dts ) {
st - > dts_ordered + + ;
} else {
av_log ( s , st - > dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING ,
" DTS % " PRIi64 " < % " PRIi64 " out of order \n " ,
pkt - > dts ,
st - > last_dts_for_order_check ) ;
st - > dts_misordered + + ;
}
if ( st - > dts_ordered + st - > dts_misordered > 250 ) {
st - > dts_ordered > > = 1 ;
st - > dts_misordered > > = 1 ;
}
}
st - > last_dts_for_order_check = pkt - > dts ;
if ( st - > dts_ordered < 8 * st - > dts_misordered & & pkt - > dts = = pkt - > pts )
pkt - > dts = AV_NOPTS_VALUE ;
}
2014-01-16 01:53:03 +01:00
if ( ( s - > flags & AVFMT_FLAG_IGNDTS ) & & pkt - > pts ! = AV_NOPTS_VALUE )
pkt - > dts = AV_NOPTS_VALUE ;
2010-01-30 23:55:12 +01:00
2013-11-03 21:26:40 +01:00
if ( pc & & pc - > pict_type = = AV_PICTURE_TYPE_B
& & ! st - > codec - > has_b_frames )
2009-10-03 21:40:52 +02:00
//FIXME Set low_delay = 0 when has_b_frames = 1
2009-06-11 06:30:05 +02:00
st - > codec - > has_b_frames = 1 ;
2008-10-19 00:41:21 +02:00
/* do we have a video B-frame ? */
2014-01-16 01:53:03 +01:00
delay = st - > codec - > has_b_frames ;
2008-10-19 00:41:21 +02:00
presentation_delayed = 0 ;
2011-02-08 03:15:44 +01:00
2008-10-19 00:41:21 +02:00
/* XXX: need has_b_frame, but cannot get it if the codec is
2014-01-16 01:53:03 +01:00
* not initialized */
2008-10-19 00:41:21 +02:00
if ( delay & &
2011-04-28 01:40:44 +02:00
pc & & pc - > pict_type ! = AV_PICTURE_TYPE_B )
2008-10-19 00:41:21 +02:00
presentation_delayed = 1 ;
2013-07-28 19:04:05 +02:00
if ( pkt - > pts ! = AV_NOPTS_VALUE & & pkt - > dts ! = AV_NOPTS_VALUE & &
st - > pts_wrap_bits < 63 & &
pkt - > dts - ( 1LL < < ( st - > pts_wrap_bits - 1 ) ) > pkt - > pts ) {
2014-01-26 23:35:38 +01:00
if ( is_relative ( st - > cur_dts ) | | pkt - > dts - ( 1LL < < ( st - > pts_wrap_bits - 1 ) ) > st - > cur_dts ) {
pkt - > dts - = 1LL < < st - > pts_wrap_bits ;
2012-08-24 03:08:51 +02:00
} else
2014-01-26 23:35:38 +01:00
pkt - > pts + = 1LL < < st - > pts_wrap_bits ;
2007-07-31 17:06:27 +02:00
}
2014-01-16 01:53:03 +01:00
/* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
* We take the conservative approach and discard both .
* Note : If this is misbehaving for an H .264 file , then possibly
* presentation_delayed is not set correctly . */
if ( delay = = 1 & & pkt - > dts = = pkt - > pts & &
pkt - > dts ! = AV_NOPTS_VALUE & & presentation_delayed ) {
2011-09-14 19:53:59 +02:00
av_log ( s , AV_LOG_DEBUG , " invalid dts/pts combination % " PRIi64 " \n " , pkt - > dts ) ;
2013-12-15 04:17:05 +01:00
if ( strcmp ( s - > iformat - > name , " mov,mp4,m4a,3gp,3g2,mj2 " )
& & strcmp ( s - > iformat - > name , " flv " ) ) // otherwise we discard correct timestamps for vc1-wmapro.ism
2014-01-26 23:35:38 +01:00
pkt - > dts = AV_NOPTS_VALUE ;
2008-10-19 03:02:48 +02:00
}
2014-01-26 23:35:38 +01:00
duration = av_mul_q ( ( AVRational ) { pkt - > duration , 1 } , st - > time_base ) ;
2003-11-10 19:37:55 +01:00
if ( pkt - > duration = = 0 ) {
2012-10-01 00:49:16 +02:00
ff_compute_frame_duration ( & num , & den , st , pc , pkt ) ;
2003-11-10 19:37:55 +01:00
if ( den & & num ) {
2014-01-26 23:35:38 +01:00
duration = ( AVRational ) { num , den } ;
pkt - > duration = av_rescale_rnd ( 1 ,
num * ( int64_t ) st - > time_base . den ,
2014-01-16 01:53:03 +01:00
den * ( int64_t ) st - > time_base . num ,
AV_ROUND_DOWN ) ;
2003-11-10 19:37:55 +01:00
}
}
2014-01-03 17:44:15 +01:00
2014-01-26 23:35:38 +01:00
if ( pkt - > duration ! = 0 & & ( s - > packet_buffer | | s - > parse_queue ) )
2012-03-06 03:56:25 +01:00
update_initial_durations ( s , st , pkt - > stream_index , pkt - > duration ) ;
2003-11-10 19:37:55 +01:00
2014-01-16 01:53:03 +01:00
/* Correct timestamps with byte offset if demuxers only have timestamps
* on packet boundaries */
if ( pc & & st - > need_parsing = = AVSTREAM_PARSE_TIMESTAMPS & & pkt - > size ) {
2007-04-13 09:50:04 +02:00
/* this will estimate bitrate based on this frame's duration and size */
offset = av_rescale ( pc - > offset , pkt - > duration , pkt - > size ) ;
2014-01-16 01:53:03 +01:00
if ( pkt - > pts ! = AV_NOPTS_VALUE )
2007-04-13 09:50:04 +02:00
pkt - > pts + = offset ;
2014-01-16 01:53:03 +01:00
if ( pkt - > dts ! = AV_NOPTS_VALUE )
2007-04-13 09:50:04 +02:00
pkt - > dts + = offset ;
}
2007-06-12 11:29:25 +02:00
/* This may be redundant, but it should not hurt. */
2014-01-16 01:53:03 +01:00
if ( pkt - > dts ! = AV_NOPTS_VALUE & &
pkt - > pts ! = AV_NOPTS_VALUE & &
pkt - > pts > pkt - > dts )
2007-03-17 15:29:00 +01:00
presentation_delayed = 1 ;
2005-12-17 19:14:38 +01:00
2012-08-21 12:40:41 +02:00
av_dlog ( NULL ,
2014-01-26 23:35:38 +01:00
" IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d \n " ,
presentation_delayed , av_ts2str ( pkt - > pts ) , av_ts2str ( pkt - > dts ) , av_ts2str ( st - > cur_dts ) ,
pkt - > stream_index , pc , pkt - > duration ) ;
/* Interpolate PTS and DTS if they are not present. We skip H264
2014-01-16 01:53:03 +01:00
* currently because delay and has_b_frames are not reliably set . */
if ( ( delay = = 0 | | ( delay = = 1 & & pc ) ) & &
2014-02-22 12:21:28 +01:00
onein_oneout ) {
2007-03-17 15:29:00 +01:00
if ( presentation_delayed ) {
2008-01-16 23:14:26 +01:00
/* DTS = decompression timestamp */
/* PTS = presentation timestamp */
2007-03-17 15:29:00 +01:00
if ( pkt - > dts = = AV_NOPTS_VALUE )
2008-02-20 21:24:38 +01:00
pkt - > dts = st - > last_IP_pts ;
2012-12-02 19:27:21 +01:00
update_initial_timestamps ( s , pkt - > stream_index , pkt - > dts , pkt - > pts , pkt ) ;
2007-03-17 15:29:00 +01:00
if ( pkt - > dts = = AV_NOPTS_VALUE )
pkt - > dts = st - > cur_dts ;
2014-01-16 01:53:03 +01:00
/* This is tricky: the dts must be incremented by the duration
* of the frame we are displaying , i . e . the last I - or P - frame . */
2008-02-20 21:24:38 +01:00
if ( st - > last_IP_duration = = 0 )
st - > last_IP_duration = pkt - > duration ;
2014-01-16 01:53:03 +01:00
if ( pkt - > dts ! = AV_NOPTS_VALUE )
2008-07-09 01:26:26 +02:00
st - > cur_dts = pkt - > dts + st - > last_IP_duration ;
2014-01-16 01:53:03 +01:00
st - > last_IP_duration = pkt - > duration ;
st - > last_IP_pts = pkt - > pts ;
/* Cannot compute PTS if not present (we can compute it only
* by knowing the future . */
2012-02-28 00:07:07 +01:00
} else if ( pkt - > pts ! = AV_NOPTS_VALUE | |
pkt - > dts ! = AV_NOPTS_VALUE | |
2012-03-06 03:56:25 +01:00
pkt - > duration ) {
2012-02-28 00:07:07 +01:00
2007-03-17 15:29:00 +01:00
/* presentation is not delayed : PTS and DTS are the same */
2012-05-05 00:44:48 +02:00
if ( pkt - > pts = = AV_NOPTS_VALUE )
2007-03-17 15:29:00 +01:00
pkt - > pts = pkt - > dts ;
2012-05-05 00:44:48 +02:00
update_initial_timestamps ( s , pkt - > stream_index , pkt - > pts ,
2012-12-02 19:27:21 +01:00
pkt - > pts , pkt ) ;
2012-05-05 00:44:48 +02:00
if ( pkt - > pts = = AV_NOPTS_VALUE )
2007-03-17 15:29:00 +01:00
pkt - > pts = st - > cur_dts ;
pkt - > dts = pkt - > pts ;
2012-05-05 00:44:48 +02:00
if ( pkt - > pts ! = AV_NOPTS_VALUE )
2014-01-03 17:44:15 +01:00
st - > cur_dts = av_add_stable ( st - > time_base , pkt - > pts , duration , 1 ) ;
2007-03-17 15:29:00 +01:00
}
2003-11-10 19:37:55 +01:00
}
2007-03-17 15:27:01 +01:00
2014-01-26 23:35:38 +01:00
if ( pkt - > pts ! = AV_NOPTS_VALUE & & delay < = MAX_REORDER_DELAY & & has_decode_delay_been_guessed ( st ) ) {
2014-01-16 01:53:03 +01:00
st - > pts_buffer [ 0 ] = pkt - > pts ;
for ( i = 0 ; i < delay & & st - > pts_buffer [ i ] > st - > pts_buffer [ i + 1 ] ; i + + )
FFSWAP ( int64_t , st - > pts_buffer [ i ] , st - > pts_buffer [ i + 1 ] ) ;
2014-02-22 13:04:18 +01:00
pkt - > dts = select_from_pts_buffer ( st , st - > pts_buffer , pkt - > dts ) ;
2007-03-17 15:27:01 +01:00
}
2014-01-26 23:35:38 +01:00
// We skipped it above so we try here.
2014-02-22 12:21:28 +01:00
if ( ! onein_oneout )
2014-01-26 23:35:38 +01:00
// This should happen on the first packet
update_initial_timestamps ( s , pkt - > stream_index , pkt - > dts , pkt - > pts , pkt ) ;
if ( pkt - > dts > st - > cur_dts )
2012-08-24 03:07:03 +02:00
st - > cur_dts = pkt - > dts ;
2007-03-17 15:27:01 +01:00
2012-10-01 15:51:40 +02:00
av_dlog ( NULL , " OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s \n " ,
presentation_delayed , delay , av_ts2str ( pkt - > pts ) , av_ts2str ( pkt - > dts ) , av_ts2str ( st - > cur_dts ) ) ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* update flags */
2012-08-11 14:50:54 +02:00
if ( is_intra_only ( st - > codec ) )
2010-03-31 14:29:58 +02:00
pkt - > flags | = AV_PKT_FLAG_KEY ;
2009-02-20 00:35:59 +01:00
if ( pc )
pkt - > convergence_duration = pc - > convergence_duration ;
2003-11-10 19:37:55 +01:00
}
2012-03-03 09:43:14 +01:00
static void free_packet_buffer ( AVPacketList * * pkt_buf , AVPacketList * * pkt_buf_end )
{
while ( * pkt_buf ) {
AVPacketList * pktl = * pkt_buf ;
* pkt_buf = pktl - > next ;
av_free_packet ( & pktl - > pkt ) ;
av_freep ( & pktl ) ;
}
* pkt_buf_end = NULL ;
}
2003-11-10 19:37:55 +01:00
2012-03-04 15:49:26 +01:00
/**
2014-01-16 01:53:03 +01:00
* Parse a packet , add all split parts to parse_queue .
2012-03-04 15:49:26 +01:00
*
2014-01-16 01:53:03 +01:00
* @ param pkt Packet to parse , NULL when flushing the parser at end of stream .
2012-03-04 15:49:26 +01:00
*/
static int parse_packet ( AVFormatContext * s , AVPacket * pkt , int stream_index )
2003-11-10 19:37:55 +01:00
{
2012-03-04 15:49:26 +01:00
AVPacket out_pkt = { 0 } , flush_pkt = { 0 } ;
2014-01-16 01:53:03 +01:00
AVStream * st = s - > streams [ stream_index ] ;
uint8_t * data = pkt ? pkt - > data : NULL ;
int size = pkt ? pkt - > size : 0 ;
2012-03-04 15:49:26 +01:00
int ret = 0 , got_output = 0 ;
2003-11-10 19:37:55 +01:00
2012-03-04 15:49:26 +01:00
if ( ! pkt ) {
av_init_packet ( & flush_pkt ) ;
2014-01-16 01:53:03 +01:00
pkt = & flush_pkt ;
2012-03-04 15:49:26 +01:00
got_output = 1 ;
2012-03-25 13:16:48 +02:00
} else if ( ! size & & st - > parser - > flags & PARSER_FLAG_COMPLETE_FRAMES ) {
// preserve 0-size sync packets
compute_pkt_fields ( s , st , st - > parser , pkt ) ;
2012-03-04 15:49:26 +01:00
}
2007-04-22 13:07:35 +02:00
2012-03-04 15:49:26 +01:00
while ( size > 0 | | ( pkt = = & flush_pkt & & got_output ) ) {
int len ;
2007-02-06 00:04:48 +01:00
2012-03-04 15:49:26 +01:00
av_init_packet ( & out_pkt ) ;
2014-01-16 01:53:03 +01:00
len = av_parser_parse2 ( st - > parser , st - > codec ,
2012-03-04 15:49:26 +01:00
& out_pkt . data , & out_pkt . size , data , size ,
pkt - > pts , pkt - > dts , pkt - > pos ) ;
2007-02-06 00:04:48 +01:00
2012-03-04 15:49:26 +01:00
pkt - > pts = pkt - > dts = AV_NOPTS_VALUE ;
2012-07-24 17:29:47 +02:00
pkt - > pos = - 1 ;
2012-03-04 15:49:26 +01:00
/* increment read pointer */
data + = len ;
size - = len ;
got_output = ! ! out_pkt . size ;
if ( ! out_pkt . size )
continue ;
2013-05-17 07:39:34 +02:00
if ( pkt - > side_data ) {
out_pkt . side_data = pkt - > side_data ;
out_pkt . side_data_elems = pkt - > side_data_elems ;
2014-01-16 01:53:03 +01:00
pkt - > side_data = NULL ;
pkt - > side_data_elems = 0 ;
2013-05-17 07:39:34 +02:00
}
2012-03-04 15:49:26 +01:00
/* set the duration */
out_pkt . duration = 0 ;
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
if ( st - > codec - > sample_rate > 0 ) {
2014-01-16 01:53:03 +01:00
out_pkt . duration =
av_rescale_q_rnd ( st - > parser - > duration ,
( AVRational ) { 1 , st - > codec - > sample_rate } ,
st - > time_base ,
AV_ROUND_DOWN ) ;
2003-11-10 19:37:55 +01:00
}
2012-03-04 15:49:26 +01:00
}
out_pkt . stream_index = st - > index ;
2014-01-16 01:53:03 +01:00
out_pkt . pts = st - > parser - > pts ;
out_pkt . dts = st - > parser - > dts ;
out_pkt . pos = st - > parser - > pos ;
2012-07-24 17:34:13 +02:00
2014-01-26 23:35:38 +01:00
if ( st - > need_parsing = = AVSTREAM_PARSE_FULL_RAW )
2012-07-24 17:34:13 +02:00
out_pkt . pos = st - > parser - > frame_offset ;
2012-03-04 15:49:26 +01:00
if ( st - > parser - > key_frame = = 1 | |
( st - > parser - > key_frame = = - 1 & &
st - > parser - > pict_type = = AV_PICTURE_TYPE_I ) )
out_pkt . flags | = AV_PKT_FLAG_KEY ;
2014-01-26 23:35:38 +01:00
if ( st - > parser - > key_frame = = - 1 & & st - > parser - > pict_type = = AV_PICTURE_TYPE_NONE & & ( pkt - > flags & AV_PKT_FLAG_KEY ) )
2012-06-02 21:11:43 +02:00
out_pkt . flags | = AV_PKT_FLAG_KEY ;
2012-03-04 15:49:26 +01:00
compute_pkt_fields ( s , st , st - > parser , & out_pkt ) ;
if ( out_pkt . data = = pkt - > data & & out_pkt . size = = pkt - > size ) {
2014-01-16 01:53:03 +01:00
out_pkt . buf = pkt - > buf ;
pkt - > buf = NULL ;
2012-10-31 08:53:18 +01:00
# if FF_API_DESTRUCT_PACKET
2013-03-27 18:36:51 +01:00
FF_DISABLE_DEPRECATION_WARNINGS
2012-03-04 15:49:26 +01:00
out_pkt . destruct = pkt - > destruct ;
pkt - > destruct = NULL ;
2013-03-27 18:36:51 +01:00
FF_ENABLE_DEPRECATION_WARNINGS
2012-10-31 08:53:18 +01:00
# endif
2012-03-04 15:49:26 +01:00
}
if ( ( ret = av_dup_packet ( & out_pkt ) ) < 0 )
goto fail ;
if ( ! add_to_pktbuf ( & s - > parse_queue , & out_pkt , & s - > parse_queue_end ) ) {
av_free_packet ( & out_pkt ) ;
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
}
/* end of the stream => close and free the parser */
if ( pkt = = & flush_pkt ) {
av_parser_close ( st - > parser ) ;
st - > parser = NULL ;
}
fail :
av_free_packet ( pkt ) ;
return ret ;
}
2012-03-03 16:28:32 +01:00
static int read_from_packet_buffer ( AVPacketList * * pkt_buffer ,
AVPacketList * * pkt_buffer_end ,
AVPacket * pkt )
{
AVPacketList * pktl ;
av_assert0 ( * pkt_buffer ) ;
2014-01-16 01:53:03 +01:00
pktl = * pkt_buffer ;
* pkt = pktl - > pkt ;
2012-03-03 16:28:32 +01:00
* pkt_buffer = pktl - > next ;
if ( ! pktl - > next )
* pkt_buffer_end = NULL ;
av_freep ( & pktl ) ;
return 0 ;
}
2011-07-15 20:27:43 +02:00
static int read_frame_internal ( AVFormatContext * s , AVPacket * pkt )
2003-11-10 19:37:55 +01:00
{
2012-03-04 15:49:26 +01:00
int ret = 0 , i , got_packet = 0 ;
2003-11-10 19:37:55 +01:00
2007-04-22 13:07:35 +02:00
av_init_packet ( pkt ) ;
2012-03-04 15:49:26 +01:00
while ( ! got_packet & & ! s - > parse_queue ) {
AVStream * st ;
AVPacket cur_pkt ;
2007-02-06 00:04:48 +01:00
2012-03-04 15:49:26 +01:00
/* read next packet */
2012-03-04 21:41:59 +01:00
ret = ff_read_packet ( s , & cur_pkt ) ;
2012-03-04 15:49:26 +01:00
if ( ret < 0 ) {
if ( ret = = AVERROR ( EAGAIN ) )
2003-11-10 19:37:55 +01:00
return ret ;
2012-03-04 15:49:26 +01:00
/* flush the parsers */
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2012-03-04 15:49:26 +01:00
st = s - > streams [ i ] ;
if ( st - > parser & & st - > need_parsing )
parse_packet ( s , NULL , st - > index ) ;
2003-12-15 15:45:37 +01:00
}
2012-03-04 15:49:26 +01:00
/* all remaining packets are now in parse_queue =>
* really terminate parsing */
break ;
}
ret = 0 ;
st = s - > streams [ cur_pkt . stream_index ] ;
if ( cur_pkt . pts ! = AV_NOPTS_VALUE & &
cur_pkt . dts ! = AV_NOPTS_VALUE & &
cur_pkt . pts < cur_pkt . dts ) {
2014-01-16 01:53:03 +01:00
av_log ( s , AV_LOG_WARNING ,
2014-01-26 23:35:38 +01:00
" Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d \n " ,
2012-03-04 15:49:26 +01:00
cur_pkt . stream_index ,
2012-05-13 22:22:35 +02:00
av_ts2str ( cur_pkt . pts ) ,
av_ts2str ( cur_pkt . dts ) ,
2012-03-04 15:49:26 +01:00
cur_pkt . size ) ;
}
if ( s - > debug & FF_FDEBUG_TS )
2014-01-16 01:53:03 +01:00
av_log ( s , AV_LOG_DEBUG ,
2014-01-26 23:35:38 +01:00
" ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d \n " ,
2012-03-04 15:49:26 +01:00
cur_pkt . stream_index ,
2012-05-13 22:22:35 +02:00
av_ts2str ( cur_pkt . pts ) ,
av_ts2str ( cur_pkt . dts ) ,
2014-01-16 01:53:03 +01:00
cur_pkt . size , cur_pkt . duration , cur_pkt . flags ) ;
2012-03-04 15:49:26 +01:00
if ( st - > need_parsing & & ! st - > parser & & ! ( s - > flags & AVFMT_FLAG_NOPARSE ) ) {
st - > parser = av_parser_init ( st - > codec - > codec_id ) ;
if ( ! st - > parser ) {
2012-03-06 03:56:25 +01:00
av_log ( s , AV_LOG_VERBOSE , " parser not found for codec "
" %s, packets or times may be invalid. \n " ,
avcodec_get_name ( st - > codec - > codec_id ) ) ;
2012-03-04 15:49:26 +01:00
/* no parser available: just output the raw packets */
st - > need_parsing = AVSTREAM_PARSE_NONE ;
2014-01-26 23:35:38 +01:00
} else if ( st - > need_parsing = = AVSTREAM_PARSE_HEADERS )
2012-03-04 15:49:26 +01:00
st - > parser - > flags | = PARSER_FLAG_COMPLETE_FRAMES ;
2014-01-16 01:53:03 +01:00
else if ( st - > need_parsing = = AVSTREAM_PARSE_FULL_ONCE )
2012-03-04 15:49:26 +01:00
st - > parser - > flags | = PARSER_FLAG_ONCE ;
2014-01-26 23:35:38 +01:00
else if ( st - > need_parsing = = AVSTREAM_PARSE_FULL_RAW )
2012-05-21 14:32:24 +02:00
st - > parser - > flags | = PARSER_FLAG_USE_CODEC_TS ;
2012-03-04 15:49:26 +01:00
}
2008-05-23 19:52:42 +02:00
2012-03-04 15:49:26 +01:00
if ( ! st - > need_parsing | | ! st - > parser ) {
/* no parsing needed: we just output the packet as is */
* pkt = cur_pkt ;
compute_pkt_fields ( s , st , NULL , pkt ) ;
if ( ( s - > iformat - > flags & AVFMT_GENERIC_INDEX ) & &
( pkt - > flags & AV_PKT_FLAG_KEY ) & & pkt - > dts ! = AV_NOPTS_VALUE ) {
ff_reduce_index ( s , st - > index ) ;
2014-01-16 01:53:03 +01:00
av_add_index_entry ( st , pkt - > pos , pkt - > dts ,
0 , 0 , AVINDEX_KEYFRAME ) ;
2003-11-10 19:37:55 +01:00
}
2012-03-04 15:49:26 +01:00
got_packet = 1 ;
} else if ( st - > discard < AVDISCARD_ALL ) {
if ( ( ret = parse_packet ( s , & cur_pkt , cur_pkt . stream_index ) ) < 0 )
return ret ;
} else {
/* free packet */
av_free_packet ( & cur_pkt ) ;
2003-11-10 19:37:55 +01:00
}
2012-04-14 00:17:30 +02:00
if ( pkt - > flags & AV_PKT_FLAG_KEY )
st - > skip_to_keyframe = 0 ;
if ( st - > skip_to_keyframe ) {
av_free_packet ( & cur_pkt ) ;
2013-05-23 00:17:08 +02:00
if ( got_packet ) {
* pkt = cur_pkt ;
}
2012-04-14 00:17:30 +02:00
got_packet = 0 ;
}
2003-11-10 19:37:55 +01:00
}
2012-03-04 15:49:26 +01:00
if ( ! got_packet & & s - > parse_queue )
ret = read_from_packet_buffer ( & s - > parse_queue , & s - > parse_queue_end , pkt ) ;
2013-11-21 00:15:05 +01:00
if ( ret > = 0 ) {
AVStream * st = s - > streams [ pkt - > stream_index ] ;
if ( st - > skip_samples ) {
uint8_t * p = av_packet_new_side_data ( pkt , AV_PKT_DATA_SKIP_SAMPLES , 10 ) ;
if ( p ) {
AV_WL32 ( p , st - > skip_samples ) ;
av_log ( s , AV_LOG_DEBUG , " demuxer injecting skip %d \n " , st - > skip_samples ) ;
}
st - > skip_samples = 0 ;
}
2014-04-13 17:57:43 +02:00
2014-04-13 19:20:17 +02:00
if ( st - > inject_global_side_data ) {
2014-04-13 17:57:43 +02:00
for ( i = 0 ; i < st - > nb_side_data ; i + + ) {
AVPacketSideData * src_sd = & st - > side_data [ i ] ;
uint8_t * dst_data ;
if ( av_packet_get_side_data ( pkt , src_sd - > type , NULL ) )
continue ;
dst_data = av_packet_new_side_data ( pkt , src_sd - > type , src_sd - > size ) ;
if ( ! dst_data ) {
2014-04-15 13:35:46 +02:00
av_log ( s , AV_LOG_WARNING , " Could not inject global side data \n " ) ;
2014-04-13 17:57:43 +02:00
continue ;
}
memcpy ( dst_data , src_sd - > data , src_sd - > size ) ;
}
2014-04-13 19:20:17 +02:00
st - > inject_global_side_data = 0 ;
2014-04-13 17:57:43 +02:00
}
2013-11-21 00:15:05 +01:00
2014-04-13 18:02:42 +02:00
if ( ! ( s - > flags & AVFMT_FLAG_KEEP_SIDE_DATA ) )
av_packet_merge_side_data ( pkt ) ;
}
2013-11-21 00:09:29 +01:00
2014-01-16 01:53:03 +01:00
if ( s - > debug & FF_FDEBUG_TS )
av_log ( s , AV_LOG_DEBUG ,
2014-01-26 23:35:38 +01:00
" read_frame_internal stream=%d, pts=%s, dts=%s, "
2014-01-16 01:53:03 +01:00
" size=%d, duration=%d, flags=%d \n " ,
2014-01-26 23:35:38 +01:00
pkt - > stream_index ,
av_ts2str ( pkt - > pts ) ,
av_ts2str ( pkt - > dts ) ,
2014-01-16 01:53:03 +01:00
pkt - > size , pkt - > duration , pkt - > flags ) ;
2006-08-08 21:55:32 +02:00
2012-03-04 15:49:26 +01:00
return ret ;
2012-01-05 10:14:07 +01:00
}
2003-11-10 19:37:55 +01:00
int av_read_frame ( AVFormatContext * s , AVPacket * pkt )
2001-07-22 16:18:56 +02:00
{
2012-01-05 10:16:41 +01:00
const int genpts = s - > flags & AVFMT_FLAG_GENPTS ;
2014-01-16 01:53:03 +01:00
int eof = 0 ;
2012-03-07 22:13:39 +01:00
int ret ;
2012-07-24 17:33:15 +02:00
AVStream * st ;
2005-08-15 16:22:43 +02:00
2012-03-07 22:13:39 +01:00
if ( ! genpts ) {
2014-01-26 23:35:38 +01:00
ret = s - > packet_buffer
? read_from_packet_buffer ( & s - > packet_buffer ,
& s - > packet_buffer_end , pkt )
: read_frame_internal ( s , pkt ) ;
2012-09-24 20:38:14 +02:00
if ( ret < 0 )
return ret ;
goto return_packet ;
2012-03-07 22:13:39 +01:00
}
2012-01-05 10:14:07 +01:00
2012-01-05 10:16:41 +01:00
for ( ; ; ) {
AVPacketList * pktl = s - > packet_buffer ;
2005-08-15 16:22:43 +02:00
if ( pktl ) {
2012-01-05 10:16:41 +01:00
AVPacket * next_pkt = & pktl - > pkt ;
2005-08-15 16:22:43 +02:00
2012-01-05 10:14:07 +01:00
if ( next_pkt - > dts ! = AV_NOPTS_VALUE ) {
2010-06-22 10:48:28 +02:00
int wrap_bits = s - > streams [ next_pkt - > stream_index ] - > pts_wrap_bits ;
2012-04-04 21:01:04 +02:00
// last dts seen for this stream. if any of packets following
// current one had no dts, we will set this to AV_NOPTS_VALUE.
int64_t last_dts = next_pkt - > dts ;
2012-01-05 10:16:41 +01:00
while ( pktl & & next_pkt - > pts = = AV_NOPTS_VALUE ) {
if ( pktl - > pkt . stream_index = = next_pkt - > stream_index & &
2012-04-04 21:01:04 +02:00
( av_compare_mod ( next_pkt - > dts , pktl - > pkt . dts , 2LL < < ( wrap_bits - 1 ) ) < 0 ) ) {
2014-01-26 23:35:38 +01:00
if ( av_compare_mod ( pktl - > pkt . pts , pktl - > pkt . dts , 2LL < < ( wrap_bits - 1 ) ) ) {
// not B-frame
2012-04-04 21:01:04 +02:00
next_pkt - > pts = pktl - > pkt . dts ;
}
if ( last_dts ! = AV_NOPTS_VALUE ) {
// Once last dts was set to AV_NOPTS_VALUE, we don't change it.
last_dts = pktl - > pkt . dts ;
}
2005-08-15 16:22:43 +02:00
}
2012-01-05 10:16:41 +01:00
pktl = pktl - > next ;
2005-08-15 16:22:43 +02:00
}
2012-04-04 21:01:04 +02:00
if ( eof & & next_pkt - > pts = = AV_NOPTS_VALUE & & last_dts ! = AV_NOPTS_VALUE ) {
// Fixing the last reference frame had none pts issue (For MXF etc).
// We only do this when
// 1. eof.
// 2. we are not able to resolve a pts value for current packet.
// 3. the packets for this stream at the end of the files had valid dts.
next_pkt - > pts = last_dts + next_pkt - > duration ;
}
2005-08-15 16:22:43 +02:00
pktl = s - > packet_buffer ;
}
2005-12-17 19:14:38 +01:00
2012-01-05 10:14:07 +01:00
/* read packet from packet buffer, if there is data */
if ( ! ( next_pkt - > pts = = AV_NOPTS_VALUE & &
2012-03-07 22:13:39 +01:00
next_pkt - > dts ! = AV_NOPTS_VALUE & & ! eof ) ) {
ret = read_from_packet_buffer ( & s - > packet_buffer ,
2012-03-03 16:28:32 +01:00
& s - > packet_buffer_end , pkt ) ;
2012-03-07 22:13:39 +01:00
goto return_packet ;
}
2005-08-15 16:22:43 +02:00
}
2005-12-17 19:14:38 +01:00
2012-01-05 10:14:07 +01:00
ret = read_frame_internal ( s , pkt ) ;
if ( ret < 0 ) {
if ( pktl & & ret ! = AVERROR ( EAGAIN ) ) {
eof = 1 ;
continue ;
} else
return ret ;
2005-08-15 16:22:43 +02:00
}
2012-01-05 10:14:07 +01:00
if ( av_dup_packet ( add_to_pktbuf ( & s - > packet_buffer , pkt ,
2014-01-16 01:53:03 +01:00
& s - > packet_buffer_end ) ) < 0 )
2012-01-05 10:14:07 +01:00
return AVERROR ( ENOMEM ) ;
2003-11-10 19:37:55 +01:00
}
2012-03-07 22:13:39 +01:00
return_packet :
2012-07-04 22:00:50 +02:00
2012-07-24 17:33:15 +02:00
st = s - > streams [ pkt - > stream_index ] ;
2012-07-24 18:00:11 +02:00
if ( ( s - > iformat - > flags & AVFMT_GENERIC_INDEX ) & & pkt - > flags & AV_PKT_FLAG_KEY ) {
ff_reduce_index ( s , st - > index ) ;
av_add_index_entry ( st , pkt - > pos , pkt - > dts , 0 , 0 , AVINDEX_KEYFRAME ) ;
}
2012-03-07 22:13:39 +01:00
if ( is_relative ( pkt - > dts ) )
pkt - > dts - = RELATIVE_TS_BASE ;
if ( is_relative ( pkt - > pts ) )
pkt - > pts - = RELATIVE_TS_BASE ;
2012-07-24 18:00:11 +02:00
2012-03-07 22:13:39 +01:00
return ret ;
2003-11-10 19:37:55 +01:00
}
/* XXX: suppress the packet queue */
static void flush_packet_queue ( AVFormatContext * s )
{
2012-03-04 15:49:26 +01:00
free_packet_buffer ( & s - > parse_queue , & s - > parse_queue_end ) ;
2012-03-03 09:43:14 +01:00
free_packet_buffer ( & s - > packet_buffer , & s - > packet_buffer_end ) ;
free_packet_buffer ( & s - > raw_packet_buffer , & s - > raw_packet_buffer_end ) ;
2003-11-10 19:37:55 +01:00
2009-06-25 20:48:57 +02:00
s - > raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE ;
2002-05-20 18:28:47 +02:00
}
2003-11-10 19:37:55 +01:00
/*******************************************************/
/* seek support */
2004-01-13 23:02:49 +01:00
int av_find_default_stream_index ( AVFormatContext * s )
{
2008-06-03 17:19:43 +02:00
int first_audio_index = - 1 ;
2004-01-13 23:02:49 +01:00
int i ;
AVStream * st ;
if ( s - > nb_streams < = 0 )
return - 1 ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2004-01-13 23:02:49 +01:00
st = s - > streams [ i ] ;
2012-03-15 09:04:41 +01:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & &
! ( st - > disposition & AV_DISPOSITION_ATTACHED_PIC ) ) {
2004-01-13 23:02:49 +01:00
return i ;
}
2014-01-16 01:53:03 +01:00
if ( first_audio_index < 0 & &
st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO )
2008-06-03 17:19:43 +02:00
first_audio_index = i ;
2004-01-13 23:02:49 +01:00
}
2008-06-03 17:19:43 +02:00
return first_audio_index > = 0 ? first_audio_index : 0 ;
2004-01-13 23:02:49 +01:00
}
2014-01-16 01:53:03 +01:00
/** Flush the frame reader. */
2010-03-16 00:15:24 +01:00
void ff_read_frame_flush ( AVFormatContext * s )
2003-11-10 19:37:55 +01:00
{
AVStream * st ;
2009-12-12 16:26:33 +01:00
int i , j ;
2003-11-10 19:37:55 +01:00
flush_packet_queue ( s ) ;
2014-01-16 01:53:03 +01:00
/* Reset read state for each stream. */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2003-11-10 19:37:55 +01:00
st = s - > streams [ i ] ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
if ( st - > parser ) {
av_parser_close ( st - > parser ) ;
st - > parser = NULL ;
}
2008-02-20 21:24:38 +01:00
st - > last_IP_pts = AV_NOPTS_VALUE ;
2014-03-03 01:55:18 +01:00
st - > last_dts_for_order_check = AV_NOPTS_VALUE ;
2014-01-26 23:35:38 +01:00
if ( st - > first_dts = = AV_NOPTS_VALUE )
st - > cur_dts = RELATIVE_TS_BASE ;
else
/* We set the current DTS to an unspecified origin. */
st - > cur_dts = AV_NOPTS_VALUE ;
2009-05-31 02:24:06 +02:00
st - > probe_packets = MAX_PROBE_PACKETS ;
2009-12-12 16:26:33 +01:00
2014-01-16 01:53:03 +01:00
for ( j = 0 ; j < MAX_REORDER_DELAY + 1 ; j + + )
st - > pts_buffer [ j ] = AV_NOPTS_VALUE ;
2014-04-13 18:27:05 +02:00
2014-04-13 19:20:17 +02:00
if ( s - > internal - > inject_global_side_data )
st - > inject_global_side_data = 1 ;
2003-11-10 19:37:55 +01:00
}
}
2011-10-16 15:03:30 +02:00
void ff_update_cur_dts ( AVFormatContext * s , AVStream * ref_st , int64_t timestamp )
{
2004-10-12 12:28:27 +02:00
int i ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2004-10-22 15:15:18 +02:00
AVStream * st = s - > streams [ i ] ;
2004-10-12 12:28:27 +02:00
2014-01-16 01:53:03 +01:00
st - > cur_dts =
av_rescale ( timestamp ,
st - > time_base . den * ( int64_t ) ref_st - > time_base . num ,
st - > time_base . num * ( int64_t ) ref_st - > time_base . den ) ;
2004-10-12 12:28:27 +02:00
}
}
2008-01-13 14:33:37 +01:00
void ff_reduce_index ( AVFormatContext * s , int stream_index )
{
2014-01-16 01:53:03 +01:00
AVStream * st = s - > streams [ stream_index ] ;
unsigned int max_entries = s - > max_index_size / sizeof ( AVIndexEntry ) ;
2008-01-13 14:33:37 +01:00
2014-01-16 01:53:03 +01:00
if ( ( unsigned ) st - > nb_index_entries > = max_entries ) {
2008-01-13 14:33:37 +01:00
int i ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; 2 * i < st - > nb_index_entries ; i + + )
st - > index_entries [ i ] = st - > index_entries [ 2 * i ] ;
st - > nb_index_entries = i ;
2008-01-13 14:33:37 +01:00
}
}
2011-01-22 10:03:22 +01:00
int ff_add_index_entry ( AVIndexEntry * * index_entries ,
int * nb_index_entries ,
unsigned int * index_entries_allocated_size ,
2014-01-16 01:53:03 +01:00
int64_t pos , int64_t timestamp ,
int size , int distance , int flags )
2003-11-10 19:37:55 +01:00
{
AVIndexEntry * entries , * ie ;
2004-01-13 23:02:49 +01:00
int index ;
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
if ( ( unsigned ) * nb_index_entries + 1 > = UINT_MAX / sizeof ( AVIndexEntry ) )
2005-01-08 15:21:33 +01:00
return - 1 ;
2005-12-17 19:14:38 +01:00
2014-01-26 23:35:38 +01:00
if ( timestamp = = AV_NOPTS_VALUE )
2012-07-24 18:10:48 +02:00
return AVERROR ( EINVAL ) ;
2013-10-24 02:29:50 +02:00
if ( size < 0 | | size > 0x3FFFFFFF )
return AVERROR ( EINVAL ) ;
2012-03-07 22:13:39 +01:00
if ( is_relative ( timestamp ) ) //FIXME this maintains previous behavior but we should shift by the correct offset once known
timestamp - = RELATIVE_TS_BASE ;
2011-01-22 10:03:22 +01:00
entries = av_fast_realloc ( * index_entries ,
index_entries_allocated_size ,
( * nb_index_entries + 1 ) *
2003-11-10 19:37:55 +01:00
sizeof ( AVIndexEntry ) ) ;
2014-01-16 01:53:03 +01:00
if ( ! entries )
2005-01-08 15:21:33 +01:00
return - 1 ;
2014-01-16 01:53:03 +01:00
* index_entries = entries ;
2004-01-13 23:02:49 +01:00
2014-01-16 01:53:03 +01:00
index = ff_index_search_timestamp ( * index_entries , * nb_index_entries ,
timestamp , AVSEEK_FLAG_ANY ) ;
2004-01-13 23:02:49 +01:00
2014-01-16 01:53:03 +01:00
if ( index < 0 ) {
index = ( * nb_index_entries ) + + ;
ie = & entries [ index ] ;
2014-01-26 23:35:38 +01:00
av_assert0 ( index = = 0 | | ie [ - 1 ] . timestamp < timestamp ) ;
2014-01-16 01:53:03 +01:00
} else {
ie = & entries [ index ] ;
if ( ie - > timestamp ! = timestamp ) {
if ( ie - > timestamp < = timestamp )
2004-10-14 01:58:28 +02:00
return - 1 ;
2014-01-16 01:53:03 +01:00
memmove ( entries + index + 1 , entries + index ,
sizeof ( AVIndexEntry ) * ( * nb_index_entries - index ) ) ;
2011-01-22 10:03:22 +01:00
( * nb_index_entries ) + + ;
2014-01-16 01:53:03 +01:00
} else if ( ie - > pos = = pos & & distance < ie - > min_distance )
// do not reduce the distance
distance = ie - > min_distance ;
2004-01-17 19:06:52 +01:00
}
2004-10-11 00:05:43 +02:00
2014-01-16 01:53:03 +01:00
ie - > pos = pos ;
ie - > timestamp = timestamp ;
ie - > min_distance = distance ;
ie - > size = size ;
ie - > flags = flags ;
2005-12-17 19:14:38 +01:00
2004-01-17 19:06:52 +01:00
return index ;
2003-11-10 19:37:55 +01:00
}
2014-01-16 01:53:03 +01:00
int av_add_index_entry ( AVStream * st , int64_t pos , int64_t timestamp ,
int size , int distance , int flags )
2011-01-22 10:03:22 +01:00
{
2012-12-02 19:27:21 +01:00
timestamp = wrap_timestamp ( st , timestamp ) ;
2011-01-22 10:03:22 +01:00
return ff_add_index_entry ( & st - > index_entries , & st - > nb_index_entries ,
& st - > index_entries_allocated_size , pos ,
timestamp , size , distance , flags ) ;
}
int ff_index_search_timestamp ( const AVIndexEntry * entries , int nb_entries ,
int64_t wanted_timestamp , int flags )
2003-11-10 19:37:55 +01:00
{
int a , b , m ;
int64_t timestamp ;
2014-01-16 01:53:03 +01:00
a = - 1 ;
2004-10-11 00:05:43 +02:00
b = nb_entries ;
2004-01-13 23:02:49 +01:00
2014-01-16 01:53:03 +01:00
// Optimize appending index entries at the end.
if ( b & & entries [ b - 1 ] . timestamp < wanted_timestamp )
a = b - 1 ;
2010-03-09 16:19:23 +01:00
2004-10-11 00:05:43 +02:00
while ( b - a > 1 ) {
2014-01-16 01:53:03 +01:00
m = ( a + b ) > > 1 ;
2003-11-10 19:37:55 +01:00
timestamp = entries [ m ] . timestamp ;
2014-01-16 01:53:03 +01:00
if ( timestamp > = wanted_timestamp )
2004-10-11 00:05:43 +02:00
b = m ;
2014-01-16 01:53:03 +01:00
if ( timestamp < = wanted_timestamp )
2004-01-13 23:02:49 +01:00
a = m ;
2003-11-10 19:37:55 +01:00
}
2014-01-16 01:53:03 +01:00
m = ( flags & AVSEEK_FLAG_BACKWARD ) ? a : b ;
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
if ( ! ( flags & AVSEEK_FLAG_ANY ) )
while ( m > = 0 & & m < nb_entries & &
! ( entries [ m ] . flags & AVINDEX_KEYFRAME ) )
2005-03-13 01:13:01 +01:00
m + = ( flags & AVSEEK_FLAG_BACKWARD ) ? - 1 : 1 ;
2004-10-11 00:05:43 +02:00
2014-01-16 01:53:03 +01:00
if ( m = = nb_entries )
2004-10-11 00:05:43 +02:00
return - 1 ;
2014-01-16 01:53:03 +01:00
return m ;
2003-11-10 19:37:55 +01:00
}
2014-01-16 01:53:03 +01:00
int av_index_search_timestamp ( AVStream * st , int64_t wanted_timestamp , int flags )
2011-01-22 10:03:22 +01:00
{
return ff_index_search_timestamp ( st - > index_entries , st - > nb_index_entries ,
wanted_timestamp , flags ) ;
}
2012-12-02 19:27:21 +01:00
static int64_t ff_read_timestamp ( AVFormatContext * s , int stream_index , int64_t * ppos , int64_t pos_limit ,
int64_t ( * read_timestamp ) ( struct AVFormatContext * , int , int64_t * , int64_t ) )
{
2013-02-18 19:48:44 +01:00
int64_t ts = read_timestamp ( s , stream_index , ppos , pos_limit ) ;
if ( stream_index > = 0 )
ts = wrap_timestamp ( s - > streams [ stream_index ] , ts ) ;
return ts ;
2012-12-02 19:27:21 +01:00
}
2014-01-16 01:53:03 +01:00
int ff_seek_frame_binary ( AVFormatContext * s , int stream_index ,
int64_t target_ts , int flags )
2011-10-16 15:03:30 +02:00
{
2014-01-16 01:53:03 +01:00
AVInputFormat * avif = s - > iformat ;
2009-03-05 20:15:14 +01:00
int64_t av_uninit ( pos_min ) , av_uninit ( pos_max ) , pos , pos_limit ;
2004-04-12 18:50:03 +02:00
int64_t ts_min , ts_max , ts ;
2006-11-14 02:34:36 +01:00
int index ;
2009-12-06 01:03:53 +01:00
int64_t ret ;
2004-04-12 18:50:03 +02:00
AVStream * st ;
2004-05-23 18:26:12 +02:00
if ( stream_index < 0 )
return - 1 ;
2005-12-17 19:14:38 +01:00
2012-05-13 22:22:35 +02:00
av_dlog ( s , " read_seek: %d %s \n " , stream_index , av_ts2str ( target_ts ) ) ;
2004-04-12 18:50:03 +02:00
2014-01-16 01:53:03 +01:00
ts_max =
ts_min = AV_NOPTS_VALUE ;
pos_limit = - 1 ; // GCC falsely says it may be uninitialized.
2004-04-12 18:50:03 +02:00
2014-01-16 01:53:03 +01:00
st = s - > streams [ stream_index ] ;
if ( st - > index_entries ) {
2004-04-12 18:50:03 +02:00
AVIndexEntry * e ;
2014-01-16 01:53:03 +01:00
/* FIXME: Whole function must be checked for non-keyframe entries in
* index case , especially read_timestamp ( ) . */
index = av_index_search_timestamp ( st , target_ts ,
flags | AVSEEK_FLAG_BACKWARD ) ;
index = FFMAX ( index , 0 ) ;
e = & st - > index_entries [ index ] ;
2004-04-12 18:50:03 +02:00
2014-01-16 01:53:03 +01:00
if ( e - > timestamp < = target_ts | | e - > pos = = e - > min_distance ) {
pos_min = e - > pos ;
ts_min = e - > timestamp ;
2012-05-13 22:22:35 +02:00
av_dlog ( s , " using cached pos_min=0x% " PRIx64 " dts_min=%s \n " ,
pos_min , av_ts2str ( ts_min ) ) ;
2014-01-16 01:53:03 +01:00
} else {
2014-01-26 23:35:38 +01:00
av_assert1 ( index = = 0 ) ;
2004-04-12 18:50:03 +02:00
}
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
index = av_index_search_timestamp ( st , target_ts ,
flags & ~ AVSEEK_FLAG_BACKWARD ) ;
2013-03-27 22:53:57 +01:00
av_assert0 ( index < st - > nb_index_entries ) ;
2014-01-16 01:53:03 +01:00
if ( index > = 0 ) {
e = & st - > index_entries [ index ] ;
2013-04-19 17:30:13 +02:00
av_assert1 ( e - > timestamp > = target_ts ) ;
2014-01-16 01:53:03 +01:00
pos_max = e - > pos ;
ts_max = e - > timestamp ;
pos_limit = pos_max - e - > min_distance ;
av_dlog ( s , " using cached pos_max=0x% " PRIx64 " pos_limit=0x% " PRIx64
2014-01-26 23:35:38 +01:00
" dts_max=%s \n " , pos_max , pos_limit , av_ts2str ( ts_max ) ) ;
2004-04-12 18:50:03 +02:00
}
}
2014-01-16 01:53:03 +01:00
pos = ff_gen_search ( s , stream_index , target_ts , pos_min , pos_max , pos_limit ,
ts_min , ts_max , flags , & ts , avif - > read_timestamp ) ;
if ( pos < 0 )
2006-11-14 02:34:36 +01:00
return - 1 ;
/* do the seek */
2011-02-28 14:57:54 +01:00
if ( ( ret = avio_seek ( s - > pb , pos , SEEK_SET ) ) < 0 )
2009-12-06 01:03:53 +01:00
return ret ;
2006-11-14 02:34:36 +01:00
2011-10-21 22:26:13 +02:00
ff_read_frame_flush ( s ) ;
2011-10-16 15:03:30 +02:00
ff_update_cur_dts ( s , st , ts ) ;
2006-11-14 02:34:36 +01:00
return 0 ;
}
2013-07-06 21:52:07 +02:00
int ff_find_last_ts ( AVFormatContext * s , int stream_index , int64_t * ts , int64_t * pos ,
int64_t ( * read_timestamp ) ( struct AVFormatContext * , int , int64_t * , int64_t ) )
{
2014-01-26 23:35:38 +01:00
int64_t step = 1024 ;
2013-07-06 21:52:07 +02:00
int64_t limit , ts_max ;
int64_t filesize = avio_size ( s - > pb ) ;
2014-01-26 23:35:38 +01:00
int64_t pos_max = filesize - 1 ;
do {
2013-07-06 21:52:07 +02:00
limit = pos_max ;
pos_max = FFMAX ( 0 , ( pos_max ) - step ) ;
2014-01-26 23:35:38 +01:00
ts_max = ff_read_timestamp ( s , stream_index ,
& pos_max , limit , read_timestamp ) ;
step + = step ;
} while ( ts_max = = AV_NOPTS_VALUE & & 2 * limit > step ) ;
2013-07-06 21:52:07 +02:00
if ( ts_max = = AV_NOPTS_VALUE )
return - 1 ;
2014-01-26 23:35:38 +01:00
for ( ; ; ) {
2013-07-06 21:52:07 +02:00
int64_t tmp_pos = pos_max + 1 ;
2014-01-26 23:35:38 +01:00
int64_t tmp_ts = ff_read_timestamp ( s , stream_index ,
& tmp_pos , INT64_MAX , read_timestamp ) ;
if ( tmp_ts = = AV_NOPTS_VALUE )
2013-07-06 21:52:07 +02:00
break ;
2013-09-04 00:58:16 +02:00
av_assert0 ( tmp_pos > pos_max ) ;
2013-07-06 21:52:07 +02:00
ts_max = tmp_ts ;
pos_max = tmp_pos ;
2014-01-26 23:35:38 +01:00
if ( tmp_pos > = filesize )
2013-07-06 21:52:07 +02:00
break ;
}
if ( ts )
* ts = ts_max ;
if ( pos )
* pos = pos_max ;
return 0 ;
}
2011-10-16 15:03:30 +02:00
int64_t ff_gen_search ( AVFormatContext * s , int stream_index , int64_t target_ts ,
int64_t pos_min , int64_t pos_max , int64_t pos_limit ,
2014-01-16 01:53:03 +01:00
int64_t ts_min , int64_t ts_max ,
int flags , int64_t * ts_ret ,
int64_t ( * read_timestamp ) ( struct AVFormatContext * , int ,
int64_t * , int64_t ) )
2011-10-16 15:03:30 +02:00
{
2006-11-14 02:34:36 +01:00
int64_t pos , ts ;
2013-07-06 21:52:07 +02:00
int64_t start_pos ;
2006-11-14 02:34:36 +01:00
int no_change ;
2013-07-06 21:52:07 +02:00
int ret ;
2006-11-14 02:34:36 +01:00
2012-05-13 22:22:35 +02:00
av_dlog ( s , " gen_seek: %d %s \n " , stream_index , av_ts2str ( target_ts ) ) ;
2006-11-14 02:34:36 +01:00
2014-01-16 01:53:03 +01:00
if ( ts_min = = AV_NOPTS_VALUE ) {
2004-04-12 18:50:03 +02:00
pos_min = s - > data_offset ;
2014-01-26 23:35:38 +01:00
ts_min = ff_read_timestamp ( s , stream_index , & pos_min , INT64_MAX , read_timestamp ) ;
2004-04-12 18:50:03 +02:00
if ( ts_min = = AV_NOPTS_VALUE )
return - 1 ;
}
2014-01-26 23:35:38 +01:00
if ( ts_min > = target_ts ) {
* ts_ret = ts_min ;
2011-10-21 20:45:00 +02:00
return pos_min ;
}
2014-01-26 23:35:38 +01:00
if ( ts_max = = AV_NOPTS_VALUE ) {
2013-07-06 21:52:07 +02:00
if ( ( ret = ff_find_last_ts ( s , stream_index , & ts_max , & pos_max , read_timestamp ) ) < 0 )
return ret ;
2014-01-16 01:53:03 +01:00
pos_limit = pos_max ;
2004-04-12 18:50:03 +02:00
}
2014-01-26 23:35:38 +01:00
if ( ts_max < = target_ts ) {
* ts_ret = ts_max ;
2011-10-21 20:45:00 +02:00
return pos_max ;
}
2014-01-16 01:53:03 +01:00
if ( ts_min > ts_max )
2006-02-02 20:23:33 +01:00
return - 1 ;
2014-01-16 01:53:03 +01:00
else if ( ts_min = = ts_max )
pos_limit = pos_min ;
2006-02-02 20:23:33 +01:00
2014-01-16 01:53:03 +01:00
no_change = 0 ;
2004-04-12 18:50:03 +02:00
while ( pos_min < pos_limit ) {
2014-01-26 23:35:38 +01:00
av_dlog ( s ,
" pos_min=0x% " PRIx64 " pos_max=0x% " PRIx64 " dts_min=%s dts_max=%s \n " ,
2012-05-13 22:22:35 +02:00
pos_min , pos_max , av_ts2str ( ts_min ) , av_ts2str ( ts_max ) ) ;
2004-04-12 18:50:03 +02:00
assert ( pos_limit < = pos_max ) ;
2014-01-16 01:53:03 +01:00
if ( no_change = = 0 ) {
int64_t approximate_keyframe_distance = pos_max - pos_limit ;
2004-04-12 18:50:03 +02:00
// interpolate position (better than dichotomy)
2014-01-16 01:53:03 +01:00
pos = av_rescale ( target_ts - ts_min , pos_max - pos_min ,
ts_max - ts_min ) +
pos_min - approximate_keyframe_distance ;
} else if ( no_change = = 1 ) {
// bisection if interpolation did not change min / max pos last time
pos = ( pos_min + pos_limit ) > > 1 ;
} else {
2008-01-16 23:14:26 +01:00
/* linear search if bisection failed, can only happen if there
2014-01-16 01:53:03 +01:00
* are very few or no keyframes between min / max */
pos = pos_min ;
2004-04-12 18:50:03 +02:00
}
2014-01-16 01:53:03 +01:00
if ( pos < = pos_min )
pos = pos_min + 1 ;
else if ( pos > pos_limit )
pos = pos_limit ;
start_pos = pos ;
// May pass pos_limit instead of -1.
2014-01-26 23:35:38 +01:00
ts = ff_read_timestamp ( s , stream_index , & pos , INT64_MAX , read_timestamp ) ;
2014-01-16 01:53:03 +01:00
if ( pos = = pos_max )
2004-04-12 18:50:03 +02:00
no_change + + ;
else
2014-01-16 01:53:03 +01:00
no_change = 0 ;
2014-01-26 23:35:38 +01:00
av_dlog ( s , " % " PRId64 " % " PRId64 " % " PRId64 " / %s %s %s "
" target:%s limit:% " PRId64 " start:% " PRId64 " noc:%d \n " ,
2012-05-13 22:22:35 +02:00
pos_min , pos , pos_max ,
av_ts2str ( ts_min ) , av_ts2str ( ts ) , av_ts2str ( ts_max ) , av_ts2str ( target_ts ) ,
2011-06-07 13:18:12 +02:00
pos_limit , start_pos , no_change ) ;
2014-01-16 01:53:03 +01:00
if ( ts = = AV_NOPTS_VALUE ) {
2007-04-22 20:48:07 +02:00
av_log ( s , AV_LOG_ERROR , " read_timestamp() failed in the middle \n " ) ;
return - 1 ;
}
2004-04-12 18:50:03 +02:00
assert ( ts ! = AV_NOPTS_VALUE ) ;
2004-10-11 00:05:43 +02:00
if ( target_ts < = ts ) {
2004-04-12 18:50:03 +02:00
pos_limit = start_pos - 1 ;
2014-01-16 01:53:03 +01:00
pos_max = pos ;
ts_max = ts ;
2004-10-11 00:05:43 +02:00
}
if ( target_ts > = ts ) {
2004-04-12 18:50:03 +02:00
pos_min = pos ;
2014-01-16 01:53:03 +01:00
ts_min = ts ;
2004-04-12 18:50:03 +02:00
}
}
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
pos = ( flags & AVSEEK_FLAG_BACKWARD ) ? pos_min : pos_max ;
ts = ( flags & AVSEEK_FLAG_BACKWARD ) ? ts_min : ts_max ;
2011-10-21 22:08:39 +02:00
#if 0
2004-04-12 18:50:03 +02:00
pos_min = pos ;
2014-01-26 23:35:38 +01:00
ts_min = ff_read_timestamp ( s , stream_index , & pos_min , INT64_MAX , read_timestamp ) ;
2004-04-12 18:50:03 +02:00
pos_min + + ;
2012-12-02 19:27:21 +01:00
ts_max = ff_read_timestamp ( s , stream_index , & pos_min , INT64_MAX , read_timestamp ) ;
2012-05-13 22:22:35 +02:00
av_dlog ( s , " pos=0x% " PRIx64 " %s<=%s<=%s \n " ,
pos , av_ts2str ( ts_min ) , av_ts2str ( target_ts ) , av_ts2str ( ts_max ) ) ;
2011-10-21 22:08:39 +02:00
# endif
2014-01-16 01:53:03 +01:00
* ts_ret = ts ;
2006-11-14 02:34:36 +01:00
return pos ;
2004-04-12 18:50:03 +02:00
}
2014-01-16 01:53:03 +01:00
static int seek_frame_byte ( AVFormatContext * s , int stream_index ,
int64_t pos , int flags )
{
2004-10-11 00:05:43 +02:00
int64_t pos_min , pos_max ;
pos_min = s - > data_offset ;
2011-03-04 19:57:36 +01:00
pos_max = avio_size ( s - > pb ) - 1 ;
2004-10-11 00:05:43 +02:00
2014-01-16 01:53:03 +01:00
if ( pos < pos_min )
pos = pos_min ;
else if ( pos > pos_max )
pos = pos_max ;
2004-10-11 00:05:43 +02:00
2011-02-28 14:57:54 +01:00
avio_seek ( s - > pb , pos , SEEK_SET ) ;
2004-10-11 00:05:43 +02:00
2013-04-04 04:01:12 +02:00
s - > io_repositioned = 1 ;
2004-10-11 00:05:43 +02:00
return 0 ;
}
2014-01-16 01:53:03 +01:00
static int seek_frame_generic ( AVFormatContext * s , int stream_index ,
int64_t timestamp , int flags )
2003-11-10 19:37:55 +01:00
{
2009-12-01 23:56:44 +01:00
int index ;
int64_t ret ;
2003-11-10 19:37:55 +01:00
AVStream * st ;
AVIndexEntry * ie ;
st = s - > streams [ stream_index ] ;
2007-02-06 00:04:48 +01:00
2005-03-13 01:13:01 +01:00
index = av_index_search_timestamp ( st , timestamp , flags ) ;
2007-02-06 00:04:48 +01:00
2014-01-16 01:53:03 +01:00
if ( index < 0 & & st - > nb_index_entries & &
timestamp < st - > index_entries [ 0 ] . timestamp )
2010-02-04 00:59:48 +01:00
return - 1 ;
2014-01-16 01:53:03 +01:00
if ( index < 0 | | index = = st - > nb_index_entries - 1 ) {
2007-02-06 00:04:48 +01:00
AVPacket pkt ;
2014-01-26 23:35:38 +01:00
int nonkey = 0 ;
2007-02-06 00:04:48 +01:00
2014-01-16 01:53:03 +01:00
if ( st - > nb_index_entries ) {
2013-03-27 22:53:57 +01:00
av_assert0 ( st - > index_entries ) ;
2014-01-16 01:53:03 +01:00
ie = & st - > index_entries [ st - > nb_index_entries - 1 ] ;
2011-02-28 14:57:54 +01:00
if ( ( ret = avio_seek ( s - > pb , ie - > pos , SEEK_SET ) ) < 0 )
2008-07-31 20:02:55 +02:00
return ret ;
2011-10-16 15:03:30 +02:00
ff_update_cur_dts ( s , st , ie - > timestamp ) ;
2014-01-16 01:53:03 +01:00
} else {
2011-02-28 14:57:54 +01:00
if ( ( ret = avio_seek ( s - > pb , s - > data_offset , SEEK_SET ) ) < 0 )
2008-07-31 20:02:55 +02:00
return ret ;
}
2011-09-14 00:27:01 +02:00
for ( ; ; ) {
2011-09-14 00:26:25 +02:00
int read_status ;
2014-01-16 01:53:03 +01:00
do {
2011-09-14 00:26:25 +02:00
read_status = av_read_frame ( s , & pkt ) ;
} while ( read_status = = AVERROR ( EAGAIN ) ) ;
if ( read_status < 0 )
2007-02-06 00:04:48 +01:00
break ;
av_free_packet ( & pkt ) ;
2014-01-26 23:35:38 +01:00
if ( stream_index = = pkt . stream_index & & pkt . dts > timestamp ) {
if ( pkt . flags & AV_PKT_FLAG_KEY )
2007-02-06 00:04:48 +01:00
break ;
2014-01-26 23:35:38 +01:00
if ( nonkey + + > 1000 & & st - > codec - > codec_id ! = AV_CODEC_ID_CDGRAPHICS ) {
2011-10-05 18:23:47 +02:00
av_log ( s , AV_LOG_ERROR , " seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found \n " , nonkey ) ;
break ;
}
2007-02-06 00:04:48 +01:00
}
}
index = av_index_search_timestamp ( st , timestamp , flags ) ;
}
2003-11-10 19:37:55 +01:00
if ( index < 0 )
return - 1 ;
2010-03-16 00:15:24 +01:00
ff_read_frame_flush ( s ) ;
2014-01-16 01:53:03 +01:00
if ( s - > iformat - > read_seek )
if ( s - > iformat - > read_seek ( s , stream_index , timestamp , flags ) > = 0 )
2007-02-06 00:04:48 +01:00
return 0 ;
ie = & st - > index_entries [ index ] ;
2011-02-28 14:57:54 +01:00
if ( ( ret = avio_seek ( s - > pb , ie - > pos , SEEK_SET ) ) < 0 )
2008-07-31 20:02:55 +02:00
return ret ;
2011-10-16 15:03:30 +02:00
ff_update_cur_dts ( s , st , ie - > timestamp ) ;
2004-05-23 18:26:12 +02:00
2003-11-10 19:37:55 +01:00
return 0 ;
}
2012-03-18 17:34:14 +01:00
static int seek_frame_internal ( AVFormatContext * s , int stream_index ,
int64_t timestamp , int flags )
2003-11-10 19:37:55 +01:00
{
int ret ;
2004-05-23 18:26:12 +02:00
AVStream * st ;
2005-12-17 19:14:38 +01:00
2011-09-17 01:02:23 +02:00
if ( flags & AVSEEK_FLAG_BYTE ) {
2011-10-02 17:57:53 +02:00
if ( s - > iformat - > flags & AVFMT_NO_BYTE_SEEK )
return - 1 ;
2011-09-17 01:02:23 +02:00
ff_read_frame_flush ( s ) ;
2011-07-15 20:27:43 +02:00
return seek_frame_byte ( s , stream_index , timestamp , flags ) ;
2011-09-17 01:02:23 +02:00
}
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
if ( stream_index < 0 ) {
stream_index = av_find_default_stream_index ( s ) ;
if ( stream_index < 0 )
2004-05-23 18:26:12 +02:00
return - 1 ;
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
st = s - > streams [ stream_index ] ;
2011-08-23 03:47:24 +02:00
/* timestamp for default must be expressed in AV_TIME_BASE units */
2014-01-16 01:53:03 +01:00
timestamp = av_rescale ( timestamp , st - > time_base . den ,
AV_TIME_BASE * ( int64_t ) st - > time_base . num ) ;
2004-05-23 18:26:12 +02:00
}
2003-11-10 19:37:55 +01:00
/* first, we try the format specific seek */
2011-09-17 01:02:23 +02:00
if ( s - > iformat - > read_seek ) {
ff_read_frame_flush ( s ) ;
2004-10-11 00:05:43 +02:00
ret = s - > iformat - > read_seek ( s , stream_index , timestamp , flags ) ;
2011-09-17 01:02:23 +02:00
} else
2003-11-10 19:37:55 +01:00
ret = - 1 ;
2014-01-16 01:53:03 +01:00
if ( ret > = 0 )
2003-11-10 19:37:55 +01:00
return 0 ;
2004-04-12 18:50:03 +02:00
2014-01-16 01:53:03 +01:00
if ( s - > iformat - > read_timestamp & &
! ( s - > iformat - > flags & AVFMT_NOBINSEARCH ) ) {
2011-09-17 01:02:23 +02:00
ff_read_frame_flush ( s ) ;
2011-10-16 15:03:30 +02:00
return ff_seek_frame_binary ( s , stream_index , timestamp , flags ) ;
2011-09-17 01:02:23 +02:00
} else if ( ! ( s - > iformat - > flags & AVFMT_NOGENSEARCH ) ) {
ff_read_frame_flush ( s ) ;
2011-07-15 20:27:43 +02:00
return seek_frame_generic ( s , stream_index , timestamp , flags ) ;
2014-01-16 01:53:03 +01:00
} else
2011-05-17 17:30:05 +02:00
return - 1 ;
2003-11-10 19:37:55 +01:00
}
2014-01-16 01:53:03 +01:00
int av_seek_frame ( AVFormatContext * s , int stream_index ,
int64_t timestamp , int flags )
2012-03-18 17:34:14 +01:00
{
2013-04-29 23:58:22 +02:00
int ret ;
if ( s - > iformat - > read_seek2 & & ! s - > iformat - > read_seek ) {
int64_t min_ts = INT64_MIN , max_ts = INT64_MAX ;
if ( ( flags & AVSEEK_FLAG_BACKWARD ) )
max_ts = timestamp ;
else
min_ts = timestamp ;
return avformat_seek_file ( s , stream_index , min_ts , timestamp , max_ts ,
flags & ~ AVSEEK_FLAG_BACKWARD ) ;
}
2013-05-04 16:58:41 +02:00
2013-04-29 23:58:22 +02:00
ret = seek_frame_internal ( s , stream_index , timestamp , flags ) ;
2012-03-18 17:34:14 +01:00
if ( ret > = 0 )
2013-03-08 17:28:42 +01:00
ret = avformat_queue_attached_pictures ( s ) ;
2012-03-18 17:34:14 +01:00
return ret ;
}
2014-01-16 01:53:03 +01:00
int avformat_seek_file ( AVFormatContext * s , int stream_index , int64_t min_ts ,
int64_t ts , int64_t max_ts , int flags )
2009-03-14 16:51:46 +01:00
{
2014-01-16 01:53:03 +01:00
if ( min_ts > ts | | max_ts < ts )
2009-03-14 16:51:46 +01:00
return - 1 ;
2013-03-20 12:27:42 +01:00
if ( stream_index < - 1 | | stream_index > = ( int ) s - > nb_streams )
return AVERROR ( EINVAL ) ;
2009-03-14 16:51:46 +01:00
2014-01-26 23:35:38 +01:00
if ( s - > seek2any > 0 )
2012-08-06 01:25:57 +02:00
flags | = AVSEEK_FLAG_ANY ;
2013-05-03 10:31:33 +02:00
flags & = ~ AVSEEK_FLAG_BACKWARD ;
2012-08-06 01:25:57 +02:00
2011-09-17 01:02:23 +02:00
if ( s - > iformat - > read_seek2 ) {
2012-03-18 17:34:14 +01:00
int ret ;
2011-09-17 01:02:23 +02:00
ff_read_frame_flush ( s ) ;
2013-01-02 22:55:42 +01:00
if ( stream_index = = - 1 & & s - > nb_streams = = 1 ) {
AVRational time_base = s - > streams [ 0 ] - > time_base ;
ts = av_rescale_q ( ts , AV_TIME_BASE_Q , time_base ) ;
min_ts = av_rescale_rnd ( min_ts , time_base . den ,
time_base . num * ( int64_t ) AV_TIME_BASE ,
2013-01-02 22:01:41 +01:00
AV_ROUND_UP | AV_ROUND_PASS_MINMAX ) ;
2013-01-02 22:55:42 +01:00
max_ts = av_rescale_rnd ( max_ts , time_base . den ,
time_base . num * ( int64_t ) AV_TIME_BASE ,
2013-01-02 22:01:41 +01:00
AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX ) ;
2013-01-02 22:55:42 +01:00
}
2014-01-16 01:53:03 +01:00
ret = s - > iformat - > read_seek2 ( s , stream_index , min_ts ,
ts , max_ts , flags ) ;
2012-03-18 17:34:14 +01:00
if ( ret > = 0 )
2013-03-08 17:28:42 +01:00
ret = avformat_queue_attached_pictures ( s ) ;
2012-03-18 17:34:14 +01:00
return ret ;
2011-09-17 01:02:23 +02:00
}
2009-03-14 16:51:46 +01:00
2014-01-16 01:53:03 +01:00
if ( s - > iformat - > read_timestamp ) {
// try to seek via read_timestamp()
2009-03-14 16:51:46 +01:00
}
2012-08-21 01:02:13 +02:00
// Fall back on old API if new is not implemented but old is.
// Note the old API has somewhat different semantics.
2012-02-18 00:16:58 +01:00
if ( s - > iformat - > read_seek | | 1 ) {
2012-09-11 02:51:09 +02:00
int dir = ( ts - ( uint64_t ) min_ts > ( uint64_t ) max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0 ) ;
2012-02-18 00:16:58 +01:00
int ret = av_seek_frame ( s , stream_index , ts , flags | dir ) ;
if ( ret < 0 & & ts ! = min_ts & & max_ts ! = ts ) {
ret = av_seek_frame ( s , stream_index , dir ? max_ts : min_ts , flags | dir ) ;
if ( ret > = 0 )
ret = av_seek_frame ( s , stream_index , ts , flags | ( dir ^ AVSEEK_FLAG_BACKWARD ) ) ;
}
return ret ;
}
2009-03-14 16:51:46 +01:00
2011-07-15 20:27:43 +02:00
// try some generic seek like seek_frame_generic() but with new ts semantics
2013-01-03 16:02:47 +01:00
return - 1 ; //unreachable
2009-03-14 16:51:46 +01:00
}
2003-10-29 15:20:56 +01:00
/*******************************************************/
2003-08-08 20:02:23 +02:00
2005-06-28 14:55:08 +02:00
/**
2010-06-30 17:38:06 +02:00
* Return TRUE if the stream has accurate duration in any stream .
2005-06-28 14:55:08 +02:00
*
2007-09-05 18:47:48 +02:00
* @ return TRUE if the stream has accurate duration for at least one component .
2005-06-28 14:55:08 +02:00
*/
2011-07-15 20:27:43 +02:00
static int has_duration ( AVFormatContext * ic )
2003-08-08 20:02:23 +02:00
{
int i ;
AVStream * st ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2003-08-08 20:02:23 +02:00
st = ic - > streams [ i ] ;
2007-09-05 18:47:48 +02:00
if ( st - > duration ! = AV_NOPTS_VALUE )
2003-08-08 20:02:23 +02:00
return 1 ;
}
2012-04-25 07:13:02 +02:00
if ( ic - > duration ! = AV_NOPTS_VALUE )
2012-04-13 07:00:57 +02:00
return 1 ;
2003-08-08 20:02:23 +02:00
return 0 ;
}
2005-06-28 14:55:08 +02:00
/**
* Estimate the stream timings from the one of each components .
*
* Also computes the global bitrate if possible .
*/
2011-07-15 20:27:43 +02:00
static void update_stream_timings ( AVFormatContext * ic )
2003-08-08 20:02:23 +02:00
{
2011-05-12 03:40:21 +02:00
int64_t start_time , start_time1 , start_time_text , end_time , end_time1 ;
2011-10-09 14:12:14 +02:00
int64_t duration , duration1 , filesize ;
2003-08-08 20:02:23 +02:00
int i ;
AVStream * st ;
2012-10-23 18:11:26 +02:00
AVProgram * p ;
2003-08-08 20:02:23 +02:00
2006-12-07 01:47:37 +01:00
start_time = INT64_MAX ;
2011-05-12 03:40:21 +02:00
start_time_text = INT64_MAX ;
2014-01-16 01:53:03 +01:00
end_time = INT64_MIN ;
duration = INT64_MIN ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2003-08-08 20:02:23 +02:00
st = ic - > streams [ i ] ;
2008-01-22 00:43:25 +01:00
if ( st - > start_time ! = AV_NOPTS_VALUE & & st - > time_base . den ) {
2014-01-16 01:53:03 +01:00
start_time1 = av_rescale_q ( st - > start_time , st - > time_base ,
AV_TIME_BASE_Q ) ;
2012-06-12 19:07:25 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE | | st - > codec - > codec_type = = AVMEDIA_TYPE_DATA ) {
2011-05-12 03:40:21 +02:00
if ( start_time1 < start_time_text )
start_time_text = start_time1 ;
} else
2012-06-14 18:54:09 +02:00
start_time = FFMIN ( start_time , start_time1 ) ;
2014-01-26 23:35:38 +01:00
end_time1 = AV_NOPTS_VALUE ;
2003-08-08 20:02:23 +02:00
if ( st - > duration ! = AV_NOPTS_VALUE ) {
2014-01-16 01:53:03 +01:00
end_time1 = start_time1 +
av_rescale_q ( st - > duration , st - > time_base ,
AV_TIME_BASE_Q ) ;
2011-10-18 09:17:12 +02:00
end_time = FFMAX ( end_time , end_time1 ) ;
2003-08-08 20:02:23 +02:00
}
2014-01-26 23:35:38 +01:00
for ( p = NULL ; ( p = av_find_program_from_stream ( ic , p , i ) ) ; ) {
if ( p - > start_time = = AV_NOPTS_VALUE | | p - > start_time > start_time1 )
2012-10-23 18:11:26 +02:00
p - > start_time = start_time1 ;
2014-01-26 23:35:38 +01:00
if ( p - > end_time < end_time1 )
2012-10-23 18:11:26 +02:00
p - > end_time = end_time1 ;
}
2003-08-08 20:02:23 +02:00
}
2007-09-05 18:47:48 +02:00
if ( st - > duration ! = AV_NOPTS_VALUE ) {
2014-01-16 01:53:03 +01:00
duration1 = av_rescale_q ( st - > duration , st - > time_base ,
AV_TIME_BASE_Q ) ;
duration = FFMAX ( duration , duration1 ) ;
2007-09-05 18:47:48 +02:00
}
2003-08-08 20:02:23 +02:00
}
2011-05-12 03:40:21 +02:00
if ( start_time = = INT64_MAX | | ( start_time > start_time_text & & start_time - start_time_text < AV_TIME_BASE ) )
start_time = start_time_text ;
2014-01-26 23:35:38 +01:00
else if ( start_time > start_time_text )
2012-06-12 19:28:08 +02:00
av_log ( ic , AV_LOG_VERBOSE , " Ignoring outlier non primary stream starttime %f \n " , start_time_text / ( float ) AV_TIME_BASE ) ;
2006-12-07 01:47:37 +01:00
if ( start_time ! = INT64_MAX ) {
2003-08-08 20:02:23 +02:00
ic - > start_time = start_time ;
2012-10-23 18:11:26 +02:00
if ( end_time ! = INT64_MIN ) {
if ( ic - > nb_programs ) {
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < ic - > nb_programs ; i + + ) {
2012-10-23 18:11:26 +02:00
p = ic - > programs [ i ] ;
2014-01-26 23:35:38 +01:00
if ( p - > start_time ! = AV_NOPTS_VALUE & & p - > end_time > p - > start_time )
2012-10-23 18:11:26 +02:00
duration = FFMAX ( duration , p - > end_time - p - > start_time ) ;
}
} else
duration = FFMAX ( duration , end_time - start_time ) ;
}
2007-09-05 18:47:48 +02:00
}
2012-09-10 16:57:31 +02:00
if ( duration ! = INT64_MIN & & duration > 0 & & ic - > duration = = AV_NOPTS_VALUE ) {
2007-09-05 18:47:48 +02:00
ic - > duration = duration ;
2011-09-13 01:02:48 +02:00
}
2014-01-26 23:35:38 +01:00
if ( ic - > pb & & ( filesize = avio_size ( ic - > pb ) ) > 0 & & ic - > duration ! = AV_NOPTS_VALUE ) {
/* compute the bitrate */
double bitrate = ( double ) filesize * 8.0 * AV_TIME_BASE /
( double ) ic - > duration ;
if ( bitrate > = 0 & & bitrate < = INT_MAX )
ic - > bit_rate = bitrate ;
2003-08-08 20:02:23 +02:00
}
}
static void fill_all_stream_timings ( AVFormatContext * ic )
{
int i ;
AVStream * st ;
2011-07-15 20:27:43 +02:00
update_stream_timings ( ic ) ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2003-08-08 20:02:23 +02:00
st = ic - > streams [ i ] ;
if ( st - > start_time = = AV_NOPTS_VALUE ) {
2014-01-16 01:53:03 +01:00
if ( ic - > start_time ! = AV_NOPTS_VALUE )
st - > start_time = av_rescale_q ( ic - > start_time , AV_TIME_BASE_Q ,
st - > time_base ) ;
if ( ic - > duration ! = AV_NOPTS_VALUE )
st - > duration = av_rescale_q ( ic - > duration , AV_TIME_BASE_Q ,
st - > time_base ) ;
2003-08-08 20:02:23 +02:00
}
}
}
2011-07-15 20:27:43 +02:00
static void estimate_timings_from_bit_rate ( AVFormatContext * ic )
2003-08-08 20:02:23 +02:00
{
int64_t filesize , duration ;
2013-09-03 14:16:42 +02:00
int i , show_warning = 0 ;
2003-08-08 20:02:23 +02:00
AVStream * st ;
/* if bit_rate is already set, we believe it */
2010-12-20 10:58:27 +01:00
if ( ic - > bit_rate < = 0 ) {
2013-08-25 11:53:34 +02:00
int bit_rate = 0 ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2003-08-08 20:02:23 +02:00
st = ic - > streams [ i ] ;
2013-08-24 21:30:46 +02:00
if ( st - > codec - > bit_rate > 0 ) {
2013-09-04 08:55:08 +02:00
if ( INT_MAX - st - > codec - > bit_rate < bit_rate ) {
2013-08-24 21:30:46 +02:00
bit_rate = 0 ;
break ;
}
bit_rate + = st - > codec - > bit_rate ;
}
2003-08-08 20:02:23 +02:00
}
ic - > bit_rate = bit_rate ;
}
/* if duration is already set, we believe it */
2005-12-17 19:14:38 +01:00
if ( ic - > duration = = AV_NOPTS_VALUE & &
2011-10-09 14:12:14 +02:00
ic - > bit_rate ! = 0 ) {
filesize = ic - > pb ? avio_size ( ic - > pb ) : 0 ;
2003-08-08 20:02:23 +02:00
if ( filesize > 0 ) {
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2014-01-26 23:35:38 +01:00
st = ic - > streams [ i ] ;
2013-03-28 01:43:55 +01:00
if ( st - > time_base . num < = INT64_MAX / ic - > bit_rate
& & st - > duration = = AV_NOPTS_VALUE ) {
2014-01-26 23:35:38 +01:00
duration = av_rescale ( 8 * filesize , st - > time_base . den ,
ic - > bit_rate *
( int64_t ) st - > time_base . num ) ;
2003-08-08 20:02:23 +02:00
st - > duration = duration ;
2013-03-30 08:24:51 +01:00
show_warning = 1 ;
2013-03-28 01:43:55 +01:00
}
2003-08-08 20:02:23 +02:00
}
}
}
2013-03-30 08:24:51 +01:00
if ( show_warning )
2014-01-26 23:35:38 +01:00
av_log ( ic , AV_LOG_WARNING ,
" Estimating duration from bitrate, this may be inaccurate \n " ) ;
2003-08-08 20:02:23 +02:00
}
2012-11-06 18:44:14 +01:00
# define DURATION_MAX_READ_SIZE 250000LL
2012-10-23 16:53:48 +02:00
# define DURATION_MAX_RETRY 4
2003-08-08 20:02:23 +02:00
/* only usable for MPEG-PS streams */
2011-07-15 20:27:43 +02:00
static void estimate_timings_from_pts ( AVFormatContext * ic , int64_t old_offset )
2003-08-08 20:02:23 +02:00
{
AVPacket pkt1 , * pkt = & pkt1 ;
AVStream * st ;
int read_size , i , ret ;
2014-05-16 16:13:36 +02:00
int found_duration = 0 ;
int is_end ;
2003-08-08 20:02:23 +02:00
int64_t filesize , offset , duration ;
2014-01-16 01:53:03 +01:00
int retry = 0 ;
2005-12-17 19:14:38 +01:00
2007-04-26 12:49:48 +02:00
/* flush packet queue */
flush_packet_queue ( ic ) ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2007-04-26 12:49:48 +02:00
st = ic - > streams [ i ] ;
2014-02-21 17:27:37 +01:00
if ( st - > start_time = = AV_NOPTS_VALUE & &
st - > first_dts = = AV_NOPTS_VALUE & &
st - > codec - > codec_type ! = AVMEDIA_TYPE_UNKNOWN )
2014-01-16 01:53:03 +01:00
av_log ( st - > codec , AV_LOG_WARNING ,
2014-04-05 01:15:12 +02:00
" start time for stream %d is not set in estimate_timings_from_pts \n " , i ) ;
2009-12-13 23:56:59 +01:00
2007-04-26 12:49:48 +02:00
if ( st - > parser ) {
av_parser_close ( st - > parser ) ;
2014-01-16 01:53:03 +01:00
st - > parser = NULL ;
2007-04-26 12:49:48 +02:00
}
}
2005-12-17 19:14:38 +01:00
2003-08-08 20:02:23 +02:00
/* estimate the end time (duration) */
/* XXX: may need to support wrapping */
2011-10-09 14:12:14 +02:00
filesize = ic - > pb ? avio_size ( ic - > pb ) : 0 ;
2014-01-16 01:53:03 +01:00
do {
2014-05-16 16:13:36 +02:00
is_end = found_duration ;
2014-01-16 01:53:03 +01:00
offset = filesize - ( DURATION_MAX_READ_SIZE < < retry ) ;
2011-08-23 03:47:24 +02:00
if ( offset < 0 )
offset = 0 ;
2003-08-08 20:02:23 +02:00
2011-08-23 03:47:24 +02:00
avio_seek ( ic - > pb , offset , SEEK_SET ) ;
read_size = 0 ;
2014-01-16 01:53:03 +01:00
for ( ; ; ) {
if ( read_size > = DURATION_MAX_READ_SIZE < < ( FFMAX ( retry - 1 , 0 ) ) )
2011-08-23 03:47:24 +02:00
break ;
2005-12-17 19:14:38 +01:00
2011-08-23 03:47:24 +02:00
do {
2012-03-04 21:41:59 +01:00
ret = ff_read_packet ( ic , pkt ) ;
2014-01-16 01:53:03 +01:00
} while ( ret = = AVERROR ( EAGAIN ) ) ;
2011-08-23 03:47:24 +02:00
if ( ret ! = 0 )
break ;
read_size + = pkt - > size ;
2014-01-16 01:53:03 +01:00
st = ic - > streams [ pkt - > stream_index ] ;
2011-08-23 03:47:24 +02:00
if ( pkt - > pts ! = AV_NOPTS_VALUE & &
( st - > start_time ! = AV_NOPTS_VALUE | |
st - > first_dts ! = AV_NOPTS_VALUE ) ) {
2014-05-14 18:25:13 +02:00
duration = pkt - > pts + pkt - > duration ;
2014-05-16 16:13:36 +02:00
found_duration = 1 ;
2011-08-23 03:47:24 +02:00
if ( st - > start_time ! = AV_NOPTS_VALUE )
duration - = st - > start_time ;
else
duration - = st - > first_dts ;
if ( duration > 0 ) {
2014-01-26 23:35:38 +01:00
if ( st - > duration = = AV_NOPTS_VALUE | | st - > info - > last_duration < = 0 | |
2013-03-04 18:01:32 +01:00
( st - > duration < duration & & FFABS ( duration - st - > info - > last_duration ) < 60LL * st - > time_base . den / st - > time_base . num ) )
2011-08-23 03:47:24 +02:00
st - > duration = duration ;
2013-03-04 18:01:32 +01:00
st - > info - > last_duration = duration ;
2011-08-23 03:47:24 +02:00
}
2003-08-08 20:02:23 +02:00
}
2011-08-23 03:47:24 +02:00
av_free_packet ( pkt ) ;
2003-08-08 20:02:23 +02:00
}
2014-05-14 18:25:13 +02:00
/* check if all audio/video streams have valid duration */
2014-05-16 16:13:36 +02:00
if ( ! is_end ) {
is_end = 1 ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
switch ( st - > codec - > codec_type ) {
case AVMEDIA_TYPE_VIDEO :
case AVMEDIA_TYPE_AUDIO :
if ( st - > duration = = AV_NOPTS_VALUE )
is_end = 0 ;
}
2014-05-14 18:25:13 +02:00
}
}
2014-05-16 16:13:36 +02:00
} while ( ! is_end & &
2014-05-16 15:49:23 +02:00
offset & &
2014-01-16 01:53:03 +01:00
+ + retry < = DURATION_MAX_RETRY ) ;
2005-12-17 19:14:38 +01:00
2014-05-14 18:25:13 +02:00
/* warn about audio/video streams which duration could not be estimated */
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > duration = = AV_NOPTS_VALUE ) {
switch ( st - > codec - > codec_type ) {
case AVMEDIA_TYPE_VIDEO :
case AVMEDIA_TYPE_AUDIO :
if ( st - > start_time ! = AV_NOPTS_VALUE | | st - > first_dts ! = AV_NOPTS_VALUE ) {
av_log ( ic , AV_LOG_DEBUG , " stream %d : no PTS found at end of file, duration not set \n " , i ) ;
} else
av_log ( ic , AV_LOG_DEBUG , " stream %d : no TS found at start of file, duration not set \n " , i ) ;
}
}
}
2005-04-30 23:43:59 +02:00
fill_all_stream_timings ( ic ) ;
2003-08-08 20:02:23 +02:00
2011-02-28 14:57:54 +01:00
avio_seek ( ic - > pb , old_offset , SEEK_SET ) ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2014-02-22 14:22:31 +01:00
int j ;
2014-01-16 01:53:03 +01:00
st = ic - > streams [ i ] ;
st - > cur_dts = st - > first_dts ;
2008-02-20 21:24:38 +01:00
st - > last_IP_pts = AV_NOPTS_VALUE ;
2014-03-03 01:55:18 +01:00
st - > last_dts_for_order_check = AV_NOPTS_VALUE ;
2014-02-22 14:22:31 +01:00
for ( j = 0 ; j < MAX_REORDER_DELAY + 1 ; j + + )
st - > pts_buffer [ j ] = AV_NOPTS_VALUE ;
2007-08-18 02:44:14 +02:00
}
2003-08-08 20:02:23 +02:00
}
2011-07-15 20:27:43 +02:00
static void estimate_timings ( AVFormatContext * ic , int64_t old_offset )
2003-08-08 20:02:23 +02:00
{
int64_t file_size ;
/* get the file size, if possible */
if ( ic - > iformat - > flags & AVFMT_NOFILE ) {
file_size = 0 ;
} else {
2011-03-04 19:57:36 +01:00
file_size = avio_size ( ic - > pb ) ;
2011-10-18 09:17:12 +02:00
file_size = FFMAX ( 0 , file_size ) ;
2003-08-08 20:02:23 +02:00
}
2006-07-10 23:14:37 +02:00
if ( ( ! strcmp ( ic - > iformat - > name , " mpeg " ) | |
! strcmp ( ic - > iformat - > name , " mpegts " ) ) & &
2011-03-05 21:06:46 +01:00
file_size & & ic - > pb - > seekable ) {
2003-08-08 20:02:23 +02:00
/* get accurate estimate from the PTSes */
2011-07-15 20:27:43 +02:00
estimate_timings_from_pts ( ic , old_offset ) ;
2012-06-18 07:20:09 +02:00
ic - > duration_estimation_method = AVFMT_DURATION_FROM_PTS ;
2011-07-15 20:27:43 +02:00
} else if ( has_duration ( ic ) ) {
2008-01-16 23:14:26 +01:00
/* at least one component has timings - we use them for all
2014-01-16 01:53:03 +01:00
* the components */
2003-08-08 20:02:23 +02:00
fill_all_stream_timings ( ic ) ;
2012-06-18 07:20:09 +02:00
ic - > duration_estimation_method = AVFMT_DURATION_FROM_STREAM ;
2003-08-08 20:02:23 +02:00
} else {
2008-01-16 23:14:26 +01:00
/* less precise: use bitrate info */
2011-07-15 20:27:43 +02:00
estimate_timings_from_bit_rate ( ic ) ;
2012-06-18 07:20:09 +02:00
ic - > duration_estimation_method = AVFMT_DURATION_FROM_BITRATE ;
2003-08-08 20:02:23 +02:00
}
2011-07-15 20:27:43 +02:00
update_stream_timings ( ic ) ;
2003-08-08 20:02:23 +02:00
{
int i ;
2011-06-03 13:52:29 +02:00
AVStream av_unused * st ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2003-08-08 20:02:23 +02:00
st = ic - > streams [ i ] ;
2011-04-29 17:27:01 +02:00
av_dlog ( ic , " %d: start_time: %0.3f duration: %0.3f \n " , i ,
( double ) st - > start_time / AV_TIME_BASE ,
( double ) st - > duration / AV_TIME_BASE ) ;
2003-08-08 20:02:23 +02:00
}
2014-01-16 01:53:03 +01:00
av_dlog ( ic ,
" stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s \n " ,
2011-04-29 17:27:01 +02:00
( double ) ic - > start_time / AV_TIME_BASE ,
( double ) ic - > duration / AV_TIME_BASE ,
ic - > bit_rate / 1000 ) ;
2003-08-08 20:02:23 +02:00
}
}
2012-07-16 00:27:09 +02:00
static int has_codec_parameters ( AVStream * st , const char * * errmsg_ptr )
2002-05-20 18:28:47 +02:00
{
2012-02-28 00:02:10 +01:00
AVCodecContext * avctx = st - > codec ;
2012-07-16 00:27:09 +02:00
# define FAIL(errmsg) do { \
if ( errmsg_ptr ) \
* errmsg_ptr = errmsg ; \
return 0 ; \
} while ( 0 )
2011-07-16 23:08:29 +02:00
switch ( avctx - > codec_type ) {
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_AUDIO :
2012-03-04 04:06:15 +01:00
if ( ! avctx - > frame_size & & determinable_frame_size ( avctx ) )
2012-09-07 14:27:47 +02:00
FAIL ( " unspecified frame size " ) ;
2014-01-16 01:53:03 +01:00
if ( st - > info - > found_decoder > = 0 & &
avctx - > sample_fmt = = AV_SAMPLE_FMT_NONE )
2012-07-16 00:27:09 +02:00
FAIL ( " unspecified sample format " ) ;
if ( ! avctx - > sample_rate )
FAIL ( " unspecified sample rate " ) ;
if ( ! avctx - > channels )
FAIL ( " unspecified number of channels " ) ;
2012-09-23 04:56:51 +02:00
if ( st - > info - > found_decoder > = 0 & & ! st - > nb_decoded_frames & & avctx - > codec_id = = AV_CODEC_ID_DTS )
FAIL ( " no decodable DTS frames " ) ;
2002-05-20 18:28:47 +02:00
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_VIDEO :
2012-07-16 00:27:09 +02:00
if ( ! avctx - > width )
FAIL ( " unspecified size " ) ;
2012-10-06 12:10:34 +02:00
if ( st - > info - > found_decoder > = 0 & & avctx - > pix_fmt = = AV_PIX_FMT_NONE )
2012-07-16 00:27:09 +02:00
FAIL ( " unspecified pixel format " ) ;
2013-03-03 18:41:16 +01:00
if ( st - > codec - > codec_id = = AV_CODEC_ID_RV30 | | st - > codec - > codec_id = = AV_CODEC_ID_RV40 )
if ( ! st - > sample_aspect_ratio . num & & ! st - > codec - > sample_aspect_ratio . num & & ! st - > codec_info_nb_frames )
FAIL ( " no frame in rv30/40 and no sar " ) ;
2002-05-20 18:28:47 +02:00
break ;
2012-08-07 18:53:00 +02:00
case AVMEDIA_TYPE_SUBTITLE :
if ( avctx - > codec_id = = AV_CODEC_ID_HDMV_PGS_SUBTITLE & & ! avctx - > width )
FAIL ( " unspecified size " ) ;
break ;
2011-08-27 02:39:11 +02:00
case AVMEDIA_TYPE_DATA :
2014-01-26 23:35:38 +01:00
if ( avctx - > codec_id = = AV_CODEC_ID_NONE ) return 1 ;
2002-05-20 18:28:47 +02:00
}
2012-07-16 00:27:09 +02:00
2012-08-07 22:45:46 +02:00
if ( avctx - > codec_id = = AV_CODEC_ID_NONE )
2012-07-16 00:27:09 +02:00
FAIL ( " unknown codec " ) ;
return 1 ;
2002-05-20 18:28:47 +02:00
}
2012-01-18 10:59:32 +01:00
/* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2014-01-26 23:35:38 +01:00
static int try_decode_frame ( AVFormatContext * s , AVStream * st , AVPacket * avpkt ,
2014-01-16 01:53:03 +01:00
AVDictionary * * options )
2003-11-10 19:37:55 +01:00
{
2012-08-18 14:22:38 +02:00
const AVCodec * codec ;
2012-01-02 09:01:02 +01:00
int got_picture = 1 , ret = 0 ;
2013-11-09 10:05:22 +01:00
AVFrame * frame = av_frame_alloc ( ) ;
2012-08-07 18:53:00 +02:00
AVSubtitle subtitle ;
2011-11-02 19:35:36 +01:00
AVPacket pkt = * avpkt ;
2005-12-17 19:14:38 +01:00
2012-09-21 09:09:01 +02:00
if ( ! frame )
return AVERROR ( ENOMEM ) ;
2014-04-21 03:38:07 +02:00
if ( ! avcodec_is_open ( st - > codec ) & &
st - > info - > found_decoder < = 0 & &
( st - > codec - > codec_id ! = - st - > info - > found_decoder | | ! st - > codec - > codec_id ) ) {
2012-01-18 20:32:32 +01:00
AVDictionary * thread_opt = NULL ;
2013-09-28 17:31:46 +02:00
codec = find_decoder ( s , st , st - > codec - > codec_id ) ;
2012-01-28 19:15:15 +01:00
2012-02-28 00:02:10 +01:00
if ( ! codec ) {
2014-04-21 03:38:07 +02:00
st - > info - > found_decoder = - st - > codec - > codec_id ;
2014-01-16 01:53:03 +01:00
ret = - 1 ;
2012-09-21 09:09:01 +02:00
goto fail ;
2012-02-28 00:02:10 +01:00
}
2012-01-18 20:32:32 +01:00
2014-01-16 01:53:03 +01:00
/* Force thread count to 1 since the H.264 decoder will not extract
* SPS and PPS to extradata during multi - threaded decoding . */
2012-01-18 20:32:32 +01:00
av_dict_set ( options ? options : & thread_opt , " threads " , " 1 " , 0 ) ;
ret = avcodec_open2 ( st - > codec , codec , options ? options : & thread_opt ) ;
if ( ! options )
av_dict_free ( & thread_opt ) ;
2012-02-28 00:02:10 +01:00
if ( ret < 0 ) {
2014-04-21 03:38:07 +02:00
st - > info - > found_decoder = - st - > codec - > codec_id ;
2012-09-21 09:09:01 +02:00
goto fail ;
2012-02-28 00:02:10 +01:00
}
st - > info - > found_decoder = 1 ;
} else if ( ! st - > info - > found_decoder )
st - > info - > found_decoder = 1 ;
2012-09-21 09:09:01 +02:00
if ( st - > info - > found_decoder < 0 ) {
ret = - 1 ;
goto fail ;
}
2005-04-25 20:29:06 +02:00
2012-01-02 09:01:02 +01:00
while ( ( pkt . size > 0 | | ( ! pkt . data & & got_picture ) ) & &
ret > = 0 & &
2014-01-26 23:35:38 +01:00
( ! has_codec_parameters ( st , NULL ) | | ! has_decode_delay_been_guessed ( st ) | |
2014-01-16 01:53:03 +01:00
( ! st - > codec_info_nb_frames & &
st - > codec - > codec - > capabilities & CODEC_CAP_CHANNEL_CONF ) ) ) {
2011-11-02 19:35:36 +01:00
got_picture = 0 ;
2014-01-16 01:53:03 +01:00
switch ( st - > codec - > codec_type ) {
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_VIDEO :
2012-09-21 09:09:01 +02:00
ret = avcodec_decode_video2 ( st - > codec , frame ,
2011-11-02 19:35:36 +01:00
& got_picture , & pkt ) ;
2009-04-13 05:32:02 +02:00
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_AUDIO :
2012-09-21 09:09:01 +02:00
ret = avcodec_decode_audio4 ( st - > codec , frame , & got_picture , & pkt ) ;
2009-04-13 05:32:02 +02:00
break ;
2012-08-07 18:53:00 +02:00
case AVMEDIA_TYPE_SUBTITLE :
ret = avcodec_decode_subtitle2 ( st - > codec , & subtitle ,
& got_picture , & pkt ) ;
ret = pkt . size ;
break ;
2009-04-13 05:32:02 +02:00
default :
break ;
}
2011-11-02 19:35:36 +01:00
if ( ret > = 0 ) {
if ( got_picture )
2012-08-04 15:38:05 +02:00
st - > nb_decoded_frames + + ;
2011-11-02 19:35:36 +01:00
pkt . data + = ret ;
pkt . size - = ret ;
2012-01-18 10:59:32 +01:00
ret = got_picture ;
2011-11-02 19:35:36 +01:00
}
2003-11-10 19:37:55 +01:00
}
2012-09-21 09:09:01 +02:00
2014-01-26 23:35:38 +01:00
if ( ! pkt . data & & ! got_picture )
2012-09-25 13:34:06 +02:00
ret = - 1 ;
2012-09-21 09:09:01 +02:00
fail :
2013-11-29 21:41:52 +01:00
av_frame_free ( & frame ) ;
2003-11-10 19:37:55 +01:00
return ret ;
}
2012-08-05 11:11:04 +02:00
unsigned int ff_codec_get_tag ( const AVCodecTag * tags , enum AVCodecID id )
2007-07-11 14:45:14 +02:00
{
2012-08-05 11:11:04 +02:00
while ( tags - > id ! = AV_CODEC_ID_NONE ) {
2007-07-11 14:45:14 +02:00
if ( tags - > id = = id )
return tags - > tag ;
tags + + ;
}
return 0 ;
}
2012-08-05 11:11:04 +02:00
enum AVCodecID ff_codec_get_id ( const AVCodecTag * tags , unsigned int tag )
2007-07-11 14:45:14 +02:00
{
2007-07-27 13:36:17 +02:00
int i ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; tags [ i ] . id ! = AV_CODEC_ID_NONE ; i + + )
if ( tag = = tags [ i ] . tag )
2007-07-27 13:36:17 +02:00
return tags [ i ] . id ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; tags [ i ] . id ! = AV_CODEC_ID_NONE ; i + + )
2011-10-17 10:12:51 +02:00
if ( avpriv_toupper4 ( tag ) = = avpriv_toupper4 ( tags [ i ] . tag ) )
2007-07-27 13:36:17 +02:00
return tags [ i ] . id ;
2012-08-05 11:11:04 +02:00
return AV_CODEC_ID_NONE ;
2007-07-11 14:45:14 +02:00
}
2012-11-27 20:52:38 +01:00
enum AVCodecID ff_get_pcm_codec_id ( int bps , int flt , int be , int sflags )
{
if ( flt ) {
switch ( bps ) {
2014-01-16 01:53:03 +01:00
case 32 :
return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE ;
case 64 :
return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE ;
default :
return AV_CODEC_ID_NONE ;
2012-11-27 20:52:38 +01:00
}
} else {
2012-11-29 13:58:57 +01:00
bps + = 7 ;
2012-11-27 20:52:38 +01:00
bps > > = 3 ;
if ( sflags & ( 1 < < ( bps - 1 ) ) ) {
switch ( bps ) {
2014-01-16 01:53:03 +01:00
case 1 :
return AV_CODEC_ID_PCM_S8 ;
case 2 :
return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE ;
case 3 :
return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE ;
case 4 :
return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE ;
default :
return AV_CODEC_ID_NONE ;
2012-11-27 20:52:38 +01:00
}
} else {
switch ( bps ) {
2014-01-16 01:53:03 +01:00
case 1 :
return AV_CODEC_ID_PCM_U8 ;
case 2 :
return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE ;
case 3 :
return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE ;
case 4 :
return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE ;
default :
return AV_CODEC_ID_NONE ;
2012-11-27 20:52:38 +01:00
}
}
}
}
2014-01-16 01:53:03 +01:00
unsigned int av_codec_get_tag ( const AVCodecTag * const * tags , enum AVCodecID id )
2013-01-17 20:44:33 +01:00
{
unsigned int tag ;
if ( ! av_codec_get_tag2 ( tags , id , & tag ) )
return 0 ;
return tag ;
}
int av_codec_get_tag2 ( const AVCodecTag * const * tags , enum AVCodecID id ,
unsigned int * tag )
2007-07-11 14:45:14 +02:00
{
int i ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; tags & & tags [ i ] ; i + + ) {
2013-01-17 20:44:33 +01:00
const AVCodecTag * codec_tags = tags [ i ] ;
while ( codec_tags - > id ! = AV_CODEC_ID_NONE ) {
if ( codec_tags - > id = = id ) {
* tag = codec_tags - > tag ;
return 1 ;
}
codec_tags + + ;
}
2007-07-11 14:45:14 +02:00
}
return 0 ;
}
2014-01-16 01:53:03 +01:00
enum AVCodecID av_codec_get_id ( const AVCodecTag * const * tags , unsigned int tag )
2007-07-11 14:45:14 +02:00
{
int i ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; tags & & tags [ i ] ; i + + ) {
enum AVCodecID id = ff_codec_get_id ( tags [ i ] , tag ) ;
if ( id ! = AV_CODEC_ID_NONE )
return id ;
2007-07-11 14:45:14 +02:00
}
2012-08-05 11:11:04 +02:00
return AV_CODEC_ID_NONE ;
2007-07-11 14:45:14 +02:00
}
2008-05-24 23:44:29 +02:00
static void compute_chapters_end ( AVFormatContext * s )
{
2011-04-01 03:02:02 +02:00
unsigned int i , j ;
2014-01-16 01:53:03 +01:00
int64_t max_time = s - > duration +
( ( s - > start_time = = AV_NOPTS_VALUE ) ? 0 : s - > start_time ) ;
2008-05-24 23:44:29 +02:00
2011-04-01 03:02:02 +02:00
for ( i = 0 ; i < s - > nb_chapters ; i + + )
2008-05-24 23:44:29 +02:00
if ( s - > chapters [ i ] - > end = = AV_NOPTS_VALUE ) {
2011-04-01 03:02:02 +02:00
AVChapter * ch = s - > chapters [ i ] ;
2014-01-16 01:53:03 +01:00
int64_t end = max_time ? av_rescale_q ( max_time , AV_TIME_BASE_Q ,
ch - > time_base )
: INT64_MAX ;
2011-04-01 03:02:02 +02:00
for ( j = 0 ; j < s - > nb_chapters ; j + + ) {
2014-01-16 01:53:03 +01:00
AVChapter * ch1 = s - > chapters [ j ] ;
int64_t next_start = av_rescale_q ( ch1 - > start , ch1 - > time_base ,
ch - > time_base ) ;
2011-04-01 03:02:02 +02:00
if ( j ! = i & & next_start > ch - > start & & next_start < end )
end = next_start ;
}
ch - > end = ( end = = INT64_MAX ) ? ch - > start : end ;
2008-05-24 23:44:29 +02:00
}
}
2014-01-16 01:53:03 +01:00
static int get_std_framerate ( int i )
{
if ( i < 60 * 12 )
2014-01-26 23:35:38 +01:00
return ( i + 1 ) * 1001 ;
2014-01-16 01:53:03 +01:00
else
2014-01-26 23:35:38 +01:00
return ( ( const int [ ] ) { 24 , 30 , 60 , 12 , 15 , 48 } ) [ i - 60 * 12 ] * 1000 * 12 ;
2006-12-11 17:59:10 +01:00
}
2014-01-16 01:53:03 +01:00
/* Is the time base unreliable?
2007-12-27 01:16:48 +01:00
* This is a heuristic to balance between quick acceptance of the values in
* the headers vs . some extra checks .
2008-01-16 23:14:26 +01:00
* Old DivX and Xvid often have nonsense timebases like 1f ps or 2f ps .
* MPEG - 2 commonly misuses field repeat flags to store different framerates .
2014-01-16 01:53:03 +01:00
* And there are " variable " fps files this needs to detect as well . */
static int tb_unreliable ( AVCodecContext * c )
{
if ( c - > time_base . den > = 101L * c - > time_base . num | |
c - > time_base . den < 5L * c - > time_base . num | |
// c->codec_tag == AV_RL32("DIVX") ||
// c->codec_tag == AV_RL32("XVID") ||
2014-01-26 23:35:38 +01:00
c - > codec_tag = = AV_RL32 ( " mp4v " ) | |
2014-01-16 01:53:03 +01:00
c - > codec_id = = AV_CODEC_ID_MPEG2VIDEO | |
2014-04-28 15:14:41 +02:00
c - > codec_id = = AV_CODEC_ID_GIF | |
2014-01-16 01:53:03 +01:00
c - > codec_id = = AV_CODEC_ID_H264 )
2007-12-27 01:16:48 +01:00
return 1 ;
return 0 ;
}
2012-02-06 17:26:38 +01:00
# if FF_API_FORMAT_PARAMETERS
int av_find_stream_info ( AVFormatContext * ic )
{
return avformat_find_stream_info ( ic , NULL ) ;
}
# endif
2013-10-13 12:19:09 +02:00
int ff_alloc_extradata ( AVCodecContext * avctx , int size )
{
int ret ;
if ( size < 0 | | size > = INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE ) {
avctx - > extradata_size = 0 ;
return AVERROR ( EINVAL ) ;
}
avctx - > extradata = av_malloc ( size + FF_INPUT_BUFFER_PADDING_SIZE ) ;
if ( avctx - > extradata ) {
memset ( avctx - > extradata + size , 0 , FF_INPUT_BUFFER_PADDING_SIZE ) ;
avctx - > extradata_size = size ;
ret = 0 ;
} else {
avctx - > extradata_size = 0 ;
ret = AVERROR ( ENOMEM ) ;
}
return ret ;
}
2013-12-25 16:34:46 +01:00
int ff_get_extradata ( AVCodecContext * avctx , AVIOContext * pb , int size )
{
int ret = ff_alloc_extradata ( avctx , size ) ;
if ( ret < 0 )
return ret ;
ret = avio_read ( pb , avctx - > extradata , size ) ;
if ( ret ! = size ) {
av_freep ( & avctx - > extradata ) ;
avctx - > extradata_size = 0 ;
av_log ( avctx , AV_LOG_ERROR , " Failed to read extradata of size %d \n " , size ) ;
return ret < 0 ? ret : AVERROR_INVALIDDATA ;
}
return ret ;
}
2013-12-05 16:56:17 +01:00
int ff_rfps_add_frame ( AVFormatContext * ic , AVStream * st , int64_t ts )
{
int i , j ;
int64_t last = st - > info - > last_dts ;
2014-01-26 23:35:38 +01:00
if ( ts ! = AV_NOPTS_VALUE & & last ! = AV_NOPTS_VALUE & & ts > last
& & ts - ( uint64_t ) last < INT64_MAX ) {
double dts = ( is_relative ( ts ) ? ts - RELATIVE_TS_BASE : ts ) * av_q2d ( st - > time_base ) ;
int64_t duration = ts - last ;
2013-12-05 16:56:17 +01:00
if ( ! st - > info - > duration_error )
st - > info - > duration_error = av_mallocz ( sizeof ( st - > info - > duration_error [ 0 ] ) * 2 ) ;
if ( ! st - > info - > duration_error )
return AVERROR ( ENOMEM ) ;
2014-01-26 23:35:38 +01:00
// if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2013-12-05 16:56:17 +01:00
// av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < MAX_STD_TIMEBASES ; i + + ) {
2013-12-07 04:13:44 +01:00
if ( st - > info - > duration_error [ 0 ] [ 1 ] [ i ] < 1e10 ) {
2014-01-26 23:35:38 +01:00
int framerate = get_std_framerate ( i ) ;
double sdts = dts * framerate / ( 1001 * 12 ) ;
for ( j = 0 ; j < 2 ; j + + ) {
int64_t ticks = llrint ( sdts + j * 0.5 ) ;
2013-12-07 04:13:44 +01:00
double error = sdts - ticks + j * 0.5 ;
st - > info - > duration_error [ j ] [ 0 ] [ i ] + = error ;
st - > info - > duration_error [ j ] [ 1 ] [ i ] + = error * error ;
}
2013-12-05 16:56:17 +01:00
}
}
st - > info - > duration_count + + ;
2013-12-15 21:40:13 +01:00
st - > info - > rfps_duration_sum + = duration ;
2013-12-07 04:13:44 +01:00
if ( st - > info - > duration_count % 10 = = 0 ) {
int n = st - > info - > duration_count ;
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < MAX_STD_TIMEBASES ; i + + ) {
2013-12-07 04:13:44 +01:00
if ( st - > info - > duration_error [ 0 ] [ 1 ] [ i ] < 1e10 ) {
double a0 = st - > info - > duration_error [ 0 ] [ 0 ] [ i ] / n ;
double error0 = st - > info - > duration_error [ 0 ] [ 1 ] [ i ] / n - a0 * a0 ;
double a1 = st - > info - > duration_error [ 1 ] [ 0 ] [ i ] / n ;
double error1 = st - > info - > duration_error [ 1 ] [ 1 ] [ i ] / n - a1 * a1 ;
if ( error0 > 0.04 & & error1 > 0.04 ) {
st - > info - > duration_error [ 0 ] [ 1 ] [ i ] = 2e10 ;
st - > info - > duration_error [ 1 ] [ 1 ] [ i ] = 2e10 ;
}
}
}
}
2013-12-05 16:56:17 +01:00
// ignore the first 4 values, they might have some random jitter
if ( st - > info - > duration_count > 3 & & is_relative ( ts ) = = is_relative ( last ) )
st - > info - > duration_gcd = av_gcd ( st - > info - > duration_gcd , duration ) ;
}
if ( ts ! = AV_NOPTS_VALUE )
st - > info - > last_dts = ts ;
return 0 ;
}
void ff_rfps_calculate ( AVFormatContext * ic )
{
int i , j ;
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2013-12-05 16:56:17 +01:00
AVStream * st = ic - > streams [ i ] ;
if ( st - > codec - > codec_type ! = AVMEDIA_TYPE_VIDEO )
continue ;
// the check for tb_unreliable() is not completely correct, since this is not about handling
// a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
// ipmovie.c produces.
if ( tb_unreliable ( st - > codec ) & & st - > info - > duration_count > 15 & & st - > info - > duration_gcd > FFMAX ( 1 , st - > time_base . den / ( 500LL * st - > time_base . num ) ) & & ! st - > r_frame_rate . num )
av_reduce ( & st - > r_frame_rate . num , & st - > r_frame_rate . den , st - > time_base . den , st - > time_base . num * st - > info - > duration_gcd , INT_MAX ) ;
if ( st - > info - > duration_count > 1 & & ! st - > r_frame_rate . num
& & tb_unreliable ( st - > codec ) ) {
int num = 0 ;
double best_error = 0.01 ;
2014-04-28 15:40:23 +02:00
AVRational ref_rate = st - > r_frame_rate . num ? st - > r_frame_rate : av_inv_q ( st - > time_base ) ;
2013-12-05 16:56:17 +01:00
2014-01-26 23:35:38 +01:00
for ( j = 0 ; j < MAX_STD_TIMEBASES ; j + + ) {
2013-12-05 16:56:17 +01:00
int k ;
2014-01-26 23:35:38 +01:00
if ( st - > info - > codec_info_duration & & st - > info - > codec_info_duration * av_q2d ( st - > time_base ) < ( 1001 * 12.0 ) / get_std_framerate ( j ) )
2013-12-05 16:56:17 +01:00
continue ;
2014-01-26 23:35:38 +01:00
if ( ! st - > info - > codec_info_duration & & 1.0 < ( 1001 * 12.0 ) / get_std_framerate ( j ) )
2013-12-05 16:56:17 +01:00
continue ;
2013-12-15 21:40:13 +01:00
if ( av_q2d ( st - > time_base ) * st - > info - > rfps_duration_sum / st - > info - > duration_count < ( 1001 * 12.0 * 0.8 ) / get_std_framerate ( j ) )
continue ;
2014-01-26 23:35:38 +01:00
for ( k = 0 ; k < 2 ; k + + ) {
int n = st - > info - > duration_count ;
2013-12-05 16:56:17 +01:00
double a = st - > info - > duration_error [ k ] [ 0 ] [ j ] / n ;
double error = st - > info - > duration_error [ k ] [ 1 ] [ j ] / n - a * a ;
2014-01-26 23:35:38 +01:00
if ( error < best_error & & best_error > 0.000000001 ) {
2013-12-05 16:56:17 +01:00
best_error = error ;
num = get_std_framerate ( j ) ;
}
2014-01-26 23:35:38 +01:00
if ( error < 0.02 )
2013-12-05 16:56:17 +01:00
av_log ( NULL , AV_LOG_DEBUG , " rfps: %f %f \n " , get_std_framerate ( j ) / 12.0 / 1001 , error ) ;
}
}
// do not increase frame rate by more than 1 % in order to match a standard rate.
2014-04-28 15:40:23 +02:00
if ( num & & ( ! ref_rate . num | | ( double ) num / ( 12 * 1001 ) < 1.01 * av_q2d ( ref_rate ) ) )
2013-12-05 16:56:17 +01:00
av_reduce ( & st - > r_frame_rate . num , & st - > r_frame_rate . den , num , 12 * 1001 , INT_MAX ) ;
}
2014-04-28 18:04:38 +02:00
if ( ! st - > avg_frame_rate . num
& & st - > r_frame_rate . num & & st - > info - > rfps_duration_sum
& & st - > info - > codec_info_duration < = 0
& & st - > info - > duration_count > 2
& & fabs ( 1.0 / ( av_q2d ( st - > r_frame_rate ) * av_q2d ( st - > time_base ) ) - st - > info - > rfps_duration_sum / ( double ) st - > info - > duration_count ) < = 1.0
) {
av_log ( ic , AV_LOG_DEBUG , " Setting avg frame rate based on r frame rate \n " ) ;
st - > avg_frame_rate = st - > r_frame_rate ;
}
2013-12-05 16:56:17 +01:00
av_freep ( & st - > info - > duration_error ) ;
st - > info - > last_dts = AV_NOPTS_VALUE ;
st - > info - > duration_count = 0 ;
2013-12-15 21:40:13 +01:00
st - > info - > rfps_duration_sum = 0 ;
2013-12-05 16:56:17 +01:00
}
}
2011-05-22 19:24:59 +02:00
int avformat_find_stream_info ( AVFormatContext * ic , AVDictionary * * options )
2002-05-20 18:28:47 +02:00
{
2013-07-02 15:00:28 +02:00
int i , count , ret = 0 , j ;
2013-03-20 17:23:23 +01:00
int64_t read_size ;
2002-05-20 18:28:47 +02:00
AVStream * st ;
2003-11-10 19:37:55 +01:00
AVPacket pkt1 , * pkt ;
2014-01-16 01:53:03 +01:00
int64_t old_offset = avio_tell ( ic - > pb ) ;
// new streams might appear, no options for those
int orig_nb_streams = ic - > nb_streams ;
2014-01-26 23:35:38 +01:00
int flush_codecs = ic - > probesize > 0 ;
2007-03-02 14:23:06 +01:00
2014-01-26 23:35:38 +01:00
if ( ic - > pb )
2013-12-05 16:06:24 +01:00
av_log ( ic , AV_LOG_DEBUG , " Before avformat_find_stream_info() pos: % " PRId64 " bytes read:% " PRId64 " seeks:%d \n " ,
avio_tell ( ic - > pb ) , ic - > pb - > bytes_read , ic - > pb - > seek_count ) ;
2012-04-14 10:43:35 +02:00
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2012-08-18 14:22:38 +02:00
const AVCodec * codec ;
2012-01-18 20:32:32 +01:00
AVDictionary * thread_opt = NULL ;
2005-04-30 23:43:59 +02:00
st = ic - > streams [ i ] ;
2011-06-28 08:39:12 +02:00
2010-11-17 00:50:18 +01:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO | |
st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2014-01-26 23:35:38 +01:00
/* if (!st->time_base.num)
st - > time_base = */
if ( ! st - > codec - > time_base . num )
st - > codec - > time_base = st - > time_base ;
2005-04-30 23:43:59 +02:00
}
2014-01-16 01:53:03 +01:00
// only for the split stuff
2010-03-31 14:55:16 +02:00
if ( ! st - > parser & & ! ( ic - > flags & AVFMT_FLAG_NOPARSE ) ) {
2005-07-18 00:24:36 +02:00
st - > parser = av_parser_init ( st - > codec - > codec_id ) ;
2014-01-26 23:35:38 +01:00
if ( st - > parser ) {
if ( st - > need_parsing = = AVSTREAM_PARSE_HEADERS ) {
2012-05-21 14:32:24 +02:00
st - > parser - > flags | = PARSER_FLAG_COMPLETE_FRAMES ;
2014-01-26 23:35:38 +01:00
} else if ( st - > need_parsing = = AVSTREAM_PARSE_FULL_RAW ) {
2012-05-21 14:32:24 +02:00
st - > parser - > flags | = PARSER_FLAG_USE_CODEC_TS ;
}
2012-06-07 19:02:32 +02:00
} else if ( st - > need_parsing ) {
av_log ( ic , AV_LOG_VERBOSE , " parser not found for codec "
" %s, packets or times may be invalid. \n " ,
avcodec_get_name ( st - > codec - > codec_id ) ) ;
2005-08-15 17:58:21 +02:00
}
2005-06-27 02:04:03 +02:00
}
2013-09-28 17:31:46 +02:00
codec = find_decoder ( ic , st , st - > codec - > codec_id ) ;
2010-10-03 00:18:02 +02:00
2014-01-16 01:53:03 +01:00
/* Force thread count to 1 since the H.264 decoder will not extract
* SPS and PPS to extradata during multi - threaded decoding . */
2012-01-18 20:32:32 +01:00
av_dict_set ( options ? & options [ i ] : & thread_opt , " threads " , " 1 " , 0 ) ;
2012-01-07 15:36:44 +01:00
2010-11-13 14:57:49 +01:00
/* Ensure that subtitle_header is properly set. */
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE
2013-12-11 20:30:21 +01:00
& & codec & & ! st - > codec - > codec ) {
if ( avcodec_open2 ( st - > codec , codec , options ? & options [ i ] : & thread_opt ) < 0 )
2014-01-26 23:35:38 +01:00
av_log ( ic , AV_LOG_WARNING ,
" Failed to open codec in av_find_stream_info \n " ) ;
2013-12-11 20:30:21 +01:00
}
2010-11-13 14:57:49 +01:00
2014-01-16 01:53:03 +01:00
// Try to just open decoders, in case this is enough to get parameters.
2012-09-23 04:49:59 +02:00
if ( ! has_codec_parameters ( st , NULL ) & & st - > request_probe < = 0 ) {
2010-11-13 14:57:49 +01:00
if ( codec & & ! st - > codec - > codec )
2013-12-11 20:30:21 +01:00
if ( avcodec_open2 ( st - > codec , codec , options ? & options [ i ] : & thread_opt ) < 0 )
2014-01-26 23:35:38 +01:00
av_log ( ic , AV_LOG_WARNING ,
" Failed to open codec in av_find_stream_info \n " ) ;
2010-02-04 00:05:58 +01:00
}
2012-01-18 20:32:32 +01:00
if ( ! options )
av_dict_free ( & thread_opt ) ;
2005-04-30 23:43:59 +02:00
}
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2012-06-26 13:10:01 +02:00
# if FF_API_R_FRAME_RATE
2010-10-09 00:01:19 +02:00
ic - > streams [ i ] - > info - > last_dts = AV_NOPTS_VALUE ;
2012-06-26 13:10:01 +02:00
# endif
2012-06-28 15:49:51 +02:00
ic - > streams [ i ] - > info - > fps_first_dts = AV_NOPTS_VALUE ;
ic - > streams [ i ] - > info - > fps_last_dts = AV_NOPTS_VALUE ;
2004-12-19 02:23:22 +01:00
}
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
count = 0 ;
2002-05-20 18:28:47 +02:00
read_size = 0 ;
2014-01-16 01:53:03 +01:00
for ( ; ; ) {
if ( ff_check_interrupt ( & ic - > interrupt_callback ) ) {
ret = AVERROR_EXIT ;
2009-06-18 02:22:08 +02:00
av_log ( ic , AV_LOG_DEBUG , " interrupted \n " ) ;
2009-02-23 03:38:45 +01:00
break ;
}
2002-05-20 18:28:47 +02:00
/* check if one codec still needs to be handled */
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2011-02-28 01:20:56 +01:00
int fps_analyze_framecount = 20 ;
2002-05-20 18:28:47 +02:00
st = ic - > streams [ i ] ;
2012-07-16 00:27:09 +02:00
if ( ! has_codec_parameters ( st , NULL ) )
2002-05-20 18:28:47 +02:00
break ;
2014-01-16 01:53:03 +01:00
/* If the timebase is coarse (like the usual millisecond precision
* of mkv ) , we need to analyze more frames to reliably arrive at
* the correct fps . */
2011-02-28 01:20:56 +01:00
if ( av_q2d ( st - > time_base ) > 0.0005 )
fps_analyze_framecount * = 2 ;
2014-04-28 16:28:41 +02:00
if ( ! tb_unreliable ( st - > codec ) )
fps_analyze_framecount = 0 ;
2011-05-09 23:34:23 +02:00
if ( ic - > fps_probe_size > = 0 )
fps_analyze_framecount = ic - > fps_probe_size ;
2013-02-15 02:17:39 +01:00
if ( st - > disposition & AV_DISPOSITION_ATTACHED_PIC )
fps_analyze_framecount = 0 ;
2004-12-21 03:16:11 +01:00
/* variable fps and no guess at the real fps */
2014-04-28 16:28:41 +02:00
if ( ! ( st - > r_frame_rate . num & & st - > avg_frame_rate . num ) & &
2014-01-26 23:35:38 +01:00
st - > info - > duration_count < fps_analyze_framecount & &
2014-01-16 01:53:03 +01:00
st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO )
2004-12-21 03:16:11 +01:00
break ;
2014-01-16 01:53:03 +01:00
if ( st - > parser & & st - > parser - > parser - > split & &
! st - > codec - > extradata )
2005-06-27 02:04:03 +02:00
break ;
2011-09-11 00:33:20 +02:00
if ( st - > first_dts = = AV_NOPTS_VALUE & &
( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO | |
st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) )
2007-08-05 00:46:13 +02:00
break ;
2002-05-20 18:28:47 +02:00
}
if ( i = = ic - > nb_streams ) {
2014-01-16 01:53:03 +01:00
/* NOTE: If the format has no header, then we need to read some
* packets to get most of the streams , so we cannot stop here . */
2003-11-10 19:37:55 +01:00
if ( ! ( ic - > ctx_flags & AVFMTCTX_NOHEADER ) ) {
2014-01-16 01:53:03 +01:00
/* If we found the info for all the codecs, we can stop. */
2002-05-20 18:28:47 +02:00
ret = count ;
2009-06-18 02:22:08 +02:00
av_log ( ic , AV_LOG_DEBUG , " All info found \n " ) ;
2012-01-06 11:51:12 +01:00
flush_codecs = 0 ;
2002-05-20 18:28:47 +02:00
break ;
}
2006-09-26 19:25:28 +02:00
}
2014-01-16 01:53:03 +01:00
/* We did not get all the codec info, but we read too much data. */
2009-06-25 21:10:27 +02:00
if ( read_size > = ic - > probesize ) {
2006-09-26 19:27:08 +02:00
ret = count ;
2014-01-16 01:53:03 +01:00
av_log ( ic , AV_LOG_DEBUG ,
2014-01-26 23:35:38 +01:00
" Probe buffer size limit of %d bytes reached \n " , ic - > probesize ) ;
2012-04-21 12:05:23 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + )
if ( ! ic - > streams [ i ] - > r_frame_rate . num & &
2013-09-17 00:08:12 +02:00
ic - > streams [ i ] - > info - > duration_count < = 1 & &
2014-02-21 17:27:20 +01:00
ic - > streams [ i ] - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & &
2013-09-17 00:08:12 +02:00
strcmp ( ic - > iformat - > name , " image2 " ) )
2012-04-21 12:05:23 +02:00
av_log ( ic , AV_LOG_WARNING ,
" Stream #%d: not enough frames to estimate rate; "
" consider increasing probesize \n " , i ) ;
2006-09-26 19:27:08 +02:00
break ;
}
2002-05-20 18:28:47 +02:00
2014-01-16 01:53:03 +01:00
/* NOTE: A new stream can be added there if no header in file
* ( AVFMTCTX_NOHEADER ) . */
2011-07-15 20:27:43 +02:00
ret = read_frame_internal ( ic , & pkt1 ) ;
2011-06-29 22:50:21 +02:00
if ( ret = = AVERROR ( EAGAIN ) )
continue ;
if ( ret < 0 ) {
2012-01-02 09:01:02 +01:00
/* EOF or error*/
2003-11-10 19:37:55 +01:00
break ;
}
2013-08-07 01:14:45 +02:00
if ( ic - > flags & AVFMT_FLAG_NOBUFFER )
free_packet_buffer ( & ic - > packet_buffer , & ic - > packet_buffer_end ) ;
{
2012-07-27 01:35:12 +02:00
pkt = add_to_pktbuf ( & ic - > packet_buffer , & pkt1 ,
& ic - > packet_buffer_end ) ;
2013-07-10 14:57:15 +02:00
if ( ! pkt ) {
ret = AVERROR ( ENOMEM ) ;
2013-07-10 02:51:41 +02:00
goto find_stream_info_err ;
2013-07-10 14:57:15 +02:00
}
2012-07-27 01:35:12 +02:00
if ( ( ret = av_dup_packet ( pkt ) ) < 0 )
goto find_stream_info_err ;
}
2002-05-20 18:28:47 +02:00
st = ic - > streams [ pkt - > stream_index ] ;
2013-11-18 03:02:36 +01:00
if ( ! ( st - > disposition & AV_DISPOSITION_ATTACHED_PIC ) )
read_size + = pkt - > size ;
2012-06-28 15:49:51 +02:00
if ( pkt - > dts ! = AV_NOPTS_VALUE & & st - > codec_info_nb_frames > 1 ) {
/* check for non-increasing dts */
if ( st - > info - > fps_last_dts ! = AV_NOPTS_VALUE & &
st - > info - > fps_last_dts > = pkt - > dts ) {
2014-01-26 23:35:38 +01:00
av_log ( ic , AV_LOG_DEBUG ,
2014-01-16 01:53:03 +01:00
" Non-increasing DTS in stream %d: packet %d with DTS "
" % " PRId64 " , packet %d with DTS % " PRId64 " \n " ,
st - > index , st - > info - > fps_last_dts_idx ,
st - > info - > fps_last_dts , st - > codec_info_nb_frames ,
pkt - > dts ) ;
st - > info - > fps_first_dts =
st - > info - > fps_last_dts = AV_NOPTS_VALUE ;
2012-06-28 15:49:51 +02:00
}
2014-01-16 01:53:03 +01:00
/* Check for a discontinuity in dts. If the difference in dts
* is more than 1000 times the average packet duration in the
* sequence , we treat it as a discontinuity . */
2012-08-11 20:24:40 +02:00
if ( st - > info - > fps_last_dts ! = AV_NOPTS_VALUE & &
st - > info - > fps_last_dts_idx > st - > info - > fps_first_dts_idx & &
( pkt - > dts - st - > info - > fps_last_dts ) / 1000 >
2014-01-16 01:53:03 +01:00
( st - > info - > fps_last_dts - st - > info - > fps_first_dts ) /
( st - > info - > fps_last_dts_idx - st - > info - > fps_first_dts_idx ) ) {
av_log ( ic , AV_LOG_WARNING ,
" DTS discontinuity in stream %d: packet %d with DTS "
" % " PRId64 " , packet %d with DTS % " PRId64 " \n " ,
st - > index , st - > info - > fps_last_dts_idx ,
st - > info - > fps_last_dts , st - > codec_info_nb_frames ,
pkt - > dts ) ;
st - > info - > fps_first_dts =
st - > info - > fps_last_dts = AV_NOPTS_VALUE ;
2012-08-11 20:24:40 +02:00
}
2012-06-28 15:49:51 +02:00
/* update stored dts values */
if ( st - > info - > fps_first_dts = = AV_NOPTS_VALUE ) {
st - > info - > fps_first_dts = pkt - > dts ;
st - > info - > fps_first_dts_idx = st - > codec_info_nb_frames ;
}
2014-01-16 01:53:03 +01:00
st - > info - > fps_last_dts = pkt - > dts ;
2012-06-28 15:49:51 +02:00
st - > info - > fps_last_dts_idx = st - > codec_info_nb_frames ;
2012-07-29 22:58:17 +02:00
}
2010-10-09 00:01:19 +02:00
if ( st - > codec_info_nb_frames > 1 ) {
2014-01-26 23:35:38 +01:00
int64_t t = 0 ;
2014-05-26 21:54:27 +02:00
int max_analyze_duration = ic - > max_analyze_duration ;
if ( ! max_analyze_duration )
max_analyze_duration = 5 * AV_TIME_BASE ;
2012-01-05 00:49:02 +01:00
if ( st - > time_base . den > 0 )
t = av_rescale_q ( st - > info - > codec_info_duration , st - > time_base , AV_TIME_BASE_Q ) ;
if ( st - > avg_frame_rate . num > 0 )
2012-08-05 23:25:27 +02:00
t = FFMAX ( t , av_rescale_q ( st - > codec_info_nb_frames , av_inv_q ( st - > avg_frame_rate ) , AV_TIME_BASE_Q ) ) ;
2012-01-05 00:49:02 +01:00
2014-01-26 23:35:38 +01:00
if ( t = = 0
2013-07-08 02:19:28 +02:00
& & st - > codec_info_nb_frames > 30
2013-07-07 15:03:12 +02:00
& & st - > info - > fps_first_dts ! = AV_NOPTS_VALUE
& & st - > info - > fps_last_dts ! = AV_NOPTS_VALUE )
t = FFMAX ( t , av_rescale_q ( st - > info - > fps_last_dts - st - > info - > fps_first_dts , st - > time_base , AV_TIME_BASE_Q ) ) ;
2014-05-26 21:54:27 +02:00
if ( t > = max_analyze_duration ) {
2014-03-12 02:04:41 +01:00
av_log ( ic , AV_LOG_VERBOSE , " max_analyze_duration %d reached at % " PRId64 " microseconds \n " ,
2014-05-26 21:54:27 +02:00
max_analyze_duration ,
2014-03-12 02:04:41 +01:00
t ) ;
2009-03-19 22:54:34 +01:00
break ;
2009-06-18 02:22:08 +02:00
}
2012-10-14 18:53:05 +02:00
if ( pkt - > duration ) {
st - > info - > codec_info_duration + = pkt - > duration ;
2014-01-26 23:35:38 +01:00
st - > info - > codec_info_duration_fields + = st - > parser & & st - > need_parsing & & st - > codec - > ticks_per_frame = = 2 ? st - > parser - > repeat_pict + 1 : 2 ;
2012-10-14 18:53:05 +02:00
}
2009-03-19 22:54:34 +01:00
}
2012-06-26 13:10:01 +02:00
# if FF_API_R_FRAME_RATE
2013-12-05 16:56:17 +01:00
ff_rfps_add_frame ( ic , st , pkt - > dts ) ;
2012-06-26 13:10:01 +02:00
# endif
2014-01-16 01:53:03 +01:00
if ( st - > parser & & st - > parser - > parser - > split & & ! st - > codec - > extradata ) {
int i = st - > parser - > parser - > split ( st - > codec , pkt - > data , pkt - > size ) ;
2012-01-12 20:12:24 +01:00
if ( i > 0 & & i < FF_MAX_EXTRADATA_SIZE ) {
2013-10-13 12:30:59 +02:00
if ( ff_alloc_extradata ( st - > codec , i ) )
2012-01-12 20:12:24 +01:00
return AVERROR ( ENOMEM ) ;
2014-01-16 01:53:03 +01:00
memcpy ( st - > codec - > extradata , pkt - > data ,
st - > codec - > extradata_size ) ;
2005-06-27 02:04:03 +02:00
}
}
2005-12-17 19:14:38 +01:00
2014-01-16 01:53:03 +01:00
/* If still no information, we try to open the codec and to
* decompress the frame . We try to avoid that in most cases as
* it takes longer and uses more memory . For MPEG - 4 , we need to
* decompress for QuickTime .
*
* If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
* least one frame of codec data , this makes sure the codec initializes
* the channel configuration and does not only trust the values from
* the container . */
2014-01-26 23:35:38 +01:00
try_decode_frame ( ic , st , pkt ,
2014-01-16 01:53:03 +01:00
( options & & i < orig_nb_streams ) ? & options [ i ] : NULL ) ;
2005-12-17 19:14:38 +01:00
2010-07-03 05:15:37 +02:00
st - > codec_info_nb_frames + + ;
2002-05-20 18:28:47 +02:00
count + + ;
}
2012-01-06 11:51:12 +01:00
if ( flush_codecs ) {
AVPacket empty_pkt = { 0 } ;
2012-03-06 03:56:25 +01:00
int err = 0 ;
2012-01-06 11:51:12 +01:00
av_init_packet ( & empty_pkt ) ;
2014-01-26 23:35:38 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2012-07-16 00:27:09 +02:00
2012-01-06 11:51:12 +01:00
st = ic - > streams [ i ] ;
/* flush the decoders */
2012-03-06 03:56:25 +01:00
if ( st - > info - > found_decoder = = 1 ) {
do {
2013-09-28 17:31:46 +02:00
err = try_decode_frame ( ic , st , & empty_pkt ,
2014-01-26 23:35:38 +01:00
( options & & i < orig_nb_streams )
? & options [ i ] : NULL ) ;
2012-07-16 00:27:09 +02:00
} while ( err > 0 & & ! has_codec_parameters ( st , NULL ) ) ;
2012-03-06 03:56:25 +01:00
if ( err < 0 ) {
av_log ( ic , AV_LOG_INFO ,
" decoding for stream %d failed \n " , st - > index ) ;
}
2012-01-27 01:42:53 +01:00
}
2012-01-06 11:51:12 +01:00
}
}
2008-03-15 17:15:47 +01:00
// close codecs which were opened in try_decode_frame()
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2005-06-27 22:54:36 +02:00
st = ic - > streams [ i ] ;
2011-12-08 06:57:44 +01:00
avcodec_close ( st - > codec ) ;
2005-06-27 22:54:36 +02:00
}
2013-12-05 16:56:17 +01:00
ff_rfps_calculate ( ic ) ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2002-05-20 18:28:47 +02:00
st = ic - > streams [ i ] ;
2010-03-31 01:30:55 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2014-01-26 23:35:38 +01:00
if ( st - > codec - > codec_id = = AV_CODEC_ID_RAWVIDEO & & ! st - > codec - > codec_tag & & ! st - > codec - > bits_per_coded_sample ) {
2011-03-09 15:12:24 +01:00
uint32_t tag = avcodec_pix_fmt_to_codec_tag ( st - > codec - > pix_fmt ) ;
2013-01-12 14:08:42 +01:00
if ( avpriv_find_pix_fmt ( ff_raw_pix_fmt_tags , tag ) = = st - > codec - > pix_fmt )
2011-03-09 15:12:24 +01:00
st - > codec - > codec_tag = tag ;
}
2004-12-19 02:23:22 +01:00
2012-07-29 22:58:17 +02:00
/* estimate average framerate if not set by demuxer */
2014-01-26 23:35:38 +01:00
if ( st - > info - > codec_info_duration_fields & &
! st - > avg_frame_rate . num & &
st - > info - > codec_info_duration ) {
2014-01-16 01:53:03 +01:00
int best_fps = 0 ;
2012-07-27 14:04:07 +02:00
double best_error = 0.01 ;
2012-06-28 15:49:51 +02:00
2013-07-16 00:39:33 +02:00
if ( st - > info - > codec_info_duration > = INT64_MAX / st - > time_base . num / 2 | |
2013-09-23 14:13:43 +02:00
st - > info - > codec_info_duration_fields > = INT64_MAX / st - > time_base . den | |
st - > info - > codec_info_duration < 0 )
2013-07-15 15:44:20 +02:00
continue ;
2012-03-13 21:45:05 +01:00
av_reduce ( & st - > avg_frame_rate . num , & st - > avg_frame_rate . den ,
2014-01-26 23:35:38 +01:00
st - > info - > codec_info_duration_fields * ( int64_t ) st - > time_base . den ,
st - > info - > codec_info_duration * 2 * ( int64_t ) st - > time_base . num , 60000 ) ;
2012-07-27 14:04:07 +02:00
2014-01-16 01:53:03 +01:00
/* Round guessed framerate to a "standard" framerate if it's
* within 1 % of the original estimate . */
2014-01-29 15:12:48 +01:00
for ( j = 0 ; j < MAX_STD_TIMEBASES ; j + + ) {
2014-01-16 01:53:03 +01:00
AVRational std_fps = { get_std_framerate ( j ) , 12 * 1001 } ;
double error = fabs ( av_q2d ( st - > avg_frame_rate ) /
av_q2d ( std_fps ) - 1 ) ;
2012-07-27 14:04:07 +02:00
if ( error < best_error ) {
best_error = error ;
best_fps = std_fps . num ;
}
}
2014-01-16 01:53:03 +01:00
if ( best_fps )
2012-07-27 14:04:07 +02:00
av_reduce ( & st - > avg_frame_rate . num , & st - > avg_frame_rate . den ,
2014-01-16 01:53:03 +01:00
best_fps , 12 * 1001 , INT_MAX ) ;
2012-06-28 15:49:51 +02:00
}
2004-12-19 02:23:22 +01:00
2014-01-26 23:35:38 +01:00
if ( ! st - > r_frame_rate . num ) {
if ( st - > codec - > time_base . den * ( int64_t ) st - > time_base . num
< = st - > codec - > time_base . num * st - > codec - > ticks_per_frame * ( int64_t ) st - > time_base . den ) {
2006-10-03 21:13:27 +02:00
st - > r_frame_rate . num = st - > codec - > time_base . den ;
2009-02-27 00:47:32 +01:00
st - > r_frame_rate . den = st - > codec - > time_base . num * st - > codec - > ticks_per_frame ;
2014-01-26 23:35:38 +01:00
} else {
2006-10-03 21:13:27 +02:00
st - > r_frame_rate . num = st - > time_base . den ;
st - > r_frame_rate . den = st - > time_base . num ;
}
2003-03-12 16:16:19 +01:00
}
2014-01-16 01:53:03 +01:00
} else if ( st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
if ( ! st - > codec - > bits_per_coded_sample )
st - > codec - > bits_per_coded_sample =
av_get_bits_per_sample ( st - > codec - > codec_id ) ;
2011-03-24 17:09:02 +01:00
// set stream disposition based on audio service type
switch ( st - > codec - > audio_service_type ) {
case AV_AUDIO_SERVICE_TYPE_EFFECTS :
2014-01-16 01:53:03 +01:00
st - > disposition = AV_DISPOSITION_CLEAN_EFFECTS ;
break ;
2011-03-24 17:09:02 +01:00
case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED :
2014-01-16 01:53:03 +01:00
st - > disposition = AV_DISPOSITION_VISUAL_IMPAIRED ;
break ;
2011-03-24 17:09:02 +01:00
case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED :
2014-01-16 01:53:03 +01:00
st - > disposition = AV_DISPOSITION_HEARING_IMPAIRED ;
break ;
2011-03-24 17:09:02 +01:00
case AV_AUDIO_SERVICE_TYPE_COMMENTARY :
2014-01-16 01:53:03 +01:00
st - > disposition = AV_DISPOSITION_COMMENT ;
break ;
2011-03-24 17:09:02 +01:00
case AV_AUDIO_SERVICE_TYPE_KARAOKE :
2014-01-16 01:53:03 +01:00
st - > disposition = AV_DISPOSITION_KARAOKE ;
break ;
2011-03-24 17:09:02 +01:00
}
2002-05-20 18:28:47 +02:00
}
2001-07-22 16:18:56 +02:00
}
2002-05-20 18:28:47 +02:00
2014-01-26 23:35:38 +01:00
if ( ic - > probesize )
2011-07-15 20:27:43 +02:00
estimate_timings ( ic , old_offset ) ;
2007-04-12 10:11:33 +02:00
2013-07-02 15:06:43 +02:00
if ( ret > = 0 & & ic - > nb_streams )
2014-01-26 23:35:38 +01:00
/* We could not have all the codec parameters before EOF. */
ret = - 1 ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2013-06-20 09:34:15 +02:00
const char * errmsg ;
st = ic - > streams [ i ] ;
if ( ! has_codec_parameters ( st , & errmsg ) ) {
char buf [ 256 ] ;
avcodec_string ( buf , sizeof ( buf ) , st - > codec , 0 ) ;
av_log ( ic , AV_LOG_WARNING ,
" Could not find codec parameters for stream %d (%s): %s \n "
" Consider increasing the value for the 'analyzeduration' and 'probesize' options \n " ,
i , buf , errmsg ) ;
} else {
ret = 0 ;
}
}
2008-05-24 23:44:29 +02:00
compute_chapters_end ( ic ) ;
2014-01-16 01:53:03 +01:00
find_stream_info_err :
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
2013-02-23 22:25:49 +01:00
st = ic - > streams [ i ] ;
2014-01-06 15:34:45 +01:00
if ( ic - > streams [ i ] - > codec - > codec_type ! = AVMEDIA_TYPE_AUDIO )
2011-12-25 11:45:05 +01:00
ic - > streams [ i ] - > codec - > thread_count = 0 ;
2013-02-23 22:25:49 +01:00
if ( st - > info )
av_freep ( & st - > info - > duration_error ) ;
2010-10-09 00:01:19 +02:00
av_freep ( & ic - > streams [ i ] - > info ) ;
2011-12-25 11:45:05 +01:00
}
2014-01-26 23:35:38 +01:00
if ( ic - > pb )
2013-12-05 16:06:24 +01:00
av_log ( ic , AV_LOG_DEBUG , " After avformat_find_stream_info() pos: % " PRId64 " bytes read:% " PRId64 " seeks:%d frames:%d \n " ,
avio_tell ( ic - > pb ) , ic - > pb - > bytes_read , ic - > pb - > seek_count , count ) ;
2002-05-20 18:28:47 +02:00
return ret ;
2001-07-22 16:18:56 +02:00
}
2011-08-22 23:42:19 +02:00
AVProgram * av_find_program_from_stream ( AVFormatContext * ic , AVProgram * last , int s )
2010-12-27 10:08:20 +01:00
{
int i , j ;
2011-08-22 23:42:19 +02:00
for ( i = 0 ; i < ic - > nb_programs ; i + + ) {
if ( ic - > programs [ i ] = = last ) {
last = NULL ;
} else {
if ( ! last )
for ( j = 0 ; j < ic - > programs [ i ] - > nb_stream_indexes ; j + + )
if ( ic - > programs [ i ] - > stream_index [ j ] = = s )
return ic - > programs [ i ] ;
}
}
2010-12-27 10:08:20 +01:00
return NULL ;
}
2014-01-16 01:53:03 +01:00
int av_find_best_stream ( AVFormatContext * ic , enum AVMediaType type ,
int wanted_stream_nb , int related_stream ,
AVCodec * * decoder_ret , int flags )
2010-12-27 10:08:20 +01:00
{
2011-02-20 01:18:30 +01:00
int i , nb_streams = ic - > nb_streams ;
2012-11-18 13:19:14 +01:00
int ret = AVERROR_STREAM_NOT_FOUND , best_count = - 1 , best_bitrate = - 1 , best_multiframe = - 1 , count , bitrate , multiframe ;
2010-12-27 10:08:20 +01:00
unsigned * program = NULL ;
2014-05-07 05:52:58 +02:00
const AVCodec * decoder = NULL , * best_decoder = NULL ;
2010-12-27 10:08:20 +01:00
if ( related_stream > = 0 & & wanted_stream_nb < 0 ) {
2011-08-22 23:42:19 +02:00
AVProgram * p = av_find_program_from_stream ( ic , NULL , related_stream ) ;
2010-12-27 10:08:20 +01:00
if ( p ) {
2014-01-16 01:53:03 +01:00
program = p - > stream_index ;
2010-12-27 10:08:20 +01:00
nb_streams = p - > nb_stream_indexes ;
}
}
for ( i = 0 ; i < nb_streams ; i + + ) {
2011-02-20 01:18:30 +01:00
int real_stream_index = program ? program [ i ] : i ;
2014-01-16 01:53:03 +01:00
AVStream * st = ic - > streams [ real_stream_index ] ;
2010-12-27 10:08:20 +01:00
AVCodecContext * avctx = st - > codec ;
if ( avctx - > codec_type ! = type )
continue ;
2011-02-20 01:18:30 +01:00
if ( wanted_stream_nb > = 0 & & real_stream_index ! = wanted_stream_nb )
2010-12-27 10:08:20 +01:00
continue ;
2014-02-04 23:59:47 +01:00
if ( wanted_stream_nb ! = real_stream_index & &
st - > disposition & ( AV_DISPOSITION_HEARING_IMPAIRED |
2014-01-16 01:53:03 +01:00
AV_DISPOSITION_VISUAL_IMPAIRED ) )
2011-02-10 07:25:40 +01:00
continue ;
2014-01-16 00:36:27 +01:00
if ( type = = AVMEDIA_TYPE_AUDIO & & ! avctx - > channels )
continue ;
2010-12-27 10:08:20 +01:00
if ( decoder_ret ) {
2013-09-28 17:31:46 +02:00
decoder = find_decoder ( ic , st , st - > codec - > codec_id ) ;
2010-12-27 10:08:20 +01:00
if ( ! decoder ) {
if ( ret < 0 )
ret = AVERROR_DECODER_NOT_FOUND ;
continue ;
}
}
2012-11-18 13:19:14 +01:00
count = st - > codec_info_nb_frames ;
bitrate = avctx - > bit_rate ;
multiframe = FFMIN ( 5 , count ) ;
if ( ( best_multiframe > multiframe ) | |
( best_multiframe = = multiframe & & best_bitrate > bitrate ) | |
( best_multiframe = = multiframe & & best_bitrate = = bitrate & & best_count > = count ) )
2010-12-27 10:08:20 +01:00
continue ;
2014-01-26 23:35:38 +01:00
best_count = count ;
2012-11-18 13:19:14 +01:00
best_bitrate = bitrate ;
best_multiframe = multiframe ;
2014-01-16 01:53:03 +01:00
ret = real_stream_index ;
2010-12-27 10:08:20 +01:00
best_decoder = decoder ;
if ( program & & i = = nb_streams - 1 & & ret < 0 ) {
2014-01-16 01:53:03 +01:00
program = NULL ;
2010-12-27 10:08:20 +01:00
nb_streams = ic - > nb_streams ;
2014-01-16 01:53:03 +01:00
/* no related stream found, try again with everything */
i = 0 ;
2010-12-27 10:08:20 +01:00
}
}
if ( decoder_ret )
2014-05-07 05:52:58 +02:00
* decoder_ret = ( AVCodec * ) best_decoder ;
2010-12-27 10:08:20 +01:00
return ret ;
}
2003-11-10 19:37:55 +01:00
/*******************************************************/
int av_read_play ( AVFormatContext * s )
{
2007-12-17 10:28:46 +01:00
if ( s - > iformat - > read_play )
return s - > iformat - > read_play ( s ) ;
2007-12-20 01:25:18 +01:00
if ( s - > pb )
2011-04-12 09:37:10 +02:00
return avio_pause ( s - > pb , 0 ) ;
2007-12-17 10:28:46 +01:00
return AVERROR ( ENOSYS ) ;
2003-11-10 19:37:55 +01:00
}
int av_read_pause ( AVFormatContext * s )
{
2007-12-17 10:28:46 +01:00
if ( s - > iformat - > read_pause )
return s - > iformat - > read_pause ( s ) ;
2007-12-20 01:25:18 +01:00
if ( s - > pb )
2011-04-12 09:37:10 +02:00
return avio_pause ( s - > pb , 1 ) ;
2007-12-17 10:28:46 +01:00
return AVERROR ( ENOSYS ) ;
2003-11-10 19:37:55 +01:00
}
2014-01-26 23:35:38 +01:00
void ff_free_stream ( AVFormatContext * s , AVStream * st ) {
2014-03-24 13:41:49 +01:00
int j ;
2012-08-21 06:13:54 +02:00
av_assert0 ( s - > nb_streams > 0 ) ;
2014-01-26 23:35:38 +01:00
av_assert0 ( s - > streams [ s - > nb_streams - 1 ] = = st ) ;
2014-03-24 13:41:49 +01:00
for ( j = 0 ; j < st - > nb_side_data ; j + + )
av_freep ( & st - > side_data [ j ] . data ) ;
av_freep ( & st - > side_data ) ;
st - > nb_side_data = 0 ;
2012-08-21 06:13:54 +02:00
if ( st - > parser ) {
av_parser_close ( st - > parser ) ;
}
if ( st - > attached_pic . data )
av_free_packet ( & st - > attached_pic ) ;
av_dict_free ( & st - > metadata ) ;
2013-04-04 13:09:54 +02:00
av_freep ( & st - > probe_data . buf ) ;
2012-08-21 06:13:54 +02:00
av_freep ( & st - > index_entries ) ;
av_freep ( & st - > codec - > extradata ) ;
av_freep ( & st - > codec - > subtitle_header ) ;
av_freep ( & st - > codec ) ;
av_freep ( & st - > priv_data ) ;
2013-02-23 22:25:49 +01:00
if ( st - > info )
av_freep ( & st - > info - > duration_error ) ;
2012-08-21 06:13:54 +02:00
av_freep ( & st - > info ) ;
av_freep ( & s - > streams [ - - s - > nb_streams ] ) ;
}
2011-02-04 11:04:16 +01:00
void avformat_free_context ( AVFormatContext * s )
{
int i ;
2012-10-20 19:48:26 +02:00
if ( ! s )
return ;
2011-06-05 13:18:17 +02:00
av_opt_free ( s ) ;
2011-06-06 13:14:05 +02:00
if ( s - > iformat & & s - > iformat - > priv_class & & s - > priv_data )
2011-06-05 13:18:17 +02:00
av_opt_free ( s - > priv_data ) ;
2014-04-09 22:43:48 +02:00
if ( s - > oformat & & s - > oformat - > priv_class & & s - > priv_data )
av_opt_free ( s - > priv_data ) ;
2011-06-05 13:18:17 +02:00
2014-01-26 23:35:38 +01:00
for ( i = s - > nb_streams - 1 ; i > = 0 ; i - - ) {
2012-08-21 06:13:54 +02:00
ff_free_stream ( s , s - > streams [ i ] ) ;
2001-07-22 16:18:56 +02:00
}
2014-01-16 01:53:03 +01:00
for ( i = s - > nb_programs - 1 ; i > = 0 ; i - - ) {
2011-05-22 12:46:29 +02:00
av_dict_free ( & s - > programs [ i ] - > metadata ) ;
2007-10-20 10:25:13 +02:00
av_freep ( & s - > programs [ i ] - > stream_index ) ;
2007-09-25 22:45:46 +02:00
av_freep ( & s - > programs [ i ] ) ;
}
2008-04-25 01:09:28 +02:00
av_freep ( & s - > programs ) ;
2002-05-24 04:09:40 +02:00
av_freep ( & s - > priv_data ) ;
2014-01-16 01:53:03 +01:00
while ( s - > nb_chapters - - ) {
2011-05-22 12:46:29 +02:00
av_dict_free ( & s - > chapters [ s - > nb_chapters ] - > metadata ) ;
2011-10-01 01:29:30 +02:00
av_freep ( & s - > chapters [ s - > nb_chapters ] ) ;
2008-05-23 00:00:21 +02:00
}
av_freep ( & s - > chapters ) ;
2011-05-22 12:46:29 +02:00
av_dict_free ( & s - > metadata ) ;
2011-04-20 11:03:55 +02:00
av_freep ( & s - > streams ) ;
2014-01-20 13:59:06 +01:00
av_freep ( & s - > internal ) ;
2002-05-19 01:11:09 +02:00
av_free ( s ) ;
2001-07-22 16:18:56 +02:00
}
2011-12-11 10:34:08 +01:00
# if FF_API_CLOSE_INPUT_FILE
2007-12-19 15:07:13 +01:00
void av_close_input_file ( AVFormatContext * s )
{
2011-12-11 10:34:08 +01:00
avformat_close_input ( & s ) ;
}
# endif
void avformat_close_input ( AVFormatContext * * ps )
{
2013-09-03 22:22:19 +02:00
AVFormatContext * s ;
AVIOContext * pb ;
if ( ! ps | | ! * ps )
return ;
2014-01-26 23:35:38 +01:00
s = * ps ;
2013-09-03 22:22:19 +02:00
pb = s - > pb ;
2012-09-04 16:05:28 +02:00
2012-09-15 20:16:32 +02:00
if ( ( s - > iformat & & s - > iformat - > flags & AVFMT_NOFILE ) | |
2012-09-04 16:05:28 +02:00
( s - > flags & AVFMT_FLAG_CUSTOM_IO ) )
pb = NULL ;
2011-12-11 10:01:46 +01:00
flush_packet_queue ( s ) ;
2012-09-04 16:05:28 +02:00
2014-01-16 01:53:03 +01:00
if ( s - > iformat )
2012-09-04 16:05:28 +02:00
if ( s - > iformat - > read_close )
s - > iformat - > read_close ( s ) ;
2011-12-11 10:01:46 +01:00
avformat_free_context ( s ) ;
2012-09-04 16:05:28 +02:00
2011-12-11 10:34:08 +01:00
* ps = NULL ;
2012-09-10 07:07:56 +02:00
avio_close ( pb ) ;
2007-12-19 15:07:13 +01:00
}
2012-02-06 17:21:46 +01:00
# if FF_API_NEW_STREAM
AVStream * av_new_stream ( AVFormatContext * s , int id )
{
AVStream * st = avformat_new_stream ( s , NULL ) ;
if ( st )
st - > id = id ;
return st ;
}
# endif
2012-10-24 16:29:05 +02:00
AVStream * avformat_new_stream ( AVFormatContext * s , const AVCodec * c )
2002-05-20 18:28:47 +02:00
{
AVStream * st ;
2006-08-30 23:18:17 +02:00
int i ;
2013-09-11 12:13:44 +02:00
AVStream * * streams ;
2002-05-20 18:28:47 +02:00
2013-09-11 12:13:44 +02:00
if ( s - > nb_streams > = INT_MAX / sizeof ( * streams ) )
2010-10-06 22:56:14 +02:00
return NULL ;
2013-09-11 13:34:25 +02:00
streams = av_realloc_array ( s - > streams , s - > nb_streams + 1 , sizeof ( * streams ) ) ;
2013-09-11 12:13:44 +02:00
if ( ! streams )
return NULL ;
s - > streams = streams ;
2002-05-20 18:28:47 +02:00
st = av_mallocz ( sizeof ( AVStream ) ) ;
if ( ! st )
return NULL ;
2010-10-09 00:01:19 +02:00
if ( ! ( st - > info = av_mallocz ( sizeof ( * st - > info ) ) ) ) {
av_free ( st ) ;
return NULL ;
}
2012-03-07 21:41:54 +01:00
st - > info - > last_dts = AV_NOPTS_VALUE ;
2005-12-17 19:14:38 +01:00
2011-06-18 11:19:27 +02:00
st - > codec = avcodec_alloc_context3 ( c ) ;
2014-01-16 01:53:03 +01:00
if ( s - > iformat )
2003-08-08 20:13:43 +02:00
/* no default bitrate if decoding */
2005-07-18 00:24:36 +02:00
st - > codec - > bit_rate = 0 ;
2014-01-16 01:53:03 +01:00
st - > index = s - > nb_streams ;
2003-08-08 20:02:23 +02:00
st - > start_time = AV_NOPTS_VALUE ;
2014-01-16 01:53:03 +01:00
st - > duration = AV_NOPTS_VALUE ;
/* we set the current DTS to 0 so that formats without any timestamps
* but durations get some timestamps , formats with some unknown
* timestamps have their first few packets buffered and the
* timestamps corrected before they are returned to the user */
2014-01-26 23:35:38 +01:00
st - > cur_dts = s - > iformat ? RELATIVE_TS_BASE : 0 ;
2014-01-16 01:53:03 +01:00
st - > first_dts = AV_NOPTS_VALUE ;
2009-05-31 02:24:06 +02:00
st - > probe_packets = MAX_PROBE_PACKETS ;
2012-12-02 19:27:21 +01:00
st - > pts_wrap_reference = AV_NOPTS_VALUE ;
st - > pts_wrap_behavior = AV_PTS_WRAP_IGNORE ;
2004-05-21 22:43:21 +02:00
2008-01-16 23:14:26 +01:00
/* default pts setting is MPEG-like */
2011-11-29 19:28:15 +01:00
avpriv_set_pts_info ( st , 33 , 1 , 90000 ) ;
2008-02-20 21:24:38 +01:00
st - > last_IP_pts = AV_NOPTS_VALUE ;
2014-03-03 01:55:18 +01:00
st - > last_dts_for_order_check = AV_NOPTS_VALUE ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < MAX_REORDER_DELAY + 1 ; i + + )
st - > pts_buffer [ i ] = AV_NOPTS_VALUE ;
2004-05-21 22:43:21 +02:00
2014-01-16 01:53:03 +01:00
st - > sample_aspect_ratio = ( AVRational ) { 0 , 1 } ;
2008-08-24 01:13:58 +02:00
2012-08-11 19:06:08 +02:00
# if FF_API_R_FRAME_RATE
st - > info - > last_dts = AV_NOPTS_VALUE ;
# endif
st - > info - > fps_first_dts = AV_NOPTS_VALUE ;
st - > info - > fps_last_dts = AV_NOPTS_VALUE ;
2014-04-13 19:20:17 +02:00
st - > inject_global_side_data = s - > internal - > inject_global_side_data ;
2002-05-20 18:28:47 +02:00
s - > streams [ s - > nb_streams + + ] = st ;
return st ;
}
2007-09-25 22:45:46 +02:00
AVProgram * av_new_program ( AVFormatContext * ac , int id )
{
2014-01-16 01:53:03 +01:00
AVProgram * program = NULL ;
2007-09-25 22:45:46 +02:00
int i ;
2011-06-07 13:18:12 +02:00
av_dlog ( ac , " new_program: id=0x%04x \n " , id ) ;
2007-09-25 22:45:46 +02:00
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ac - > nb_programs ; i + + )
if ( ac - > programs [ i ] - > id = = id )
2007-09-25 22:45:46 +02:00
program = ac - > programs [ i ] ;
2014-01-16 01:53:03 +01:00
if ( ! program ) {
2007-09-25 22:45:46 +02:00
program = av_mallocz ( sizeof ( AVProgram ) ) ;
if ( ! program )
return NULL ;
dynarray_add ( & ac - > programs , & ac - > nb_programs , program ) ;
program - > discard = AVDISCARD_NONE ;
}
program - > id = id ;
2012-12-02 19:27:21 +01:00
program - > pts_wrap_reference = AV_NOPTS_VALUE ;
program - > pts_wrap_behavior = AV_PTS_WRAP_IGNORE ;
2007-09-25 22:45:46 +02:00
2012-10-23 18:11:26 +02:00
program - > start_time =
program - > end_time = AV_NOPTS_VALUE ;
2007-09-25 22:45:46 +02:00
return program ;
}
2014-01-16 01:53:03 +01:00
AVChapter * avpriv_new_chapter ( AVFormatContext * s , int id , AVRational time_base ,
int64_t start , int64_t end , const char * title )
2008-05-23 00:00:21 +02:00
{
2008-05-23 15:02:27 +02:00
AVChapter * chapter = NULL ;
int i ;
2014-05-23 04:33:05 +02:00
if ( end ! = AV_NOPTS_VALUE & & start > end ) {
av_log ( s , AV_LOG_ERROR , " Chapter end time % " PRId64 " before start % " PRId64 " \n " , end , start ) ;
return NULL ;
}
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < s - > nb_chapters ; i + + )
if ( s - > chapters [ i ] - > id = = id )
2008-05-23 15:02:27 +02:00
chapter = s - > chapters [ i ] ;
2014-01-16 01:53:03 +01:00
if ( ! chapter ) {
chapter = av_mallocz ( sizeof ( AVChapter ) ) ;
if ( ! chapter )
2008-05-23 15:14:11 +02:00
return NULL ;
2008-05-23 15:07:58 +02:00
dynarray_add ( & s - > chapters , & s - > nb_chapters , chapter ) ;
2008-05-23 15:02:27 +02:00
}
2011-05-22 12:46:29 +02:00
av_dict_set ( & chapter - > metadata , " title " , title , 0 ) ;
2014-01-16 01:53:03 +01:00
chapter - > id = id ;
chapter - > time_base = time_base ;
chapter - > start = start ;
chapter - > end = end ;
2008-05-23 00:00:21 +02:00
2008-05-23 15:14:11 +02:00
return chapter ;
2008-05-23 00:00:21 +02:00
}
2007-09-25 22:45:46 +02:00
2014-01-16 01:53:03 +01:00
void ff_program_add_stream_index ( AVFormatContext * ac , int progid , unsigned idx )
2007-10-20 10:25:13 +02:00
{
int i , j ;
2014-01-16 01:53:03 +01:00
AVProgram * program = NULL ;
2013-09-11 12:13:44 +02:00
void * tmp ;
2007-10-20 10:25:13 +02:00
2009-10-19 20:55:27 +02:00
if ( idx > = ac - > nb_streams ) {
av_log ( ac , AV_LOG_ERROR , " stream index %d is not valid \n " , idx ) ;
return ;
}
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ac - > nb_programs ; i + + ) {
if ( ac - > programs [ i ] - > id ! = progid )
2007-10-20 10:25:13 +02:00
continue ;
program = ac - > programs [ i ] ;
2014-01-16 01:53:03 +01:00
for ( j = 0 ; j < program - > nb_stream_indexes ; j + + )
if ( program - > stream_index [ j ] = = idx )
2007-10-20 10:25:13 +02:00
return ;
2013-09-11 13:34:25 +02:00
tmp = av_realloc_array ( program - > stream_index , program - > nb_stream_indexes + 1 , sizeof ( unsigned int ) ) ;
2014-01-26 23:35:38 +01:00
if ( ! tmp )
2007-10-20 10:25:13 +02:00
return ;
2013-09-11 12:13:44 +02:00
program - > stream_index = tmp ;
2007-10-20 10:25:13 +02:00
program - > stream_index [ program - > nb_stream_indexes + + ] = idx ;
return ;
}
}
2014-01-16 01:53:03 +01:00
static void print_fps ( double d , const char * postfix )
{
uint64_t v = lrintf ( d * 100 ) ;
if ( v % 100 )
av_log ( NULL , AV_LOG_INFO , " , %3.2f %s " , d , postfix ) ;
else if ( v % ( 100 * 1000 ) )
av_log ( NULL , AV_LOG_INFO , " , %1.0f %s " , d , postfix ) ;
else
av_log ( NULL , AV_LOG_INFO , " , %1.0fk %s " , d / 1000 , postfix ) ;
2009-02-22 00:00:07 +01:00
}
2011-05-22 12:46:29 +02:00
static void dump_metadata ( void * ctx , AVDictionary * m , const char * indent )
2009-12-14 00:19:24 +01:00
{
2014-01-16 01:53:03 +01:00
if ( m & & ! ( av_dict_count ( m ) = = 1 & & av_dict_get ( m , " language " , NULL , 0 ) ) ) {
AVDictionaryEntry * tag = NULL ;
2009-12-14 00:19:24 +01:00
av_log ( ctx , AV_LOG_INFO , " %sMetadata: \n " , indent ) ;
2014-01-16 01:53:03 +01:00
while ( ( tag = av_dict_get ( m , " " , tag , AV_DICT_IGNORE_SUFFIX ) ) )
2014-01-26 23:35:38 +01:00
if ( strcmp ( " language " , tag - > key ) ) {
2012-02-10 02:39:14 +01:00
const char * p = tag - > value ;
2014-01-16 01:53:03 +01:00
av_log ( ctx , AV_LOG_INFO ,
2014-01-26 23:35:38 +01:00
" %s %-16s: " , indent , tag - > key ) ;
while ( * p ) {
2012-02-10 02:39:14 +01:00
char tmp [ 256 ] ;
2012-08-08 21:13:15 +02:00
size_t len = strcspn ( p , " \ x8 \ xa \ xb \ xc \ xd " ) ;
2012-02-10 02:39:14 +01:00
av_strlcpy ( tmp , p , FFMIN ( sizeof ( tmp ) , len + 1 ) ) ;
av_log ( ctx , AV_LOG_INFO , " %s " , tmp ) ;
p + = len ;
if ( * p = = 0xd ) av_log ( ctx , AV_LOG_INFO , " " ) ;
if ( * p = = 0xa ) av_log ( ctx , AV_LOG_INFO , " \n %s %-16s: " , indent , " " ) ;
if ( * p ) p + + ;
}
av_log ( ctx , AV_LOG_INFO , " \n " ) ;
2011-06-19 20:32:37 +02:00
}
2009-12-14 00:19:24 +01:00
}
}
2001-07-22 16:18:56 +02:00
/* "user interface" functions */
2014-01-16 01:53:03 +01:00
static void dump_stream_format ( AVFormatContext * ic , int i ,
int index , int is_output )
2007-10-20 10:17:01 +02:00
{
2007-10-22 01:10:15 +02:00
char buf [ 256 ] ;
2007-10-20 10:17:01 +02:00
int flags = ( is_output ? ic - > oformat - > flags : ic - > iformat - > flags ) ;
AVStream * st = ic - > streams [ i ] ;
2009-01-17 12:13:33 +01:00
int g = av_gcd ( st - > time_base . num , st - > time_base . den ) ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * lang = av_dict_get ( st - > metadata , " language " , NULL , 0 ) ;
2007-10-20 10:17:01 +02:00
avcodec_string ( buf , sizeof ( buf ) , st - > codec , is_output ) ;
2011-09-23 10:16:36 +02:00
av_log ( NULL , AV_LOG_INFO , " Stream #%d:%d " , index , i ) ;
2007-10-20 10:17:01 +02:00
/* the pid is an important information, so we display it */
/* XXX: add a generic system */
if ( flags & AVFMT_SHOW_IDS )
av_log ( NULL , AV_LOG_INFO , " [0x%x] " , st - > id ) ;
2009-03-01 16:38:06 +01:00
if ( lang )
av_log ( NULL , AV_LOG_INFO , " (%s) " , lang - > value ) ;
2014-01-16 01:53:03 +01:00
av_log ( NULL , AV_LOG_DEBUG , " , %d, %d/%d " , st - > codec_info_nb_frames ,
st - > time_base . num / g , st - > time_base . den / g ) ;
2007-10-20 10:17:01 +02:00
av_log ( NULL , AV_LOG_INFO , " : %s " , buf ) ;
2009-01-22 20:45:53 +01:00
if ( st - > sample_aspect_ratio . num & & // default
av_cmp_q ( st - > sample_aspect_ratio , st - > codec - > sample_aspect_ratio ) ) {
AVRational display_aspect_ratio ;
av_reduce ( & display_aspect_ratio . num , & display_aspect_ratio . den ,
2014-01-16 01:53:03 +01:00
st - > codec - > width * st - > sample_aspect_ratio . num ,
st - > codec - > height * st - > sample_aspect_ratio . den ,
1024 * 1024 ) ;
2011-07-27 10:35:08 +02:00
av_log ( NULL , AV_LOG_INFO , " , SAR %d:%d DAR %d:%d " ,
2014-01-16 01:53:03 +01:00
st - > sample_aspect_ratio . num , st - > sample_aspect_ratio . den ,
display_aspect_ratio . num , display_aspect_ratio . den ) ;
2009-01-22 20:45:53 +01:00
}
2014-01-16 01:53:03 +01:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
if ( st - > avg_frame_rate . den & & st - > avg_frame_rate . num )
2009-12-13 16:52:11 +01:00
print_fps ( av_q2d ( st - > avg_frame_rate ) , " fps " ) ;
2012-06-26 13:10:01 +02:00
# if FF_API_R_FRAME_RATE
2014-01-26 23:35:38 +01:00
if ( st - > r_frame_rate . den & & st - > r_frame_rate . num )
2009-02-22 00:00:07 +01:00
print_fps ( av_q2d ( st - > r_frame_rate ) , " tbr " ) ;
2012-06-26 13:10:01 +02:00
# endif
2014-01-16 01:53:03 +01:00
if ( st - > time_base . den & & st - > time_base . num )
print_fps ( 1 / av_q2d ( st - > time_base ) , " tbn " ) ;
if ( st - > codec - > time_base . den & & st - > codec - > time_base . num )
print_fps ( 1 / av_q2d ( st - > codec - > time_base ) , " tbc " ) ;
2007-10-20 10:17:01 +02:00
}
2011-02-12 19:11:11 +01:00
if ( st - > disposition & AV_DISPOSITION_DEFAULT )
av_log ( NULL , AV_LOG_INFO , " (default) " ) ;
if ( st - > disposition & AV_DISPOSITION_DUB )
av_log ( NULL , AV_LOG_INFO , " (dub) " ) ;
if ( st - > disposition & AV_DISPOSITION_ORIGINAL )
av_log ( NULL , AV_LOG_INFO , " (original) " ) ;
if ( st - > disposition & AV_DISPOSITION_COMMENT )
av_log ( NULL , AV_LOG_INFO , " (comment) " ) ;
if ( st - > disposition & AV_DISPOSITION_LYRICS )
av_log ( NULL , AV_LOG_INFO , " (lyrics) " ) ;
if ( st - > disposition & AV_DISPOSITION_KARAOKE )
av_log ( NULL , AV_LOG_INFO , " (karaoke) " ) ;
if ( st - > disposition & AV_DISPOSITION_FORCED )
av_log ( NULL , AV_LOG_INFO , " (forced) " ) ;
if ( st - > disposition & AV_DISPOSITION_HEARING_IMPAIRED )
av_log ( NULL , AV_LOG_INFO , " (hearing impaired) " ) ;
if ( st - > disposition & AV_DISPOSITION_VISUAL_IMPAIRED )
av_log ( NULL , AV_LOG_INFO , " (visual impaired) " ) ;
2011-02-14 19:43:38 +01:00
if ( st - > disposition & AV_DISPOSITION_CLEAN_EFFECTS )
av_log ( NULL , AV_LOG_INFO , " (clean effects) " ) ;
2007-10-20 10:17:01 +02:00
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2009-12-14 00:27:43 +01:00
dump_metadata ( NULL , st - > metadata , " " ) ;
2007-10-20 10:17:01 +02:00
}
2001-07-22 16:18:56 +02:00
2014-01-16 01:53:03 +01:00
void av_dump_format ( AVFormatContext * ic , int index ,
const char * url , int is_output )
2001-07-22 16:18:56 +02:00
{
2007-10-25 12:11:15 +02:00
int i ;
2011-09-30 19:30:35 +02:00
uint8_t * printed = ic - > nb_streams ? av_mallocz ( ic - > nb_streams ) : NULL ;
2009-10-19 04:12:10 +02:00
if ( ic - > nb_streams & & ! printed )
return ;
2001-07-22 16:18:56 +02:00
2005-12-17 19:14:38 +01:00
av_log ( NULL , AV_LOG_INFO , " %s #%d, %s, %s '%s': \n " ,
2014-01-16 01:53:03 +01:00
is_output ? " Output " : " Input " ,
index ,
is_output ? ic - > oformat - > name : ic - > iformat - > name ,
is_output ? " to " : " from " , url ) ;
2009-12-14 00:34:46 +01:00
dump_metadata ( NULL , ic - > metadata , " " ) ;
2003-08-08 20:02:23 +02:00
if ( ! is_output ) {
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " Duration: " ) ;
2003-08-08 20:02:23 +02:00
if ( ic - > duration ! = AV_NOPTS_VALUE ) {
int hours , mins , secs , us ;
2012-10-31 18:48:58 +01:00
int64_t duration = ic - > duration + 5000 ;
2014-01-26 23:35:38 +01:00
secs = duration / AV_TIME_BASE ;
us = duration % AV_TIME_BASE ;
2014-01-16 01:53:03 +01:00
mins = secs / 60 ;
2003-08-08 20:02:23 +02:00
secs % = 60 ;
hours = mins / 60 ;
mins % = 60 ;
2008-04-16 08:46:54 +02:00
av_log ( NULL , AV_LOG_INFO , " %02d:%02d:%02d.%02d " , hours , mins , secs ,
( 100 * us ) / AV_TIME_BASE ) ;
2003-08-08 20:02:23 +02:00
} else {
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " N/A " ) ;
2003-08-08 20:02:23 +02:00
}
2004-10-11 19:12:52 +02:00
if ( ic - > start_time ! = AV_NOPTS_VALUE ) {
int secs , us ;
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " , start: " ) ;
2004-10-11 19:12:52 +02:00
secs = ic - > start_time / AV_TIME_BASE ;
2014-01-16 01:53:03 +01:00
us = abs ( ic - > start_time % AV_TIME_BASE ) ;
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " %d.%06d " ,
2014-01-16 01:53:03 +01:00
secs , ( int ) av_rescale ( us , 1000000 , AV_TIME_BASE ) ) ;
2004-10-11 19:12:52 +02:00
}
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " , bitrate: " ) ;
2014-01-16 01:53:03 +01:00
if ( ic - > bit_rate )
av_log ( NULL , AV_LOG_INFO , " %d kb/s " , ic - > bit_rate / 1000 ) ;
else
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " N/A " ) ;
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2003-08-08 20:02:23 +02:00
}
2010-02-28 19:37:09 +01:00
for ( i = 0 ; i < ic - > nb_chapters ; i + + ) {
AVChapter * ch = ic - > chapters [ i ] ;
av_log ( NULL , AV_LOG_INFO , " Chapter #%d.%d: " , index , i ) ;
2014-01-16 01:53:03 +01:00
av_log ( NULL , AV_LOG_INFO ,
" start %f, " , ch - > start * av_q2d ( ch - > time_base ) ) ;
av_log ( NULL , AV_LOG_INFO ,
" end %f \n " , ch - > end * av_q2d ( ch - > time_base ) ) ;
2010-02-28 19:37:09 +01:00
dump_metadata ( NULL , ch - > metadata , " " ) ;
}
2014-01-16 01:53:03 +01:00
if ( ic - > nb_programs ) {
2009-10-19 04:12:10 +02:00
int j , k , total = 0 ;
2014-01-16 01:53:03 +01:00
for ( j = 0 ; j < ic - > nb_programs ; j + + ) {
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * name = av_dict_get ( ic - > programs [ j ] - > metadata ,
2009-03-01 16:38:06 +01:00
" name " , NULL , 0 ) ;
2007-10-26 22:02:11 +02:00
av_log ( NULL , AV_LOG_INFO , " Program %d %s \n " , ic - > programs [ j ] - > id ,
2009-03-01 16:38:06 +01:00
name ? name - > value : " " ) ;
2009-12-14 00:27:43 +01:00
dump_metadata ( NULL , ic - > programs [ j ] - > metadata , " " ) ;
2014-01-16 01:53:03 +01:00
for ( k = 0 ; k < ic - > programs [ j ] - > nb_stream_indexes ; k + + ) {
dump_stream_format ( ic , ic - > programs [ j ] - > stream_index [ k ] ,
index , is_output ) ;
2009-10-19 04:12:10 +02:00
printed [ ic - > programs [ j ] - > stream_index [ k ] ] = 1 ;
}
total + = ic - > programs [ j ] - > nb_stream_indexes ;
}
if ( total < ic - > nb_streams )
av_log ( NULL , AV_LOG_INFO , " No Program \n " ) ;
}
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + )
2009-10-19 04:20:08 +02:00
if ( ! printed [ i ] )
2009-10-18 22:25:48 +02:00
dump_stream_format ( ic , i , index , is_output ) ;
2009-10-19 04:12:10 +02:00
av_free ( printed ) ;
2001-07-22 16:18:56 +02:00
}
2010-03-10 23:21:39 +01:00
uint64_t ff_ntp_time ( void )
{
2014-01-16 01:53:03 +01:00
return ( av_gettime ( ) / 1000 ) * 1000 + NTP_OFFSET_US ;
2010-03-10 23:21:39 +01:00
}
2014-01-16 01:53:03 +01:00
int av_get_frame_filename ( char * buf , int buf_size , const char * path , int number )
2001-09-16 23:50:48 +02:00
{
const char * p ;
2003-10-26 11:49:49 +01:00
char * q , buf1 [ 20 ] , c ;
int nd , len , percentd_found ;
2001-09-16 23:50:48 +02:00
q = buf ;
p = path ;
percentd_found = 0 ;
2014-01-16 01:53:03 +01:00
for ( ; ; ) {
2001-09-16 23:50:48 +02:00
c = * p + + ;
if ( c = = ' \0 ' )
break ;
if ( c = = ' % ' ) {
2002-12-11 04:20:05 +01:00
do {
nd = 0 ;
2014-01-16 01:53:03 +01:00
while ( av_isdigit ( * p ) )
2002-12-11 04:20:05 +01:00
nd = nd * 10 + * p + + - ' 0 ' ;
c = * p + + ;
2013-03-03 11:17:50 +01:00
} while ( av_isdigit ( c ) ) ;
2002-12-11 04:20:05 +01:00
2014-01-16 01:53:03 +01:00
switch ( c ) {
2001-09-16 23:50:48 +02:00
case ' % ' :
goto addchar ;
case ' d ' :
if ( percentd_found )
goto fail ;
percentd_found = 1 ;
snprintf ( buf1 , sizeof ( buf1 ) , " %0*d " , nd , number ) ;
len = strlen ( buf1 ) ;
if ( ( q - buf + len ) > buf_size - 1 )
goto fail ;
memcpy ( q , buf1 , len ) ;
q + = len ;
break ;
default :
goto fail ;
}
} else {
2014-01-16 01:53:03 +01:00
addchar :
2001-09-16 23:50:48 +02:00
if ( ( q - buf ) < buf_size - 1 )
* q + + = c ;
}
}
if ( ! percentd_found )
goto fail ;
* q = ' \0 ' ;
return 0 ;
2014-01-16 01:53:03 +01:00
fail :
2001-09-16 23:50:48 +02:00
* q = ' \0 ' ;
return - 1 ;
}
2014-01-16 01:55:38 +01:00
# define HEXDUMP_PRINT(...) \
2014-01-16 01:53:03 +01:00
do { \
if ( ! f ) \
av_log ( avcl , level , __VA_ARGS__ ) ; \
else \
fprintf ( f , __VA_ARGS__ ) ; \
} while ( 0 )
2002-05-20 18:28:47 +02:00
2014-01-16 01:55:38 +01:00
static void hex_dump_internal ( void * avcl , FILE * f , int level ,
const uint8_t * buf , int size )
{
int len , i , j , c ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < size ; i + = 16 ) {
2002-05-20 18:28:47 +02:00
len = size - i ;
if ( len > 16 )
len = 16 ;
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " %08x " , i ) ;
2014-01-16 01:53:03 +01:00
for ( j = 0 ; j < 16 ; j + + ) {
2002-05-20 18:28:47 +02:00
if ( j < len )
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " %02x " , buf [ i + j ] ) ;
2002-05-20 18:28:47 +02:00
else
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " " ) ;
2002-05-20 18:28:47 +02:00
}
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " " ) ;
2014-01-16 01:53:03 +01:00
for ( j = 0 ; j < len ; j + + ) {
c = buf [ i + j ] ;
2002-05-20 18:28:47 +02:00
if ( c < ' ' | | c > ' ~ ' )
c = ' . ' ;
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " %c " , c ) ;
2002-05-20 18:28:47 +02:00
}
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " \n " ) ;
2002-05-20 18:28:47 +02:00
}
2007-03-12 15:17:26 +01:00
}
2012-10-01 12:48:23 +02:00
void av_hex_dump ( FILE * f , const uint8_t * buf , int size )
2007-03-12 15:17:26 +01:00
{
hex_dump_internal ( NULL , f , 0 , buf , size ) ;
}
2012-10-01 12:48:23 +02:00
void av_hex_dump_log ( void * avcl , int level , const uint8_t * buf , int size )
2007-03-12 15:17:26 +01:00
{
hex_dump_internal ( avcl , NULL , level , buf , size ) ;
2002-05-20 18:28:47 +02:00
}
2014-04-03 12:44:43 +02:00
static void pkt_dump_internal ( void * avcl , FILE * f , int level , const AVPacket * pkt ,
2014-01-16 01:53:03 +01:00
int dump_payload , AVRational time_base )
2003-11-10 19:37:55 +01:00
{
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " stream #%d: \n " , pkt - > stream_index ) ;
HEXDUMP_PRINT ( " keyframe=%d \n " , ( pkt - > flags & AV_PKT_FLAG_KEY ) ! = 0 ) ;
HEXDUMP_PRINT ( " duration=%0.3f \n " , pkt - > duration * av_q2d ( time_base ) ) ;
2003-12-15 15:45:37 +01:00
/* DTS is _always_ valid after av_read_frame() */
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " dts= " ) ;
2003-12-15 15:45:37 +01:00
if ( pkt - > dts = = AV_NOPTS_VALUE )
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " N/A " ) ;
2003-12-15 15:45:37 +01:00
else
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " %0.3f " , pkt - > dts * av_q2d ( time_base ) ) ;
2008-01-16 23:14:26 +01:00
/* PTS may not be known if B-frames are present. */
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " pts= " ) ;
2003-11-10 19:37:55 +01:00
if ( pkt - > pts = = AV_NOPTS_VALUE )
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " N/A " ) ;
2003-11-10 19:37:55 +01:00
else
2014-01-16 01:55:38 +01:00
HEXDUMP_PRINT ( " %0.3f " , pkt - > pts * av_q2d ( time_base ) ) ;
HEXDUMP_PRINT ( " \n " ) ;
HEXDUMP_PRINT ( " size=%d \n " , pkt - > size ) ;
2003-11-10 19:37:55 +01:00
if ( dump_payload )
av_hex_dump ( f , pkt - > data , pkt - > size ) ;
}
2014-04-03 12:44:43 +02:00
void av_pkt_dump2 ( FILE * f , const AVPacket * pkt , int dump_payload , const AVStream * st )
2011-02-24 09:08:06 +01:00
{
pkt_dump_internal ( NULL , f , 0 , pkt , dump_payload , st - > time_base ) ;
2007-03-12 15:17:26 +01:00
}
2014-04-03 12:44:43 +02:00
void av_pkt_dump_log2 ( void * avcl , int level , const AVPacket * pkt , int dump_payload ,
const AVStream * st )
2011-02-24 09:08:06 +01:00
{
pkt_dump_internal ( avcl , NULL , level , pkt , dump_payload , st - > time_base ) ;
2007-03-12 15:17:26 +01:00
}
2010-06-27 16:16:46 +02:00
void av_url_split ( char * proto , int proto_size ,
char * authorization , int authorization_size ,
char * hostname , int hostname_size ,
2014-01-16 01:53:03 +01:00
int * port_ptr , char * path , int path_size , const char * url )
2002-07-24 20:04:50 +02:00
{
2012-11-15 11:56:47 +01:00
const char * p , * ls , * ls2 , * at , * at2 , * col , * brk ;
2007-09-27 21:18:07 +02:00
2014-01-16 01:53:03 +01:00
if ( port_ptr )
* port_ptr = - 1 ;
if ( proto_size > 0 )
proto [ 0 ] = 0 ;
if ( authorization_size > 0 )
authorization [ 0 ] = 0 ;
if ( hostname_size > 0 )
hostname [ 0 ] = 0 ;
if ( path_size > 0 )
path [ 0 ] = 0 ;
2007-09-27 21:18:07 +02:00
/* parse protocol */
if ( ( p = strchr ( url , ' : ' ) ) ) {
av_strlcpy ( proto , url , FFMIN ( proto_size , p + 1 - url ) ) ;
p + + ; /* skip ':' */
2014-01-16 01:53:03 +01:00
if ( * p = = ' / ' )
p + + ;
if ( * p = = ' / ' )
p + + ;
2002-07-24 20:04:50 +02:00
} else {
2007-09-27 21:18:07 +02:00
/* no protocol means plain filename */
av_strlcpy ( path , url , path_size ) ;
return ;
}
2004-08-12 02:09:32 +02:00
2007-09-27 21:18:07 +02:00
/* separate path from hostname */
2007-12-29 17:13:03 +01:00
ls = strchr ( p , ' / ' ) ;
2012-07-22 12:51:53 +02:00
ls2 = strchr ( p , ' ? ' ) ;
2014-01-16 01:53:03 +01:00
if ( ! ls )
2012-07-22 12:51:53 +02:00
ls = ls2 ;
else if ( ls & & ls2 )
ls = FFMIN ( ls , ls2 ) ;
2014-01-16 01:53:03 +01:00
if ( ls )
2007-12-29 17:34:51 +01:00
av_strlcpy ( path , ls , path_size ) ;
2007-12-29 17:13:03 +01:00
else
2014-01-16 01:53:03 +01:00
ls = & p [ strlen ( p ) ] ; // XXX
2007-09-27 21:18:07 +02:00
/* the rest is hostname, use that to parse auth/port */
if ( ls ! = p ) {
/* authorization (user[:pass]@hostname) */
2012-11-15 11:56:47 +01:00
at2 = p ;
while ( ( at = strchr ( p , ' @ ' ) ) & & at < ls ) {
av_strlcpy ( authorization , at2 ,
FFMIN ( authorization_size , at + 1 - at2 ) ) ;
2007-09-27 21:18:07 +02:00
p = at + 1 ; /* skip '@' */
2002-07-24 20:04:50 +02:00
}
2007-09-27 21:18:07 +02:00
2007-09-29 16:35:52 +02:00
if ( * p = = ' [ ' & & ( brk = strchr ( p , ' ] ' ) ) & & brk < ls ) {
/* [host]:port */
av_strlcpy ( hostname , p + 1 ,
FFMIN ( hostname_size , brk - p ) ) ;
if ( brk [ 1 ] = = ' : ' & & port_ptr )
* port_ptr = atoi ( brk + 2 ) ;
} else if ( ( col = strchr ( p , ' : ' ) ) & & col < ls ) {
av_strlcpy ( hostname , p ,
FFMIN ( col + 1 - p , hostname_size ) ) ;
2014-01-16 01:53:03 +01:00
if ( port_ptr )
* port_ptr = atoi ( col + 1 ) ;
2007-09-29 16:35:52 +02:00
} else
av_strlcpy ( hostname , p ,
FFMIN ( ls + 1 - p , hostname_size ) ) ;
2002-07-24 20:04:50 +02:00
}
}
2010-03-25 08:13:20 +01:00
char * ff_data_to_hex ( char * buff , const uint8_t * src , int s , int lowercase )
2008-08-28 01:43:28 +02:00
{
int i ;
2010-03-25 08:13:20 +01:00
static const char hex_table_uc [ 16 ] = { ' 0 ' , ' 1 ' , ' 2 ' , ' 3 ' ,
2010-03-25 08:14:41 +01:00
' 4 ' , ' 5 ' , ' 6 ' , ' 7 ' ,
' 8 ' , ' 9 ' , ' A ' , ' B ' ,
' C ' , ' D ' , ' E ' , ' F ' } ;
2010-03-25 08:13:20 +01:00
static const char hex_table_lc [ 16 ] = { ' 0 ' , ' 1 ' , ' 2 ' , ' 3 ' ,
' 4 ' , ' 5 ' , ' 6 ' , ' 7 ' ,
' 8 ' , ' 9 ' , ' a ' , ' b ' ,
' c ' , ' d ' , ' e ' , ' f ' } ;
const char * hex_table = lowercase ? hex_table_lc : hex_table_uc ;
2008-08-28 01:43:28 +02:00
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < s ; i + + ) {
2008-08-28 14:00:58 +02:00
buff [ i * 2 ] = hex_table [ src [ i ] > > 4 ] ;
buff [ i * 2 + 1 ] = hex_table [ src [ i ] & 0xF ] ;
2008-08-28 01:43:28 +02:00
}
return buff ;
}
2010-08-09 12:05:33 +02:00
int ff_hex_to_data ( uint8_t * data , const char * p )
{
int c , len , v ;
len = 0 ;
2014-01-16 01:53:03 +01:00
v = 1 ;
2010-08-09 12:05:33 +02:00
for ( ; ; ) {
p + = strspn ( p , SPACE_CHARS ) ;
if ( * p = = ' \0 ' )
break ;
2013-03-03 11:17:50 +01:00
c = av_toupper ( ( unsigned char ) * p + + ) ;
2010-08-09 12:05:33 +02:00
if ( c > = ' 0 ' & & c < = ' 9 ' )
c = c - ' 0 ' ;
else if ( c > = ' A ' & & c < = ' F ' )
c = c - ' A ' + 10 ;
else
break ;
v = ( v < < 4 ) | c ;
if ( v & 0x100 ) {
if ( data )
data [ len ] = v ;
len + + ;
v = 1 ;
}
}
return len ;
}
2011-11-29 19:28:15 +01:00
# if FF_API_SET_PTS_INFO
2004-05-21 22:43:21 +02:00
void av_set_pts_info ( AVStream * s , int pts_wrap_bits ,
2009-07-01 20:50:31 +02:00
unsigned int pts_num , unsigned int pts_den )
2011-11-29 19:28:15 +01:00
{
avpriv_set_pts_info ( s , pts_wrap_bits , pts_num , pts_den ) ;
}
# endif
void avpriv_set_pts_info ( AVStream * s , int pts_wrap_bits ,
unsigned int pts_num , unsigned int pts_den )
2002-10-21 17:54:49 +02:00
{
2011-02-06 15:27:30 +01:00
AVRational new_tb ;
2014-01-16 01:53:03 +01:00
if ( av_reduce ( & new_tb . num , & new_tb . den , pts_num , pts_den , INT_MAX ) ) {
if ( new_tb . num ! = pts_num )
av_log ( NULL , AV_LOG_DEBUG ,
" st:%d removing common factor %d from timebase \n " ,
s - > index , pts_num / new_tb . num ) ;
} else
av_log ( NULL , AV_LOG_WARNING ,
" st:%d has too large timebase, reducing \n " , s - > index ) ;
if ( new_tb . num < = 0 | | new_tb . den < = 0 ) {
av_log ( NULL , AV_LOG_ERROR ,
2014-01-26 23:35:38 +01:00
" Ignoring attempt to set invalid timebase %d/%d for st:%d \n " ,
new_tb . num , new_tb . den ,
2014-01-16 01:53:03 +01:00
s - > index ) ;
2011-02-06 15:27:30 +01:00
return ;
}
2014-01-16 01:53:03 +01:00
s - > time_base = new_tb ;
2012-07-15 16:04:44 +02:00
av_codec_set_pkt_timebase ( s - > codec , new_tb ) ;
2011-02-06 15:27:30 +01:00
s - > pts_wrap_bits = pts_wrap_bits ;
2002-10-21 17:54:49 +02:00
}
2010-03-05 23:31:45 +01:00
2010-08-19 16:49:53 +02:00
void ff_parse_key_value ( const char * str , ff_parse_key_val_cb callback_get_buf ,
void * context )
{
const char * ptr = str ;
/* Parse key=value pairs. */
for ( ; ; ) {
const char * key ;
char * dest = NULL , * dest_end ;
int key_len , dest_len = 0 ;
/* Skip whitespace and potential commas. */
2013-03-03 11:17:50 +01:00
while ( * ptr & & ( av_isspace ( * ptr ) | | * ptr = = ' , ' ) )
2010-08-19 16:49:53 +02:00
ptr + + ;
if ( ! * ptr )
break ;
key = ptr ;
if ( ! ( ptr = strchr ( key , ' = ' ) ) )
break ;
ptr + + ;
key_len = ptr - key ;
callback_get_buf ( context , key , key_len , & dest , & dest_len ) ;
dest_end = dest + dest_len - 1 ;
if ( * ptr = = ' \" ' ) {
ptr + + ;
while ( * ptr & & * ptr ! = ' \" ' ) {
if ( * ptr = = ' \\ ' ) {
if ( ! ptr [ 1 ] )
break ;
if ( dest & & dest < dest_end )
* dest + + = ptr [ 1 ] ;
ptr + = 2 ;
} else {
if ( dest & & dest < dest_end )
* dest + + = * ptr ;
ptr + + ;
}
}
if ( * ptr = = ' \" ' )
ptr + + ;
} else {
2013-03-03 11:17:50 +01:00
for ( ; * ptr & & ! ( av_isspace ( * ptr ) | | * ptr = = ' , ' ) ; ptr + + )
2010-08-19 16:49:53 +02:00
if ( dest & & dest < dest_end )
* dest + + = * ptr ;
}
if ( dest )
* dest = 0 ;
}
}
2010-12-26 02:24:51 +01:00
int ff_find_stream_index ( AVFormatContext * s , int id )
{
int i ;
2014-01-16 01:53:03 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + )
2010-12-26 02:24:51 +01:00
if ( s - > streams [ i ] - > id = = id )
return i ;
return - 1 ;
}
2011-03-17 11:24:23 +01:00
2011-07-13 11:45:17 +02:00
int64_t ff_iso8601_to_unix_time ( const char * datestr )
{
2014-01-16 01:53:03 +01:00
struct tm time1 = { 0 } , time2 = { 0 } ;
2011-11-07 23:12:09 +01:00
char * ret1 , * ret2 ;
2012-09-01 13:32:43 +02:00
ret1 = av_small_strptime ( datestr , " %Y - %m - %d %H:%M:%S " , & time1 ) ;
ret2 = av_small_strptime ( datestr , " %Y - %m - %dT%H:%M:%S " , & time2 ) ;
2011-11-07 23:12:09 +01:00
if ( ret2 & & ! ret1 )
return av_timegm ( & time2 ) ;
else
return av_timegm ( & time1 ) ;
2011-07-13 11:45:17 +02:00
}
2011-08-11 20:34:45 +02:00
2014-01-16 01:53:03 +01:00
int avformat_query_codec ( AVOutputFormat * ofmt , enum AVCodecID codec_id ,
int std_compliance )
2011-08-11 20:34:45 +02:00
{
if ( ofmt ) {
if ( ofmt - > query_codec )
return ofmt - > query_codec ( codec_id , std_compliance ) ;
else if ( ofmt - > codec_tag )
return ! ! av_codec_get_tag ( ofmt - > codec_tag , codec_id ) ;
2014-01-16 01:53:03 +01:00
else if ( codec_id = = ofmt - > video_codec | |
codec_id = = ofmt - > audio_codec | |
2011-08-11 20:34:45 +02:00
codec_id = = ofmt - > subtitle_codec )
2011-08-23 03:47:24 +02:00
return 1 ;
2011-08-11 20:34:45 +02:00
}
return AVERROR_PATCHWELCOME ;
}
2011-11-01 12:40:04 +01:00
int avformat_network_init ( void )
{
# if CONFIG_NETWORK
int ret ;
2011-11-07 22:07:39 +01:00
ff_network_inited_globally = 1 ;
2011-11-01 12:40:04 +01:00
if ( ( ret = ff_network_init ( ) ) < 0 )
return ret ;
ff_tls_init ( ) ;
# endif
return 0 ;
}
int avformat_network_deinit ( void )
{
# if CONFIG_NETWORK
ff_network_close ( ) ;
ff_tls_deinit ( ) ;
# endif
return 0 ;
}
2011-12-16 11:48:09 +01:00
int ff_add_param_change ( AVPacket * pkt , int32_t channels ,
uint64_t channel_layout , int32_t sample_rate ,
int32_t width , int32_t height )
{
uint32_t flags = 0 ;
int size = 4 ;
uint8_t * data ;
if ( ! pkt )
return AVERROR ( EINVAL ) ;
if ( channels ) {
2014-01-16 01:53:03 +01:00
size + = 4 ;
2011-12-16 11:48:09 +01:00
flags | = AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT ;
}
if ( channel_layout ) {
2014-01-16 01:53:03 +01:00
size + = 8 ;
2011-12-16 11:48:09 +01:00
flags | = AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT ;
}
if ( sample_rate ) {
2014-01-16 01:53:03 +01:00
size + = 4 ;
2011-12-16 11:48:09 +01:00
flags | = AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE ;
}
if ( width | | height ) {
2014-01-16 01:53:03 +01:00
size + = 8 ;
2011-12-16 11:48:09 +01:00
flags | = AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS ;
}
data = av_packet_new_side_data ( pkt , AV_PKT_DATA_PARAM_CHANGE , size ) ;
if ( ! data )
return AVERROR ( ENOMEM ) ;
bytestream_put_le32 ( & data , flags ) ;
if ( channels )
bytestream_put_le32 ( & data , channels ) ;
if ( channel_layout )
bytestream_put_le64 ( & data , channel_layout ) ;
if ( sample_rate )
bytestream_put_le32 ( & data , sample_rate ) ;
if ( width | | height ) {
bytestream_put_le32 ( & data , width ) ;
bytestream_put_le32 ( & data , height ) ;
}
return 0 ;
}
2012-01-27 13:33:09 +01:00
2012-05-07 20:27:08 +02:00
AVRational av_guess_sample_aspect_ratio ( AVFormatContext * format , AVStream * stream , AVFrame * frame )
{
AVRational undef = { 0 , 1 } ;
AVRational stream_sample_aspect_ratio = stream ? stream - > sample_aspect_ratio : undef ;
2012-05-20 15:53:02 +02:00
AVRational codec_sample_aspect_ratio = stream & & stream - > codec ? stream - > codec - > sample_aspect_ratio : undef ;
AVRational frame_sample_aspect_ratio = frame ? frame - > sample_aspect_ratio : codec_sample_aspect_ratio ;
2012-05-07 20:27:08 +02:00
av_reduce ( & stream_sample_aspect_ratio . num , & stream_sample_aspect_ratio . den ,
stream_sample_aspect_ratio . num , stream_sample_aspect_ratio . den , INT_MAX ) ;
if ( stream_sample_aspect_ratio . num < = 0 | | stream_sample_aspect_ratio . den < = 0 )
stream_sample_aspect_ratio = undef ;
av_reduce ( & frame_sample_aspect_ratio . num , & frame_sample_aspect_ratio . den ,
frame_sample_aspect_ratio . num , frame_sample_aspect_ratio . den , INT_MAX ) ;
if ( frame_sample_aspect_ratio . num < = 0 | | frame_sample_aspect_ratio . den < = 0 )
frame_sample_aspect_ratio = undef ;
if ( stream_sample_aspect_ratio . num )
return stream_sample_aspect_ratio ;
else
return frame_sample_aspect_ratio ;
}
2012-07-18 11:41:13 +02:00
2013-03-27 22:08:53 +01:00
AVRational av_guess_frame_rate ( AVFormatContext * format , AVStream * st , AVFrame * frame )
{
AVRational fr = st - > r_frame_rate ;
2014-02-19 18:20:13 +01:00
AVRational codec_fr = av_inv_q ( st - > codec - > time_base ) ;
AVRational avg_fr = st - > avg_frame_rate ;
if ( avg_fr . num > 0 & & avg_fr . den > 0 & & fr . num > 0 & & fr . den > 0 & &
av_q2d ( avg_fr ) < 70 & & av_q2d ( fr ) > 210 ) {
fr = avg_fr ;
}
2013-03-27 22:08:53 +01:00
if ( st - > codec - > ticks_per_frame > 1 ) {
codec_fr . den * = st - > codec - > ticks_per_frame ;
if ( codec_fr . num > 0 & & codec_fr . den > 0 & & av_q2d ( codec_fr ) < av_q2d ( fr ) * 0.7
& & fabs ( 1.0 - av_q2d ( av_div_q ( avg_fr , fr ) ) ) > 0.1 )
fr = codec_fr ;
}
return fr ;
}
2012-07-18 11:41:13 +02:00
int avformat_match_stream_specifier ( AVFormatContext * s , AVStream * st ,
const char * spec )
{
if ( * spec < = ' 9 ' & & * spec > = ' 0 ' ) /* opt:index */
return strtol ( spec , NULL , 0 ) = = st - > index ;
else if ( * spec = = ' v ' | | * spec = = ' a ' | | * spec = = ' s ' | | * spec = = ' d ' | |
* spec = = ' t ' ) { /* opt:[vasdt] */
enum AVMediaType type ;
switch ( * spec + + ) {
case ' v ' : type = AVMEDIA_TYPE_VIDEO ; break ;
case ' a ' : type = AVMEDIA_TYPE_AUDIO ; break ;
case ' s ' : type = AVMEDIA_TYPE_SUBTITLE ; break ;
case ' d ' : type = AVMEDIA_TYPE_DATA ; break ;
case ' t ' : type = AVMEDIA_TYPE_ATTACHMENT ; break ;
default : av_assert0 ( 0 ) ;
}
if ( type ! = st - > codec - > codec_type )
return 0 ;
if ( * spec + + = = ' : ' ) { /* possibly followed by :index */
int i , index = strtol ( spec , NULL , 0 ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + )
if ( s - > streams [ i ] - > codec - > codec_type = = type & & index - - = = 0 )
return i = = st - > index ;
return 0 ;
}
return 1 ;
} else if ( * spec = = ' p ' & & * ( spec + 1 ) = = ' : ' ) {
int prog_id , i , j ;
char * endptr ;
spec + = 2 ;
prog_id = strtol ( spec , & endptr , 0 ) ;
for ( i = 0 ; i < s - > nb_programs ; i + + ) {
if ( s - > programs [ i ] - > id ! = prog_id )
continue ;
if ( * endptr + + = = ' : ' ) {
int stream_idx = strtol ( endptr , NULL , 0 ) ;
return stream_idx > = 0 & &
stream_idx < s - > programs [ i ] - > nb_stream_indexes & &
st - > index = = s - > programs [ i ] - > stream_index [ stream_idx ] ;
}
for ( j = 0 ; j < s - > programs [ i ] - > nb_stream_indexes ; j + + )
if ( st - > index = = s - > programs [ i ] - > stream_index [ j ] )
return 1 ;
}
return 0 ;
2014-03-13 14:16:00 +01:00
} else if ( * spec = = ' # ' | |
( * spec = = ' i ' & & * ( spec + 1 ) = = ' : ' ) ) {
int stream_id ;
2012-07-18 11:41:13 +02:00
char * endptr ;
2014-03-13 14:16:00 +01:00
spec + = 1 + ( * spec = = ' i ' ) ;
stream_id = strtol ( spec , & endptr , 0 ) ;
2012-07-18 11:41:13 +02:00
if ( ! * endptr )
2014-03-13 14:16:00 +01:00
return stream_id = = st - > id ;
2012-07-18 11:41:13 +02:00
} else if ( ! * spec ) /* empty specifier, matches everything */
return 1 ;
av_log ( s , AV_LOG_ERROR , " Invalid stream specifier: %s. \n " , spec ) ;
return AVERROR ( EINVAL ) ;
}
2012-09-26 12:13:53 +02:00
2012-09-26 12:13:53 +02:00
int ff_generate_avci_extradata ( AVStream * st )
2012-09-26 12:13:53 +02:00
{
static const uint8_t avci100_1080p_extradata [ ] = {
// SPS
0x00 , 0x00 , 0x00 , 0x01 , 0x67 , 0x7a , 0x10 , 0x29 ,
0xb6 , 0xd4 , 0x20 , 0x22 , 0x33 , 0x19 , 0xc6 , 0x63 ,
0x23 , 0x21 , 0x01 , 0x11 , 0x98 , 0xce , 0x33 , 0x19 ,
0x18 , 0x21 , 0x02 , 0x56 , 0xb9 , 0x3d , 0x7d , 0x7e ,
0x4f , 0xe3 , 0x3f , 0x11 , 0xf1 , 0x9e , 0x08 , 0xb8 ,
0x8c , 0x54 , 0x43 , 0xc0 , 0x78 , 0x02 , 0x27 , 0xe2 ,
0x70 , 0x1e , 0x30 , 0x10 , 0x10 , 0x14 , 0x00 , 0x00 ,
0x03 , 0x00 , 0x04 , 0x00 , 0x00 , 0x03 , 0x00 , 0xca ,
0x10 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
// PPS
0x00 , 0x00 , 0x00 , 0x01 , 0x68 , 0xce , 0x33 , 0x48 ,
0xd0
} ;
static const uint8_t avci100_1080i_extradata [ ] = {
// SPS
0x00 , 0x00 , 0x00 , 0x01 , 0x67 , 0x7a , 0x10 , 0x29 ,
0xb6 , 0xd4 , 0x20 , 0x22 , 0x33 , 0x19 , 0xc6 , 0x63 ,
0x23 , 0x21 , 0x01 , 0x11 , 0x98 , 0xce , 0x33 , 0x19 ,
0x18 , 0x21 , 0x03 , 0x3a , 0x46 , 0x65 , 0x6a , 0x65 ,
0x24 , 0xad , 0xe9 , 0x12 , 0x32 , 0x14 , 0x1a , 0x26 ,
0x34 , 0xad , 0xa4 , 0x41 , 0x82 , 0x23 , 0x01 , 0x50 ,
0x2b , 0x1a , 0x24 , 0x69 , 0x48 , 0x30 , 0x40 , 0x2e ,
0x11 , 0x12 , 0x08 , 0xc6 , 0x8c , 0x04 , 0x41 , 0x28 ,
0x4c , 0x34 , 0xf0 , 0x1e , 0x01 , 0x13 , 0xf2 , 0xe0 ,
0x3c , 0x60 , 0x20 , 0x20 , 0x28 , 0x00 , 0x00 , 0x03 ,
0x00 , 0x08 , 0x00 , 0x00 , 0x03 , 0x01 , 0x94 , 0x00 ,
// PPS
0x00 , 0x00 , 0x00 , 0x01 , 0x68 , 0xce , 0x33 , 0x48 ,
0xd0
} ;
static const uint8_t avci50_1080i_extradata [ ] = {
// SPS
0x00 , 0x00 , 0x00 , 0x01 , 0x67 , 0x6e , 0x10 , 0x28 ,
0xa6 , 0xd4 , 0x20 , 0x32 , 0x33 , 0x0c , 0x71 , 0x18 ,
0x88 , 0x62 , 0x10 , 0x19 , 0x19 , 0x86 , 0x38 , 0x8c ,
0x44 , 0x30 , 0x21 , 0x02 , 0x56 , 0x4e , 0x6e , 0x61 ,
0x87 , 0x3e , 0x73 , 0x4d , 0x98 , 0x0c , 0x03 , 0x06 ,
0x9c , 0x0b , 0x73 , 0xe6 , 0xc0 , 0xb5 , 0x18 , 0x63 ,
0x0d , 0x39 , 0xe0 , 0x5b , 0x02 , 0xd4 , 0xc6 , 0x19 ,
0x1a , 0x79 , 0x8c , 0x32 , 0x34 , 0x24 , 0xf0 , 0x16 ,
2013-01-05 09:20:03 +01:00
0x81 , 0x13 , 0xf7 , 0xff , 0x80 , 0x02 , 0x00 , 0x01 ,
0xf1 , 0x80 , 0x80 , 0x80 , 0xa0 , 0x00 , 0x00 , 0x03 ,
2012-09-26 12:13:53 +02:00
0x00 , 0x20 , 0x00 , 0x00 , 0x06 , 0x50 , 0x80 , 0x00 ,
// PPS
0x00 , 0x00 , 0x00 , 0x01 , 0x68 , 0xee , 0x31 , 0x12 ,
0x11
} ;
static const uint8_t avci100_720p_extradata [ ] = {
// SPS
0x00 , 0x00 , 0x00 , 0x01 , 0x67 , 0x7a , 0x10 , 0x29 ,
0xb6 , 0xd4 , 0x20 , 0x2a , 0x33 , 0x1d , 0xc7 , 0x62 ,
0xa1 , 0x08 , 0x40 , 0x54 , 0x66 , 0x3b , 0x8e , 0xc5 ,
0x42 , 0x02 , 0x10 , 0x25 , 0x64 , 0x2c , 0x89 , 0xe8 ,
0x85 , 0xe4 , 0x21 , 0x4b , 0x90 , 0x83 , 0x06 , 0x95 ,
0xd1 , 0x06 , 0x46 , 0x97 , 0x20 , 0xc8 , 0xd7 , 0x43 ,
0x08 , 0x11 , 0xc2 , 0x1e , 0x4c , 0x91 , 0x0f , 0x01 ,
0x40 , 0x16 , 0xec , 0x07 , 0x8c , 0x04 , 0x04 , 0x05 ,
0x00 , 0x00 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x03 ,
0x00 , 0x64 , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
// PPS
0x00 , 0x00 , 0x00 , 0x01 , 0x68 , 0xce , 0x31 , 0x12 ,
0x11
} ;
2012-09-26 12:13:53 +02:00
const uint8_t * data = NULL ;
2014-01-16 01:53:03 +01:00
int size = 0 ;
2012-09-26 12:13:53 +02:00
2012-09-26 12:13:53 +02:00
if ( st - > codec - > width = = 1920 ) {
if ( st - > codec - > field_order = = AV_FIELD_PROGRESSIVE ) {
data = avci100_1080p_extradata ;
size = sizeof ( avci100_1080p_extradata ) ;
} else {
data = avci100_1080i_extradata ;
size = sizeof ( avci100_1080i_extradata ) ;
}
} else if ( st - > codec - > width = = 1440 ) {
data = avci50_1080i_extradata ;
size = sizeof ( avci50_1080i_extradata ) ;
} else if ( st - > codec - > width = = 1280 ) {
data = avci100_720p_extradata ;
size = sizeof ( avci100_720p_extradata ) ;
}
2012-09-26 12:13:53 +02:00
2012-09-26 12:13:53 +02:00
if ( ! size )
2012-09-26 12:13:53 +02:00
return 0 ;
2012-09-26 12:13:53 +02:00
av_freep ( & st - > codec - > extradata ) ;
2013-10-13 12:30:59 +02:00
if ( ff_alloc_extradata ( st - > codec , size ) )
2012-09-26 12:13:53 +02:00
return AVERROR ( ENOMEM ) ;
2012-09-26 12:13:53 +02:00
memcpy ( st - > codec - > extradata , data , size ) ;
2012-09-26 12:13:53 +02:00
return 0 ;
2012-09-26 12:13:53 +02:00
}
2014-05-19 16:29:30 +02:00
uint8_t * av_stream_get_side_data ( AVStream * st , enum AVPacketSideDataType type ,
int * size )
{
int i ;
for ( i = 0 ; i < st - > nb_side_data ; i + + ) {
if ( st - > side_data [ i ] . type = = type ) {
if ( size )
* size = st - > side_data [ i ] . size ;
return st - > side_data [ i ] . data ;
}
}
return NULL ;
}