2001-07-22 16:18:56 +02:00
/*
* Various utilities for ffmpeg system
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
*/
2001-08-13 23:37:10 +02:00
# include "avformat.h"
2006-06-30 09:41:25 +02:00
# include "allformats.h"
2006-08-27 14:14:13 +02:00
# include "opt.h"
2002-07-27 04:54:10 +02:00
2004-01-13 23:02:49 +01:00
# undef NDEBUG
# include <assert.h>
2005-06-28 14:55:08 +02:00
/**
* @ file libavformat / utils . c
* Various utility functions for using ffmpeg library .
*/
2006-06-25 19:37:12 +02:00
static void av_frac_init ( AVFrac * f , int64_t val , int64_t num , int64_t den ) ;
static void av_frac_add ( AVFrac * f , int64_t incr ) ;
2005-06-28 14:55:08 +02:00
/** head of registered input format linked list. */
2004-08-13 17:30:42 +02:00
AVInputFormat * first_iformat = NULL ;
2005-06-28 14:55:08 +02:00
/** head of registered output format linked list. */
2004-08-13 17:30:42 +02:00
AVOutputFormat * first_oformat = NULL ;
2001-07-22 16:18:56 +02:00
2002-05-20 18:28:47 +02:00
void av_register_input_format ( AVInputFormat * format )
2001-07-22 16:18:56 +02:00
{
2002-05-20 18:28:47 +02:00
AVInputFormat * * p ;
p = & first_iformat ;
while ( * p ! = NULL ) p = & ( * p ) - > next ;
* p = format ;
format - > next = NULL ;
}
void av_register_output_format ( AVOutputFormat * format )
{
AVOutputFormat * * p ;
p = & first_oformat ;
2001-07-22 16:18:56 +02:00
while ( * p ! = NULL ) p = & ( * p ) - > next ;
* p = format ;
format - > next = NULL ;
}
2002-11-18 18:17:27 +01:00
int match_ext ( const char * filename , const char * extensions )
2001-07-22 16:18:56 +02:00
{
const char * ext , * p ;
char ext1 [ 32 ] , * q ;
2004-04-27 04:55:05 +02:00
if ( ! filename )
return 0 ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:18:56 +02:00
ext = strrchr ( filename , ' . ' ) ;
if ( ext ) {
ext + + ;
p = extensions ;
for ( ; ; ) {
q = ext1 ;
2005-12-17 19:14:38 +01:00
while ( * p ! = ' \0 ' & & * p ! = ' , ' & & q - ext1 < sizeof ( ext1 ) - 1 )
2001-07-22 16:18:56 +02:00
* q + + = * p + + ;
* q = ' \0 ' ;
2005-12-17 19:14:38 +01:00
if ( ! strcasecmp ( ext1 , ext ) )
2001-07-22 16:18:56 +02:00
return 1 ;
2005-12-17 19:14:38 +01:00
if ( * p = = ' \0 ' )
2001-07-22 16:18:56 +02:00
break ;
p + + ;
}
}
return 0 ;
}
2005-12-17 19:14:38 +01:00
AVOutputFormat * guess_format ( const char * short_name , const char * filename ,
2002-05-20 18:28:47 +02:00
const char * mime_type )
2001-07-22 16:18:56 +02:00
{
2002-05-20 18:28:47 +02:00
AVOutputFormat * fmt , * fmt_found ;
2001-07-22 16:18:56 +02:00
int score_max , score ;
2003-01-11 06:02:14 +01:00
/* specific test for image sequences */
2006-07-10 23:14:37 +02:00
# ifdef CONFIG_IMAGE2_MUXER
2005-12-17 19:14:38 +01:00
if ( ! short_name & & filename & &
2006-09-04 11:57:47 +02:00
av_filename_number_test ( filename ) & &
2004-11-11 19:09:28 +01:00
av_guess_image2_codec ( filename ) ! = CODEC_ID_NONE ) {
return guess_format ( " image2 " , NULL , NULL ) ;
}
2006-07-10 23:14:37 +02:00
# endif
2001-07-22 16:18:56 +02:00
/* find the proper file type */
fmt_found = NULL ;
score_max = 0 ;
2002-05-20 18:28:47 +02:00
fmt = first_oformat ;
2001-07-22 16:18:56 +02:00
while ( fmt ! = NULL ) {
score = 0 ;
if ( fmt - > name & & short_name & & ! strcmp ( fmt - > name , short_name ) )
score + = 100 ;
if ( fmt - > mime_type & & mime_type & & ! strcmp ( fmt - > mime_type , mime_type ) )
score + = 10 ;
2005-12-17 19:14:38 +01:00
if ( filename & & fmt - > extensions & &
2001-07-22 16:18:56 +02:00
match_ext ( filename , fmt - > extensions ) ) {
score + = 5 ;
}
if ( score > score_max ) {
score_max = score ;
fmt_found = fmt ;
}
fmt = fmt - > next ;
}
return fmt_found ;
2005-12-17 19:14:38 +01:00
}
2001-07-22 16:18:56 +02:00
2005-12-17 19:14:38 +01:00
AVOutputFormat * guess_stream_format ( const char * short_name , const char * filename ,
2002-07-27 04:54:10 +02:00
const char * mime_type )
{
AVOutputFormat * fmt = guess_format ( short_name , filename , mime_type ) ;
if ( fmt ) {
AVOutputFormat * stream_fmt ;
char stream_format_name [ 64 ] ;
snprintf ( stream_format_name , sizeof ( stream_format_name ) , " %s_stream " , fmt - > name ) ;
stream_fmt = guess_format ( stream_format_name , NULL , NULL ) ;
if ( stream_fmt )
fmt = stream_fmt ;
}
return fmt ;
}
2004-11-11 19:09:28 +01:00
/**
2005-06-28 14:55:08 +02:00
* Guesses the codec id based upon muxer and filename .
2004-11-11 19:09:28 +01:00
*/
2005-12-17 19:14:38 +01:00
enum CodecID av_guess_codec ( AVOutputFormat * fmt , const char * short_name ,
2004-11-11 19:09:28 +01:00
const char * filename , const char * mime_type , enum CodecType type ) {
if ( type = = CODEC_TYPE_VIDEO ) {
enum CodecID codec_id = CODEC_ID_NONE ;
2006-07-10 23:14:37 +02:00
# ifdef CONFIG_IMAGE2_MUXER
2004-11-12 23:51:52 +01:00
if ( ! strcmp ( fmt - > name , " image2 " ) | | ! strcmp ( fmt - > name , " image2pipe " ) ) {
2004-11-11 19:09:28 +01:00
codec_id = av_guess_image2_codec ( filename ) ;
}
2006-07-10 23:14:37 +02:00
# endif
2004-11-11 19:09:28 +01:00
if ( codec_id = = CODEC_ID_NONE )
codec_id = fmt - > video_codec ;
return codec_id ;
} else if ( type = = CODEC_TYPE_AUDIO )
return fmt - > audio_codec ;
else
return CODEC_ID_NONE ;
}
2005-06-28 14:55:08 +02:00
/**
* finds AVInputFormat based on input format ' s short name .
*/
2002-05-20 18:28:47 +02:00
AVInputFormat * av_find_input_format ( const char * short_name )
{
AVInputFormat * fmt ;
for ( fmt = first_iformat ; fmt ! = NULL ; fmt = fmt - > next ) {
if ( ! strcmp ( fmt - > name , short_name ) )
return fmt ;
}
return NULL ;
}
2001-07-22 16:18:56 +02:00
/* memory handling */
2003-02-03 23:58:29 +01:00
/**
2005-06-28 14:55:08 +02:00
* Default packet destructor .
2003-02-03 23:58:29 +01:00
*/
2005-06-27 02:04:03 +02:00
void av_destruct_packet ( AVPacket * pkt )
2003-02-03 23:58:29 +01:00
{
av_free ( pkt - > data ) ;
pkt - > data = NULL ; pkt - > size = 0 ;
}
2002-05-20 18:28:47 +02:00
/**
* Allocate the payload of a packet and intialized its fields to default values .
*
* @ param pkt packet
* @ param size wanted payload size
* @ return 0 if OK . AVERROR_xxx otherwise .
*/
2001-07-22 16:18:56 +02:00
int av_new_packet ( AVPacket * pkt , int size )
{
2006-10-31 00:59:52 +01:00
uint8_t * data ;
2005-01-08 15:21:33 +01:00
if ( ( unsigned ) size > ( unsigned ) size + FF_INPUT_BUFFER_PADDING_SIZE )
2005-12-17 19:14:38 +01:00
return AVERROR_NOMEM ;
2005-01-08 15:21:33 +01:00
data = av_malloc ( size + FF_INPUT_BUFFER_PADDING_SIZE ) ;
2003-02-03 23:58:29 +01:00
if ( ! data )
2002-05-20 18:28:47 +02:00
return AVERROR_NOMEM ;
2003-02-03 23:58:29 +01:00
memset ( data + size , 0 , FF_INPUT_BUFFER_PADDING_SIZE ) ;
2002-11-09 16:53:52 +01:00
2003-02-03 23:58:29 +01:00
av_init_packet ( pkt ) ;
2005-12-17 19:14:38 +01:00
pkt - > data = data ;
2003-02-03 23:58:29 +01:00
pkt - > size = size ;
pkt - > destruct = av_destruct_packet ;
2001-07-22 16:18:56 +02:00
return 0 ;
}
2005-05-26 22:17:12 +02:00
/**
* Allocate and read the payload of a packet and intialized its fields to default values .
*
* @ param pkt packet
* @ param size wanted payload size
* @ return > 0 ( read size ) if OK . AVERROR_xxx otherwise .
*/
int av_get_packet ( ByteIOContext * s , AVPacket * pkt , int size )
{
int ret = av_new_packet ( pkt , size ) ;
if ( ret < 0 )
return ret ;
pkt - > pos = url_ftell ( s ) ;
ret = get_buffer ( s , pkt - > data , size ) ;
if ( ret < = 0 )
av_free_packet ( pkt ) ;
else
pkt - > size = ret ;
return ret ;
}
2003-11-10 19:37:55 +01:00
/* This is a hack - the packet memory allocation stuff is broken. The
packet is allocated if it was not really allocated */
int av_dup_packet ( AVPacket * pkt )
{
if ( pkt - > destruct ! = av_destruct_packet ) {
uint8_t * data ;
2003-12-09 16:34:44 +01:00
/* we duplicate the packet and don't forget to put the padding
again */
2005-01-08 15:21:33 +01:00
if ( ( unsigned ) pkt - > size > ( unsigned ) pkt - > size + FF_INPUT_BUFFER_PADDING_SIZE )
2005-12-17 19:14:38 +01:00
return AVERROR_NOMEM ;
2003-12-09 16:34:44 +01:00
data = av_malloc ( pkt - > size + FF_INPUT_BUFFER_PADDING_SIZE ) ;
2003-11-10 19:37:55 +01:00
if ( ! data ) {
return AVERROR_NOMEM ;
}
memcpy ( data , pkt - > data , pkt - > size ) ;
2003-12-09 16:34:44 +01:00
memset ( data + pkt - > size , 0 , FF_INPUT_BUFFER_PADDING_SIZE ) ;
2003-11-10 19:37:55 +01:00
pkt - > data = data ;
pkt - > destruct = av_destruct_packet ;
}
return 0 ;
}
2006-09-04 11:57:47 +02:00
/**
2007-01-23 10:24:41 +01:00
* Check whether filename actually is a numbered sequence generator .
2006-09-04 11:57:47 +02:00
*
* @ param filename possible numbered sequence string
* @ return 1 if a valid numbered sequence string , 0 otherwise .
*/
int av_filename_number_test ( const char * filename )
2002-05-20 18:28:47 +02:00
{
char buf [ 1024 ] ;
2006-09-04 11:57:47 +02:00
return filename & & ( av_get_frame_filename ( buf , sizeof ( buf ) , filename , 1 ) > = 0 ) ;
2002-05-20 18:28:47 +02:00
}
2005-06-28 14:55:08 +02:00
/**
* Guess file format .
2007-01-19 23:54:50 +01:00
*
* @ param is_opened whether the file is already opened , determines whether
* demuxers with or without AVFMT_NOFILE are probed
2005-06-28 14:55:08 +02:00
*/
2002-07-25 18:05:52 +02:00
AVInputFormat * av_probe_input_format ( AVProbeData * pd , int is_opened )
2002-05-20 18:28:47 +02:00
{
AVInputFormat * fmt1 , * fmt ;
int score , score_max ;
fmt = NULL ;
score_max = 0 ;
for ( fmt1 = first_iformat ; fmt1 ! = NULL ; fmt1 = fmt1 - > next ) {
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 ) {
score = fmt1 - > read_probe ( pd ) ;
} else if ( fmt1 - > extensions ) {
2002-05-20 18:28:47 +02:00
if ( match_ext ( pd - > filename , fmt1 - > extensions ) ) {
score = 50 ;
}
2005-12-17 19:14:38 +01:00
}
2002-05-20 18:28:47 +02:00
if ( score > score_max ) {
score_max = score ;
fmt = fmt1 ;
}
}
return fmt ;
}
/************************************************************/
/* input media file */
2001-09-25 01:25:28 +02:00
2003-10-29 15:20:56 +01:00
/**
2005-06-28 14:55:08 +02:00
* Open a media file from an IO stream . ' fmt ' must be specified .
2003-10-29 15:20:56 +01:00
*/
2004-03-03 18:53:55 +01:00
static const char * format_to_name ( void * ptr )
2004-03-03 16:41:21 +01:00
{
2004-03-03 18:53:55 +01:00
AVFormatContext * fc = ( AVFormatContext * ) ptr ;
2004-03-03 16:41:21 +01:00
if ( fc - > iformat ) return fc - > iformat - > name ;
else if ( fc - > oformat ) return fc - > oformat - > name ;
else return " NULL " ;
}
2006-09-14 15:51:54 +02:00
# define OFFSET(x) offsetof(AVFormatContext,x)
2006-08-27 14:14:13 +02:00
# define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
//these names are too long to be readable
# define E AV_OPT_FLAG_ENCODING_PARAM
# define D AV_OPT_FLAG_DECODING_PARAM
static const AVOption options [ ] = {
2006-09-10 23:51:08 +02:00
{ " probesize " , NULL , OFFSET ( probesize ) , FF_OPT_TYPE_INT , 32000 , 32 , INT_MAX , D } , /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
2006-09-20 10:23:01 +02:00
{ " muxrate " , " set mux rate " , OFFSET ( mux_rate ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , E } ,
2006-09-20 10:24:17 +02:00
{ " packetsize " , " set packet size " , OFFSET ( packet_size ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , E } ,
2006-10-27 12:53:08 +02:00
{ " fflags " , NULL , OFFSET ( flags ) , FF_OPT_TYPE_FLAGS , DEFAULT , INT_MIN , INT_MAX , D | E , " fflags " } ,
2006-09-05 21:23:32 +02:00
{ " ignidx " , " ignore index " , 0 , FF_OPT_TYPE_CONST , AVFMT_FLAG_IGNIDX , INT_MIN , INT_MAX , D , " fflags " } ,
{ " genpts " , " generate pts " , 0 , FF_OPT_TYPE_CONST , AVFMT_FLAG_GENPTS , INT_MIN , INT_MAX , D , " fflags " } ,
2006-09-10 23:51:08 +02:00
{ " track " , " set the track number " , OFFSET ( track ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , E } ,
2006-09-08 14:28:28 +02:00
{ " year " , " set the year " , OFFSET ( year ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , E } ,
2007-01-23 18:34:26 +01:00
{ " analyzeduration " , NULL , OFFSET ( max_analyze_duration ) , FF_OPT_TYPE_INT , 3 * AV_TIME_BASE , 0 , INT_MAX , D } ,
2006-08-27 14:14:13 +02:00
{ NULL } ,
} ;
2006-09-09 10:49:28 +02:00
# undef E
# undef D
# undef DEFAULT
2006-08-27 14:14:13 +02:00
static const AVClass av_format_context_class = { " AVFormatContext " , format_to_name , options } ;
2007-01-08 15:42:01 +01:00
static void avformat_get_context_defaults ( AVFormatContext * s )
{
2006-08-27 14:14:13 +02:00
memset ( s , 0 , sizeof ( AVFormatContext ) ) ;
2006-08-27 14:21:19 +02:00
2006-09-10 22:21:40 +02:00
s - > av_class = & av_format_context_class ;
av_opt_set_defaults ( s ) ;
2006-08-27 14:14:13 +02:00
}
2004-03-03 16:41:21 +01:00
AVFormatContext * av_alloc_format_context ( void )
{
AVFormatContext * ic ;
2006-09-14 14:04:07 +02:00
ic = av_malloc ( sizeof ( AVFormatContext ) ) ;
2004-03-03 16:41:21 +01:00
if ( ! ic ) return ic ;
2006-08-27 14:14:13 +02:00
avformat_get_context_defaults ( ic ) ;
2004-03-03 18:53:55 +01:00
ic - > av_class = & av_format_context_class ;
2004-03-03 16:41:21 +01:00
return ic ;
}
2005-06-28 14:55:08 +02:00
/**
* Allocates all the structures needed to read an input stream .
* This does not open the needed codecs for decoding the stream [ s ] .
*/
2005-12-17 19:14:38 +01:00
int av_open_input_stream ( AVFormatContext * * ic_ptr ,
ByteIOContext * pb , const char * filename ,
2003-10-29 15:20:56 +01:00
AVInputFormat * fmt , AVFormatParameters * ap )
{
int err ;
AVFormatContext * ic ;
2006-03-11 01:22:21 +01:00
AVFormatParameters default_ap ;
if ( ! ap ) {
ap = & default_ap ;
memset ( ap , 0 , sizeof ( default_ap ) ) ;
}
2003-10-29 15:20:56 +01:00
2006-08-27 14:14:13 +02:00
if ( ! ap - > prealloced_context )
ic = av_alloc_format_context ( ) ;
else
ic = * ic_ptr ;
2003-10-29 15:20:56 +01:00
if ( ! ic ) {
err = AVERROR_NOMEM ;
goto fail ;
}
ic - > iformat = fmt ;
if ( pb )
ic - > pb = * pb ;
ic - > duration = AV_NOPTS_VALUE ;
ic - > start_time = AV_NOPTS_VALUE ;
pstrcpy ( ic - > filename , sizeof ( ic - > filename ) , filename ) ;
/* allocate private data */
if ( fmt - > priv_data_size > 0 ) {
ic - > priv_data = av_mallocz ( fmt - > priv_data_size ) ;
if ( ! ic - > priv_data ) {
err = AVERROR_NOMEM ;
goto fail ;
}
} else {
ic - > priv_data = NULL ;
}
err = ic - > iformat - > read_header ( ic , ap ) ;
if ( err < 0 )
goto fail ;
2003-11-10 19:37:55 +01:00
2006-11-11 20:37:21 +01:00
if ( pb & & ! ic - > data_offset )
2003-11-10 19:37:55 +01:00
ic - > data_offset = url_ftell ( & ic - > pb ) ;
2003-10-29 15:20:56 +01:00
* ic_ptr = ic ;
return 0 ;
fail :
if ( ic ) {
av_freep ( & ic - > priv_data ) ;
}
av_free ( ic ) ;
* ic_ptr = NULL ;
return err ;
}
2005-06-28 14:55:08 +02:00
/** Size of probe buffer, for guessing file type from file contents. */
2006-02-02 12:27:35 +01:00
# define PROBE_BUF_MIN 2048
2006-06-13 13:10:55 +02:00
# define PROBE_BUF_MAX (1<<20)
2002-05-20 18:28:47 +02:00
/**
* Open a media file as input . The codec are not opened . Only the file
* header ( if present ) is read .
*
* @ param ic_ptr the opened media file handle is put here
* @ param filename filename to open .
* @ param fmt if non NULL , force the file format to use
* @ param buf_size optional buffer size ( zero if default is OK )
* @ param ap additionnal parameters needed when opening the file ( NULL if default )
* @ return 0 if OK . AVERROR_xxx otherwise .
*/
2005-12-17 19:14:38 +01:00
int av_open_input_file ( AVFormatContext * * ic_ptr , const char * filename ,
2002-05-20 18:28:47 +02:00
AVInputFormat * fmt ,
int buf_size ,
AVFormatParameters * ap )
2001-07-22 16:18:56 +02:00
{
2006-02-02 12:27:35 +01:00
int err , must_open_file , file_opened , probe_size ;
2002-05-20 18:28:47 +02:00
AVProbeData probe_data , * pd = & probe_data ;
2003-10-29 15:20:56 +01:00
ByteIOContext pb1 , * pb = & pb1 ;
2005-12-17 19:14:38 +01:00
2003-10-29 15:20:56 +01:00
file_opened = 0 ;
pd - > filename = " " ;
if ( filename )
pd - > filename = filename ;
2006-02-02 12:27:35 +01:00
pd - > buf = NULL ;
2002-05-20 18:28:47 +02:00
pd - > buf_size = 0 ;
if ( ! fmt ) {
/* guess format if no file can be opened */
2002-07-25 18:05:52 +02:00
fmt = av_probe_input_format ( pd , 0 ) ;
2001-07-22 16:18:56 +02:00
}
2003-07-15 18:57:35 +02:00
/* do not open file if the format does not need it. XXX: specific
hack needed to handle RTSP / TCP */
must_open_file = 1 ;
2003-10-29 15:20:56 +01:00
if ( fmt & & ( fmt - > flags & AVFMT_NOFILE ) ) {
2003-07-15 18:57:35 +02:00
must_open_file = 0 ;
2004-09-28 23:09:25 +02:00
pb = NULL ; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
2003-07-15 18:57:35 +02:00
}
if ( ! fmt | | must_open_file ) {
2003-01-11 06:02:14 +01:00
/* if no file needed do not try to open one */
2003-10-29 15:20:56 +01:00
if ( url_fopen ( pb , filename , URL_RDONLY ) < 0 ) {
2002-05-20 18:28:47 +02:00
err = AVERROR_IO ;
2001-09-25 01:25:28 +02:00
goto fail ;
2002-05-20 18:28:47 +02:00
}
2003-10-29 15:20:56 +01:00
file_opened = 1 ;
2001-09-25 01:25:28 +02:00
if ( buf_size > 0 ) {
2003-10-29 15:20:56 +01:00
url_setbufsize ( pb , buf_size ) ;
2001-09-25 01:25:28 +02:00
}
2006-02-02 12:27:35 +01:00
for ( probe_size = PROBE_BUF_MIN ; probe_size < = PROBE_BUF_MAX & & ! fmt ; probe_size < < = 1 ) {
2002-11-18 18:17:27 +01:00
/* read probe data */
2006-02-02 12:27:35 +01:00
pd - > buf = av_realloc ( pd - > buf , probe_size ) ;
pd - > buf_size = get_buffer ( pb , pd - > buf , probe_size ) ;
2004-07-25 13:59:34 +02:00
if ( url_fseek ( pb , 0 , SEEK_SET ) = = ( offset_t ) - EPIPE ) {
url_fclose ( pb ) ;
if ( url_fopen ( pb , filename , URL_RDONLY ) < 0 ) {
2006-02-11 18:17:37 +01:00
file_opened = 0 ;
2004-07-25 13:59:34 +02:00
err = AVERROR_IO ;
goto fail ;
}
}
2006-02-02 12:27:35 +01:00
/* guess file format */
fmt = av_probe_input_format ( pd , 1 ) ;
2002-11-18 18:17:27 +01:00
}
2006-02-02 12:27:35 +01:00
av_freep ( & pd - > buf ) ;
2002-05-20 18:28:47 +02:00
}
/* if still no format found, error */
if ( ! fmt ) {
err = AVERROR_NOFMT ;
2003-10-29 15:20:56 +01:00
goto fail ;
2001-07-22 16:18:56 +02:00
}
2005-12-17 19:14:38 +01:00
2002-11-20 12:41:22 +01:00
/* XXX: suppress this hack for redirectors */
2003-01-11 21:34:38 +01:00
# ifdef CONFIG_NETWORK
2006-07-10 01:40:53 +02:00
if ( fmt = = & redir_demuxer ) {
2003-10-29 15:20:56 +01:00
err = redir_open ( ic_ptr , pb ) ;
url_fclose ( pb ) ;
2002-11-20 12:41:22 +01:00
return err ;
}
2002-12-20 20:25:10 +01:00
# endif
2002-11-20 12:41:22 +01:00
2003-01-11 06:02:14 +01:00
/* check filename in case of an image number is expected */
2003-10-29 15:20:56 +01:00
if ( fmt - > flags & AVFMT_NEEDNUMBER ) {
2006-09-04 11:57:47 +02:00
if ( ! av_filename_number_test ( filename ) ) {
2003-01-11 06:02:14 +01:00
err = AVERROR_NUMEXPECTED ;
2003-10-29 15:20:56 +01:00
goto fail ;
2003-01-11 06:02:14 +01:00
}
}
2003-10-29 15:20:56 +01:00
err = av_open_input_stream ( ic_ptr , pb , filename , fmt , ap ) ;
if ( err )
goto fail ;
2002-05-20 18:28:47 +02:00
return 0 ;
2001-07-22 16:18:56 +02:00
fail :
2006-02-02 12:27:35 +01:00
av_freep ( & pd - > buf ) ;
2003-10-29 15:20:56 +01:00
if ( file_opened )
url_fclose ( pb ) ;
2002-05-20 18:28:47 +02:00
* ic_ptr = NULL ;
return err ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:18:56 +02:00
}
2003-10-29 15:20:56 +01:00
/*******************************************************/
2002-05-20 18:28:47 +02:00
/**
2005-06-28 14:55:08 +02:00
* Read a transport packet from a media file .
*
* This function is absolete and should never be used .
* Use av_read_frame ( ) instead .
2005-12-17 19:14:38 +01:00
*
2002-05-20 18:28:47 +02:00
* @ param s media file handle
2005-12-17 19:14:38 +01:00
* @ param pkt is filled
* @ return 0 if OK . AVERROR_xxx if error .
2002-05-20 18:28:47 +02:00
*/
2001-07-22 16:18:56 +02:00
int av_read_packet ( AVFormatContext * s , AVPacket * pkt )
2003-11-10 19:37:55 +01:00
{
return s - > iformat - > read_packet ( s , pkt ) ;
}
/**********************************************************/
2005-06-28 14:55:08 +02:00
/**
* Get the number of samples of an audio frame . Return ( - 1 ) if error .
*/
2003-11-10 19:37:55 +01:00
static int get_audio_frame_size ( AVCodecContext * enc , int size )
{
int frame_size ;
if ( enc - > frame_size < = 1 ) {
2006-07-07 19:50:09 +02:00
int bits_per_sample = av_get_bits_per_sample ( enc - > codec_id ) ;
if ( bits_per_sample ) {
2003-11-10 19:37:55 +01:00
if ( enc - > channels = = 0 )
return - 1 ;
2006-07-08 09:14:00 +02:00
frame_size = ( size < < 3 ) / ( bits_per_sample * enc - > channels ) ;
2006-07-07 19:50:09 +02:00
} else {
2003-11-10 19:37:55 +01:00
/* used for example by ADPCM codecs */
if ( enc - > bit_rate = = 0 )
return - 1 ;
frame_size = ( size * 8 * enc - > sample_rate ) / enc - > bit_rate ;
}
} else {
frame_size = enc - > frame_size ;
}
return frame_size ;
}
2005-06-28 14:55:08 +02:00
/**
* Return the frame duration in seconds , return 0 if not available .
*/
2005-12-17 19:14:38 +01:00
static void compute_frame_duration ( int * pnum , int * pden , AVStream * st ,
2003-11-10 19:37:55 +01:00
AVCodecParserContext * pc , AVPacket * pkt )
{
int frame_size ;
* pnum = 0 ;
* pden = 0 ;
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2003-11-10 19:37:55 +01:00
case CODEC_TYPE_VIDEO :
2005-05-12 18:27:05 +02:00
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 ;
2005-07-18 00:24:36 +02:00
} else if ( st - > codec - > time_base . num * 1000LL > st - > codec - > time_base . den ) {
* 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 ) {
* pden * = 2 ;
* pnum = ( * pnum ) * ( 2 + pc - > repeat_pict ) ;
}
2003-11-10 19:37:55 +01:00
}
break ;
case CODEC_TYPE_AUDIO :
2005-07-18 00:24:36 +02:00
frame_size = get_audio_frame_size ( st - > codec , pkt - > size ) ;
2003-11-10 19:37:55 +01:00
if ( frame_size < 0 )
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 ;
}
}
2004-10-22 03:51:17 +02:00
static int is_intra_only ( AVCodecContext * enc ) {
if ( enc - > codec_type = = CODEC_TYPE_AUDIO ) {
return 1 ;
} else if ( enc - > codec_type = = CODEC_TYPE_VIDEO ) {
switch ( enc - > codec_id ) {
case CODEC_ID_MJPEG :
case CODEC_ID_MJPEGB :
case CODEC_ID_LJPEG :
case CODEC_ID_RAWVIDEO :
case CODEC_ID_DVVIDEO :
case CODEC_ID_HUFFYUV :
2004-11-28 19:29:38 +01:00
case CODEC_ID_FFVHUFF :
2004-10-22 03:51:17 +02:00
case CODEC_ID_ASV1 :
case CODEC_ID_ASV2 :
case CODEC_ID_VCR1 :
return 1 ;
default : break ;
}
}
return 0 ;
}
2004-05-23 23:36:23 +02:00
static int64_t lsb2full ( int64_t lsb , int64_t last_ts , int lsb_bits ) {
2004-05-24 17:13:23 +02:00
int64_t mask = lsb_bits < 64 ? ( 1LL < < lsb_bits ) - 1 : - 1LL ;
2004-05-23 23:36:23 +02:00
int64_t delta = last_ts - mask / 2 ;
return ( ( lsb - delta ) & mask ) + delta ;
}
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 )
{
int num , den , presentation_delayed ;
2004-05-23 23:36:23 +02:00
/* handle wrapping */
2004-05-29 04:06:32 +02:00
if ( st - > cur_dts ! = AV_NOPTS_VALUE ) {
if ( pkt - > pts ! = AV_NOPTS_VALUE )
pkt - > pts = lsb2full ( pkt - > pts , st - > cur_dts , st - > pts_wrap_bits ) ;
if ( pkt - > dts ! = AV_NOPTS_VALUE )
pkt - > dts = lsb2full ( pkt - > dts , st - > cur_dts , st - > pts_wrap_bits ) ;
}
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
if ( pkt - > duration = = 0 ) {
2004-05-29 20:50:31 +02:00
compute_frame_duration ( & num , & den , st , pc , pkt ) ;
2003-11-10 19:37:55 +01:00
if ( den & & num ) {
2004-05-23 23:36:23 +02:00
pkt - > duration = av_rescale ( 1 , num * ( int64_t ) st - > time_base . den , den * ( int64_t ) st - > time_base . num ) ;
2003-11-10 19:37:55 +01:00
}
}
2005-07-18 00:24:36 +02:00
if ( is_intra_only ( st - > codec ) )
2004-10-22 03:51:17 +02:00
pkt - > flags | = PKT_FLAG_KEY ;
2003-11-10 19:37:55 +01:00
/* do we have a video B frame ? */
presentation_delayed = 0 ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
2003-11-10 19:37:55 +01:00
/* XXX: need has_b_frame, but cannot get it if the codec is
not initialized */
2005-12-17 19:14:38 +01:00
if ( ( st - > codec - > codec_id = = CODEC_ID_H264
| | st - > codec - > has_b_frames ) & &
2003-11-10 19:37:55 +01:00
pc & & pc - > pict_type ! = FF_B_TYPE )
presentation_delayed = 1 ;
2004-05-23 23:36:23 +02:00
/* this may be redundant, but it shouldnt hurt */
if ( pkt - > dts ! = AV_NOPTS_VALUE & & pkt - > pts ! = AV_NOPTS_VALUE & & pkt - > pts > pkt - > dts )
presentation_delayed = 1 ;
2003-11-10 19:37:55 +01:00
}
2005-12-17 19:14:38 +01:00
2004-05-29 04:06:32 +02:00
if ( st - > cur_dts = = AV_NOPTS_VALUE ) {
if ( presentation_delayed ) st - > cur_dts = - pkt - > duration ;
else st - > cur_dts = 0 ;
}
2003-11-10 19:37:55 +01:00
2006-11-01 23:39:58 +01:00
// av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
2003-11-10 19:37:55 +01:00
/* interpolate PTS and DTS if they are not present */
if ( presentation_delayed ) {
/* DTS = decompression time stamp */
/* PTS = presentation time stamp */
if ( pkt - > dts = = AV_NOPTS_VALUE ) {
2004-05-23 23:36:23 +02:00
/* if we know the last pts, use it */
if ( st - > last_IP_pts ! = AV_NOPTS_VALUE )
st - > cur_dts = pkt - > dts = st - > last_IP_pts ;
else
pkt - > dts = st - > cur_dts ;
2003-11-10 19:37:55 +01:00
} else {
st - > cur_dts = pkt - > dts ;
}
/* 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 */
if ( st - > last_IP_duration = = 0 )
st - > cur_dts + = pkt - > duration ;
else
st - > cur_dts + = st - > last_IP_duration ;
st - > last_IP_duration = pkt - > duration ;
2004-05-23 23:36:23 +02:00
st - > last_IP_pts = pkt - > pts ;
2003-11-10 19:37:55 +01:00
/* cannot compute PTS if not present (we can compute it only
by knowing the futur */
2005-01-29 03:27:33 +01:00
} else if ( pkt - > pts ! = AV_NOPTS_VALUE | | pkt - > dts ! = AV_NOPTS_VALUE | | pkt - > duration ) {
2004-12-15 03:36:03 +01:00
if ( pkt - > pts ! = AV_NOPTS_VALUE & & pkt - > duration ) {
2006-10-12 01:17:58 +02:00
int64_t old_diff = FFABS ( st - > cur_dts - pkt - > duration - pkt - > pts ) ;
int64_t new_diff = FFABS ( st - > cur_dts - pkt - > pts ) ;
2004-12-15 03:36:03 +01:00
if ( old_diff < new_diff & & old_diff < ( pkt - > duration > > 3 ) ) {
pkt - > pts + = pkt - > duration ;
2006-11-01 23:39:58 +01:00
// av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
2004-12-15 03:36:03 +01:00
}
}
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* presentation is not delayed : PTS and DTS are the same */
if ( pkt - > pts = = AV_NOPTS_VALUE ) {
2004-02-20 15:39:15 +01:00
if ( pkt - > dts = = AV_NOPTS_VALUE ) {
pkt - > pts = st - > cur_dts ;
pkt - > dts = st - > cur_dts ;
}
else {
st - > cur_dts = pkt - > dts ;
pkt - > pts = pkt - > dts ;
}
2003-11-10 19:37:55 +01:00
} else {
st - > cur_dts = pkt - > pts ;
pkt - > dts = pkt - > pts ;
}
st - > cur_dts + = pkt - > duration ;
}
2006-11-01 23:39:58 +01:00
// av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* update flags */
if ( pc ) {
pkt - > flags = 0 ;
/* key frame computation */
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2003-11-10 19:37:55 +01:00
case CODEC_TYPE_VIDEO :
if ( pc - > pict_type = = FF_I_TYPE )
pkt - > flags | = PKT_FLAG_KEY ;
break ;
case CODEC_TYPE_AUDIO :
pkt - > flags | = PKT_FLAG_KEY ;
break ;
default :
break ;
}
}
}
2004-09-28 23:09:25 +02:00
void av_destruct_packet_nofree ( AVPacket * pkt )
2003-11-10 19:37:55 +01:00
{
pkt - > data = NULL ; pkt - > size = 0 ;
}
static int av_read_frame_internal ( AVFormatContext * s , AVPacket * pkt )
{
AVStream * st ;
2003-12-15 15:45:37 +01:00
int len , ret , i ;
2003-11-10 19:37:55 +01:00
for ( ; ; ) {
/* select current input stream component */
st = s - > cur_st ;
if ( st ) {
2005-06-27 02:04:03 +02:00
if ( ! st - > need_parsing | | ! st - > parser ) {
2003-11-10 19:37:55 +01:00
/* no parsing needed: we just output the packet as is */
/* raw data support */
* pkt = s - > cur_pkt ;
compute_pkt_fields ( s , st , NULL , pkt ) ;
s - > cur_st = NULL ;
2006-08-08 21:55:32 +02:00
break ;
2005-03-17 02:25:01 +01:00
} else if ( s - > cur_len > 0 & & st - > discard < AVDISCARD_ALL ) {
2005-12-17 19:14:38 +01:00
len = av_parser_parse ( st - > parser , st - > codec , & pkt - > data , & pkt - > size ,
2003-12-16 12:21:25 +01:00
s - > cur_ptr , s - > cur_len ,
s - > cur_pkt . pts , s - > cur_pkt . dts ) ;
s - > cur_pkt . pts = AV_NOPTS_VALUE ;
s - > cur_pkt . dts = AV_NOPTS_VALUE ;
2003-11-10 19:37:55 +01:00
/* increment read pointer */
s - > cur_ptr + = len ;
s - > cur_len - = len ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* return packet if any */
if ( pkt - > size ) {
2003-12-15 15:45:37 +01:00
got_packet :
2003-11-10 19:37:55 +01:00
pkt - > duration = 0 ;
pkt - > stream_index = st - > index ;
2003-12-16 12:21:25 +01:00
pkt - > pts = st - > parser - > pts ;
pkt - > dts = st - > parser - > dts ;
2003-11-10 19:37:55 +01:00
pkt - > destruct = av_destruct_packet_nofree ;
compute_pkt_fields ( s , st , st - > parser , pkt ) ;
2006-08-08 21:55:32 +02:00
break ;
2003-11-10 19:37:55 +01:00
}
} else {
2003-11-20 12:22:25 +01:00
/* free packet */
2005-12-17 19:14:38 +01:00
av_free_packet ( & s - > cur_pkt ) ;
2003-11-10 19:37:55 +01:00
s - > cur_st = NULL ;
}
} else {
/* read next packet */
ret = av_read_packet ( s , & s - > cur_pkt ) ;
2003-12-15 15:45:37 +01:00
if ( ret < 0 ) {
if ( ret = = - EAGAIN )
return ret ;
/* return the last frames, if any */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
st = s - > streams [ i ] ;
2005-06-27 02:04:03 +02:00
if ( st - > parser & & st - > need_parsing ) {
2005-12-17 19:14:38 +01:00
av_parser_parse ( st - > parser , st - > codec ,
& pkt - > data , & pkt - > size ,
NULL , 0 ,
2003-12-16 12:21:25 +01:00
AV_NOPTS_VALUE , AV_NOPTS_VALUE ) ;
2003-12-15 15:45:37 +01:00
if ( pkt - > size )
goto got_packet ;
}
}
/* no more packets: really terminates parsing */
2003-11-10 19:37:55 +01:00
return ret ;
2003-12-15 15:45:37 +01:00
}
2005-12-17 19:14:38 +01:00
2004-05-21 22:43:21 +02:00
st = s - > streams [ s - > cur_pkt . stream_index ] ;
2006-08-08 21:55:32 +02:00
if ( st - > codec - > debug & FF_DEBUG_PTS )
2006-10-14 22:43:39 +02:00
av_log ( s , AV_LOG_DEBUG , " av_read_packet stream=%d, pts=% " PRId64 " , dts=% " PRId64 " , size=%d \n " ,
2006-08-08 21:55:32 +02:00
s - > cur_pkt . stream_index ,
s - > cur_pkt . pts ,
s - > cur_pkt . dts ,
s - > cur_pkt . size ) ;
2003-11-10 19:37:55 +01:00
s - > cur_st = st ;
s - > cur_ptr = s - > cur_pkt . data ;
s - > cur_len = s - > cur_pkt . size ;
if ( st - > need_parsing & & ! st - > parser ) {
2005-07-18 00:24:36 +02:00
st - > parser = av_parser_init ( st - > codec - > codec_id ) ;
2003-11-10 19:37:55 +01:00
if ( ! st - > parser ) {
/* no parser available : just output the raw packets */
st - > need_parsing = 0 ;
2005-08-15 17:58:21 +02:00
} else if ( st - > need_parsing = = 2 ) {
st - > parser - > flags | = PARSER_FLAG_COMPLETE_FRAMES ;
2003-11-10 19:37:55 +01:00
}
}
}
}
2006-08-08 21:55:32 +02:00
if ( st - > codec - > debug & FF_DEBUG_PTS )
2006-10-14 22:43:39 +02:00
av_log ( s , AV_LOG_DEBUG , " av_read_frame_internal stream=%d, pts=% " PRId64 " , dts=% " PRId64 " , size=%d \n " ,
2006-08-08 21:55:32 +02:00
pkt - > stream_index ,
pkt - > pts ,
pkt - > dts ,
pkt - > size ) ;
return 0 ;
2003-11-10 19:37:55 +01:00
}
/**
2005-06-28 14:55:08 +02:00
* Return the next frame of a stream .
*
* The returned packet is valid
2003-11-10 19:37:55 +01:00
* until the next av_read_frame ( ) or until av_close_input_file ( ) and
* must be freed with av_free_packet . For video , the packet contains
* exactly one frame . For audio , it contains an integer number of
* frames if each frame has a known fixed size ( e . g . PCM or ADPCM
* data ) . If the audio frames have a variable size ( e . g . MPEG audio ) ,
* then it contains one frame .
2005-12-17 19:14:38 +01:00
*
2003-11-10 19:37:55 +01:00
* pkt - > pts , pkt - > dts and pkt - > duration are always set to correct
* values in AV_TIME_BASE unit ( and guessed if the format cannot
* provided them ) . pkt - > pts can be AV_NOPTS_VALUE if the video format
* has B frames , so it is better to rely on pkt - > dts if you do not
* decompress the payload .
2005-12-17 19:14:38 +01:00
*
2005-06-28 14:55:08 +02:00
* @ return 0 if OK , < 0 if error or end of file .
2003-11-10 19:37:55 +01:00
*/
int av_read_frame ( AVFormatContext * s , AVPacket * pkt )
2001-07-22 16:18:56 +02:00
{
AVPacketList * pktl ;
2005-08-15 16:22:43 +02:00
int eof = 0 ;
const int genpts = s - > flags & AVFMT_FLAG_GENPTS ;
for ( ; ; ) {
pktl = s - > packet_buffer ;
if ( pktl ) {
AVPacket * next_pkt = & pktl - > pkt ;
if ( genpts & & next_pkt - > dts ! = AV_NOPTS_VALUE ) {
while ( pktl & & next_pkt - > pts = = AV_NOPTS_VALUE ) {
2005-12-17 19:14:38 +01:00
if ( pktl - > pkt . stream_index = = next_pkt - > stream_index
2005-08-15 16:22:43 +02:00
& & next_pkt - > dts < pktl - > pkt . dts
& & pktl - > pkt . pts ! = pktl - > pkt . dts //not b frame
/*&& pktl->pkt.dts != AV_NOPTS_VALUE*/ ) {
next_pkt - > pts = pktl - > pkt . dts ;
}
pktl = pktl - > next ;
}
pktl = s - > packet_buffer ;
}
2005-12-17 19:14:38 +01:00
if ( next_pkt - > pts ! = AV_NOPTS_VALUE
| | next_pkt - > dts = = AV_NOPTS_VALUE
2005-08-15 16:22:43 +02:00
| | ! genpts | | eof ) {
/* read packet from packet buffer, if there is data */
* pkt = * next_pkt ;
s - > packet_buffer = pktl - > next ;
av_free ( pktl ) ;
return 0 ;
}
}
if ( genpts ) {
AVPacketList * * plast_pktl = & s - > packet_buffer ;
int ret = av_read_frame_internal ( s , pkt ) ;
if ( ret < 0 ) {
if ( pktl & & ret ! = - EAGAIN ) {
eof = 1 ;
continue ;
} else
return ret ;
}
2005-12-17 19:14:38 +01:00
2005-08-15 16:22:43 +02:00
/* duplicate the packet */
if ( av_dup_packet ( pkt ) < 0 )
return AVERROR_NOMEM ;
2001-07-22 16:18:56 +02:00
2005-08-15 16:22:43 +02:00
while ( * plast_pktl ) plast_pktl = & ( * plast_pktl ) - > next ; //FIXME maybe maintain pointer to the last?
2005-12-17 19:14:38 +01:00
2005-08-15 16:22:43 +02:00
pktl = av_mallocz ( sizeof ( AVPacketList ) ) ;
if ( ! pktl )
return AVERROR_NOMEM ;
2005-12-17 19:14:38 +01:00
2005-08-15 16:22:43 +02:00
/* add the packet in the buffered packet list */
* plast_pktl = pktl ;
2005-12-17 19:14:38 +01:00
pktl - > pkt = * pkt ;
2005-08-15 16:22:43 +02:00
} else {
assert ( ! s - > packet_buffer ) ;
return av_read_frame_internal ( s , pkt ) ;
}
2003-11-10 19:37:55 +01:00
}
}
/* XXX: suppress the packet queue */
static void flush_packet_queue ( AVFormatContext * s )
{
AVPacketList * pktl ;
for ( ; ; ) {
pktl = s - > packet_buffer ;
2005-12-17 19:14:38 +01:00
if ( ! pktl )
2003-11-10 19:37:55 +01:00
break ;
s - > packet_buffer = pktl - > next ;
av_free_packet ( & pktl - > pkt ) ;
av_free ( pktl ) ;
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 )
{
int i ;
AVStream * st ;
if ( s - > nb_streams < = 0 )
return - 1 ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
st = s - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
2004-01-13 23:02:49 +01:00
return i ;
}
}
return 0 ;
}
2005-06-28 14:55:08 +02:00
/**
* Flush the frame reader .
*/
2003-11-10 19:37:55 +01:00
static void av_read_frame_flush ( AVFormatContext * s )
{
AVStream * st ;
int i ;
flush_packet_queue ( s ) ;
/* free previous packet */
if ( s - > cur_st ) {
if ( s - > cur_st - > parser )
av_free_packet ( & s - > cur_pkt ) ;
s - > cur_st = NULL ;
}
/* fail safe */
s - > cur_ptr = NULL ;
s - > cur_len = 0 ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* for each stream, reset read state */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
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 ;
}
2004-05-23 23:36:23 +02:00
st - > last_IP_pts = AV_NOPTS_VALUE ;
2003-11-10 19:37:55 +01:00
st - > cur_dts = 0 ; /* we set the current DTS to an unspecified origin */
}
}
2004-10-12 12:28:27 +02:00
/**
2005-06-28 14:55:08 +02:00
* Updates cur_dts of all streams based on given timestamp and AVStream .
*
* Stream ref_st unchanged , others set cur_dts in their native timebase
2004-10-22 15:15:18 +02:00
* only needed for timestamp wrapping or if ( dts not set and pts ! = dts )
* @ param timestamp new dts expressed in time_base of param ref_st
* @ param ref_st reference stream giving time_base of param timestamp
2004-10-12 12:28:27 +02:00
*/
2006-07-23 20:19:33 +02:00
void av_update_cur_dts ( AVFormatContext * s , AVStream * ref_st , int64_t timestamp ) {
2004-10-12 12:28:27 +02:00
int i ;
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
2005-12-17 19:14:38 +01:00
st - > cur_dts = av_rescale ( timestamp ,
2004-10-22 15:15:18 +02:00
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
}
}
2004-05-23 18:26:12 +02:00
/**
2005-06-28 14:55:08 +02:00
* Add a index entry into a sorted list updateing if it is already there .
*
2004-05-23 18:26:12 +02:00
* @ param timestamp timestamp in the timebase of the given stream
*/
2004-01-17 19:06:52 +01:00
int av_add_index_entry ( AVStream * st ,
2006-03-01 12:29:55 +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
2005-01-08 15:21:33 +01:00
if ( ( unsigned ) st - > nb_index_entries + 1 > = UINT_MAX / sizeof ( AVIndexEntry ) )
return - 1 ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
entries = av_fast_realloc ( st - > index_entries ,
& st - > index_entries_allocated_size ,
2005-12-17 19:14:38 +01:00
( st - > nb_index_entries + 1 ) *
2003-11-10 19:37:55 +01:00
sizeof ( AVIndexEntry ) ) ;
2005-01-08 15:21:33 +01:00
if ( ! entries )
return - 1 ;
2004-01-13 23:02:49 +01:00
st - > index_entries = entries ;
2005-03-13 01:13:01 +01:00
index = av_index_search_timestamp ( st , timestamp , AVSEEK_FLAG_ANY ) ;
2004-01-13 23:02:49 +01:00
2004-10-11 00:05:43 +02:00
if ( index < 0 ) {
2004-01-17 19:06:52 +01:00
index = st - > nb_index_entries + + ;
ie = & entries [ index ] ;
2004-10-11 00:05:43 +02:00
assert ( index = = 0 | | ie [ - 1 ] . timestamp < timestamp ) ;
} else {
ie = & entries [ index ] ;
if ( ie - > timestamp ! = timestamp ) {
2004-10-14 01:58:28 +02:00
if ( ie - > timestamp < = timestamp )
return - 1 ;
2004-10-11 00:05:43 +02:00
memmove ( entries + index + 1 , entries + index , sizeof ( AVIndexEntry ) * ( st - > nb_index_entries - index ) ) ;
st - > nb_index_entries + + ;
} else if ( ie - > pos = = pos & & distance < ie - > min_distance ) //dont reduce the distance
distance = ie - > min_distance ;
2004-01-17 19:06:52 +01:00
}
2004-10-11 00:05:43 +02:00
2004-01-13 23:02:49 +01:00
ie - > pos = pos ;
ie - > timestamp = timestamp ;
2004-01-17 19:06:52 +01:00
ie - > min_distance = distance ;
2006-03-01 12:29:55 +01:00
ie - > size = size ;
2004-01-13 23:02:49 +01:00
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
}
2005-06-28 14:55:08 +02:00
/**
* build an index for raw streams using a parser .
*/
2003-11-10 19:37:55 +01:00
static void av_build_index_raw ( AVFormatContext * s )
{
AVPacket pkt1 , * pkt = & pkt1 ;
int ret ;
AVStream * st ;
st = s - > streams [ 0 ] ;
av_read_frame_flush ( s ) ;
url_fseek ( & s - > pb , s - > data_offset , SEEK_SET ) ;
for ( ; ; ) {
ret = av_read_frame ( s , pkt ) ;
if ( ret < 0 )
break ;
if ( pkt - > stream_index = = 0 & & st - > parser & &
( pkt - > flags & PKT_FLAG_KEY ) ) {
2005-12-17 19:14:38 +01:00
av_add_index_entry ( st , st - > parser - > frame_offset , pkt - > dts ,
2006-03-01 12:29:55 +01:00
0 , 0 , AVINDEX_KEYFRAME ) ;
2003-11-10 19:37:55 +01:00
}
av_free_packet ( pkt ) ;
}
}
2005-06-28 14:55:08 +02:00
/**
* Returns TRUE if we deal with a raw stream .
*
* Raw codec data and parsing needed .
*/
2003-11-10 19:37:55 +01:00
static int is_raw_stream ( AVFormatContext * s )
{
AVStream * st ;
if ( s - > nb_streams ! = 1 )
return 0 ;
st = s - > streams [ 0 ] ;
if ( ! st - > need_parsing )
return 0 ;
return 1 ;
}
2004-10-11 00:05:43 +02:00
/**
2005-06-28 14:55:08 +02:00
* Gets the index for a specific timestamp .
2005-12-17 19:14:38 +01:00
* @ param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
* the timestamp which is < = the requested one , if backward is 0
2004-10-11 00:05:43 +02:00
* then it will be > =
2005-03-13 01:13:01 +01:00
* if AVSEEK_FLAG_ANY seek to any frame , only keyframes otherwise
2004-10-11 00:05:43 +02:00
* @ return < 0 if no such timestamp could be found
*/
2004-11-23 19:23:56 +01:00
int av_index_search_timestamp ( AVStream * st , int64_t wanted_timestamp ,
2005-03-13 01:13:01 +01:00
int flags )
2003-11-10 19:37:55 +01:00
{
2004-01-13 23:02:49 +01:00
AVIndexEntry * entries = st - > index_entries ;
int nb_entries = st - > nb_index_entries ;
2003-11-10 19:37:55 +01:00
int a , b , m ;
int64_t timestamp ;
2004-10-11 00:05:43 +02:00
a = - 1 ;
b = nb_entries ;
2004-01-13 23:02:49 +01:00
2004-10-11 00:05:43 +02:00
while ( b - a > 1 ) {
m = ( a + b ) > > 1 ;
2003-11-10 19:37:55 +01:00
timestamp = entries [ m ] . timestamp ;
2004-10-11 00:05:43 +02:00
if ( timestamp > = wanted_timestamp )
b = m ;
if ( timestamp < = wanted_timestamp )
2004-01-13 23:02:49 +01:00
a = m ;
2003-11-10 19:37:55 +01:00
}
2005-03-13 01:13:01 +01:00
m = ( flags & AVSEEK_FLAG_BACKWARD ) ? a : b ;
2005-12-17 19:14:38 +01:00
2005-03-13 01:13:01 +01:00
if ( ! ( flags & AVSEEK_FLAG_ANY ) ) {
while ( m > = 0 & & m < nb_entries & & ! ( entries [ m ] . flags & AVINDEX_KEYFRAME ) ) {
m + = ( flags & AVSEEK_FLAG_BACKWARD ) ? - 1 : 1 ;
}
}
2004-10-11 00:05:43 +02:00
2005-12-17 19:14:38 +01:00
if ( m = = nb_entries )
2004-10-11 00:05:43 +02:00
return - 1 ;
return m ;
2003-11-10 19:37:55 +01:00
}
2004-04-12 18:50:03 +02:00
# define DEBUG_SEEK
2004-05-23 18:26:12 +02:00
/**
* Does a binary search using av_index_search_timestamp ( ) and AVCodec . read_timestamp ( ) .
* this isnt supposed to be called directly by a user application , but by demuxers
* @ param target_ts target timestamp in the time base of the given stream
* @ param stream_index stream number
*/
2004-10-11 00:05:43 +02:00
int av_seek_frame_binary ( AVFormatContext * s , int stream_index , int64_t target_ts , int flags ) {
2004-04-12 18:50:03 +02:00
AVInputFormat * avif = s - > iformat ;
int64_t pos_min , pos_max , pos , pos_limit ;
int64_t ts_min , ts_max , ts ;
2006-11-14 02:34:36 +01:00
int index ;
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
2004-04-12 18:50:03 +02:00
# ifdef DEBUG_SEEK
2005-12-12 02:56:46 +01:00
av_log ( s , AV_LOG_DEBUG , " read_seek: %d % " PRId64 " \n " , stream_index , target_ts ) ;
2004-04-12 18:50:03 +02:00
# endif
ts_max =
ts_min = AV_NOPTS_VALUE ;
pos_limit = - 1 ; //gcc falsely says it may be uninitalized
st = s - > streams [ stream_index ] ;
if ( st - > index_entries ) {
AVIndexEntry * e ;
2005-03-13 01:13:01 +01:00
index = av_index_search_timestamp ( st , target_ts , flags | AVSEEK_FLAG_BACKWARD ) ; //FIXME whole func must be checked for non keyframe entries in index case, especially read_timestamp()
2004-10-11 00:05:43 +02:00
index = FFMAX ( index , 0 ) ;
2004-04-12 18:50:03 +02:00
e = & st - > index_entries [ index ] ;
if ( e - > timestamp < = target_ts | | e - > pos = = e - > min_distance ) {
pos_min = e - > pos ;
ts_min = e - > timestamp ;
# ifdef DEBUG_SEEK
2005-12-17 19:14:38 +01:00
av_log ( s , AV_LOG_DEBUG , " using cached pos_min=0x% " PRIx64 " dts_min=% " PRId64 " \n " ,
2004-04-12 18:50:03 +02:00
pos_min , ts_min ) ;
# endif
} else {
assert ( index = = 0 ) ;
}
2005-12-17 19:14:38 +01:00
index = av_index_search_timestamp ( st , target_ts , flags & ~ AVSEEK_FLAG_BACKWARD ) ;
2005-03-13 01:13:01 +01:00
assert ( index < st - > nb_index_entries ) ;
if ( index > = 0 ) {
2004-04-12 18:50:03 +02:00
e = & st - > index_entries [ index ] ;
assert ( e - > timestamp > = target_ts ) ;
pos_max = e - > pos ;
ts_max = e - > timestamp ;
pos_limit = pos_max - e - > min_distance ;
# ifdef DEBUG_SEEK
2005-12-17 19:14:38 +01:00
av_log ( s , AV_LOG_DEBUG , " using cached pos_max=0x% " PRIx64 " pos_limit=0x% " PRIx64 " dts_max=% " PRId64 " \n " ,
2004-04-12 18:50:03 +02:00
pos_max , pos_limit , ts_max ) ;
# endif
}
}
2006-11-14 02:34:36 +01:00
pos = av_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 )
return - 1 ;
/* do the seek */
url_fseek ( & s - > pb , pos , SEEK_SET ) ;
av_update_cur_dts ( s , st , ts ) ;
return 0 ;
}
/**
* Does a binary search using read_timestamp ( ) .
* this isnt supposed to be called directly by a user application , but by demuxers
* @ param target_ts target timestamp in the time base of the given stream
* @ param stream_index stream number
*/
int64_t av_gen_search ( AVFormatContext * s , int stream_index , int64_t target_ts , int64_t pos_min , int64_t pos_max , int64_t pos_limit , 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 ) ) {
int64_t pos , ts ;
int64_t start_pos , filesize ;
int no_change ;
# ifdef DEBUG_SEEK
av_log ( s , AV_LOG_DEBUG , " gen_seek: %d % " PRId64 " \n " , stream_index , target_ts ) ;
# endif
2004-04-12 18:50:03 +02:00
if ( ts_min = = AV_NOPTS_VALUE ) {
pos_min = s - > data_offset ;
2006-11-14 02:34:36 +01:00
ts_min = read_timestamp ( s , stream_index , & pos_min , INT64_MAX ) ;
2004-04-12 18:50:03 +02:00
if ( ts_min = = AV_NOPTS_VALUE )
return - 1 ;
}
if ( ts_max = = AV_NOPTS_VALUE ) {
int step = 1024 ;
2005-07-08 11:14:05 +02:00
filesize = url_fsize ( & s - > pb ) ;
pos_max = filesize - 1 ;
2004-04-12 18:50:03 +02:00
do {
pos_max - = step ;
2006-11-14 02:34:36 +01:00
ts_max = read_timestamp ( s , stream_index , & pos_max , pos_max + step ) ;
2004-04-12 18:50:03 +02:00
step + = step ;
} while ( ts_max = = AV_NOPTS_VALUE & & pos_max > = step ) ;
if ( ts_max = = AV_NOPTS_VALUE )
return - 1 ;
2005-12-17 19:14:38 +01:00
2004-04-12 18:50:03 +02:00
for ( ; ; ) {
int64_t tmp_pos = pos_max + 1 ;
2006-11-14 02:34:36 +01:00
int64_t tmp_ts = read_timestamp ( s , stream_index , & tmp_pos , INT64_MAX ) ;
2004-04-12 18:50:03 +02:00
if ( tmp_ts = = AV_NOPTS_VALUE )
break ;
ts_max = tmp_ts ;
pos_max = tmp_pos ;
2005-07-08 11:14:05 +02:00
if ( tmp_pos > = filesize )
break ;
2004-04-12 18:50:03 +02:00
}
pos_limit = pos_max ;
}
2006-02-02 20:23:33 +01:00
if ( ts_min > ts_max ) {
return - 1 ;
} else if ( ts_min = = ts_max ) {
pos_limit = pos_min ;
}
2004-04-12 18:50:03 +02:00
no_change = 0 ;
while ( pos_min < pos_limit ) {
# ifdef DEBUG_SEEK
2005-12-17 19:14:38 +01:00
av_log ( s , AV_LOG_DEBUG , " pos_min=0x% " PRIx64 " pos_max=0x% " PRIx64 " dts_min=% " PRId64 " dts_max=% " PRId64 " \n " ,
2004-04-12 18:50:03 +02:00
pos_min , pos_max ,
ts_min , ts_max ) ;
# endif
assert ( pos_limit < = pos_max ) ;
if ( no_change = = 0 ) {
int64_t approximate_keyframe_distance = pos_max - pos_limit ;
// interpolate position (better than dichotomy)
2004-10-11 00:05:43 +02:00
pos = av_rescale ( target_ts - ts_min , pos_max - pos_min , ts_max - ts_min )
+ pos_min - approximate_keyframe_distance ;
2004-04-12 18:50:03 +02:00
} else if ( no_change = = 1 ) {
// bisection, if interpolation failed to change min or max pos last time
pos = ( pos_min + pos_limit ) > > 1 ;
} else {
// linear search if bisection failed, can only happen if there are very few or no keframes between min/max
pos = pos_min ;
}
if ( pos < = pos_min )
pos = pos_min + 1 ;
else if ( pos > pos_limit )
pos = pos_limit ;
start_pos = pos ;
2006-11-14 02:34:36 +01:00
ts = read_timestamp ( s , stream_index , & pos , INT64_MAX ) ; //may pass pos_limit instead of -1
2004-04-12 18:50:03 +02:00
if ( pos = = pos_max )
no_change + + ;
else
no_change = 0 ;
# ifdef DEBUG_SEEK
2005-12-12 02:56:46 +01:00
av_log ( s , AV_LOG_DEBUG , " % " PRId64 " % " PRId64 " % " PRId64 " / % " PRId64 " % " PRId64 " % " PRId64 " target:% " PRId64 " limit:% " PRId64 " start:% " PRId64 " noc:%d \n " , pos_min , pos , pos_max , ts_min , ts , ts_max , target_ts , pos_limit , start_pos , no_change ) ;
2004-04-12 18:50:03 +02:00
# endif
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 ;
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 ;
ts_min = ts ;
}
}
2005-12-17 19:14:38 +01:00
2004-10-11 00:05:43 +02:00
pos = ( flags & AVSEEK_FLAG_BACKWARD ) ? pos_min : pos_max ;
ts = ( flags & AVSEEK_FLAG_BACKWARD ) ? ts_min : ts_max ;
2004-04-12 18:50:03 +02:00
# ifdef DEBUG_SEEK
pos_min = pos ;
2006-11-14 02:34:36 +01:00
ts_min = read_timestamp ( s , stream_index , & pos_min , INT64_MAX ) ;
2004-04-12 18:50:03 +02:00
pos_min + + ;
2006-11-14 02:34:36 +01:00
ts_max = read_timestamp ( s , stream_index , & pos_min , INT64_MAX ) ;
2005-12-17 19:14:38 +01:00
av_log ( s , AV_LOG_DEBUG , " pos=0x% " PRIx64 " % " PRId64 " <=% " PRId64 " <=% " PRId64 " \n " ,
2004-04-12 18:50:03 +02:00
pos , ts_min , target_ts , ts_max ) ;
# endif
2006-11-14 02:34:36 +01:00
* ts_ret = ts ;
return pos ;
2004-04-12 18:50:03 +02:00
}
2004-10-11 00:05:43 +02:00
static int av_seek_frame_byte ( AVFormatContext * s , int stream_index , int64_t pos , int flags ) {
int64_t pos_min , pos_max ;
#if 0
AVStream * st ;
if ( stream_index < 0 )
return - 1 ;
st = s - > streams [ stream_index ] ;
# endif
pos_min = s - > data_offset ;
2005-05-19 02:06:27 +02:00
pos_max = url_fsize ( & s - > pb ) - 1 ;
2004-10-11 00:05:43 +02:00
if ( pos < pos_min ) pos = pos_min ;
else if ( pos > pos_max ) pos = pos_max ;
url_fseek ( & s - > pb , pos , SEEK_SET ) ;
#if 0
2004-10-12 12:28:27 +02:00
av_update_cur_dts ( s , st , ts ) ;
2004-10-11 00:05:43 +02:00
# endif
return 0 ;
}
2005-12-17 19:14:38 +01:00
static int av_seek_frame_generic ( AVFormatContext * s ,
2004-10-11 00:05:43 +02:00
int stream_index , int64_t timestamp , int flags )
2003-11-10 19:37:55 +01:00
{
2004-10-12 12:28:27 +02:00
int index ;
2003-11-10 19:37:55 +01:00
AVStream * st ;
AVIndexEntry * ie ;
if ( ! s - > index_built ) {
if ( is_raw_stream ( s ) ) {
av_build_index_raw ( s ) ;
} else {
return - 1 ;
}
s - > index_built = 1 ;
}
st = s - > streams [ stream_index ] ;
2005-03-13 01:13:01 +01:00
index = av_index_search_timestamp ( st , timestamp , flags ) ;
2003-11-10 19:37:55 +01:00
if ( index < 0 )
return - 1 ;
/* now we have found the index, we can seek */
ie = & st - > index_entries [ index ] ;
av_read_frame_flush ( s ) ;
url_fseek ( & s - > pb , ie - > pos , SEEK_SET ) ;
2004-10-11 00:05:43 +02:00
2004-10-12 12:28:27 +02:00
av_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 ;
}
/**
2004-10-11 00:05:43 +02:00
* Seek to the key frame at timestamp .
2004-05-23 18:26:12 +02:00
* ' timestamp ' in ' stream_index ' .
* @ param stream_index If stream_index is ( - 1 ) , a default
2005-12-17 19:14:38 +01:00
* stream is selected , and timestamp is automatically converted
2004-10-11 21:42:18 +02:00
* from AV_TIME_BASE units to the stream specific time_base .
2004-10-11 00:05:43 +02:00
* @ param timestamp timestamp in AVStream . time_base units
2005-07-05 11:07:51 +02:00
* or if there is no stream specified then in AV_TIME_BASE units
2004-10-11 00:05:43 +02:00
* @ param flags flags which select direction and seeking mode
2004-05-23 18:26:12 +02:00
* @ return > = 0 on success
2003-11-10 19:37:55 +01:00
*/
2004-10-11 00:05:43 +02:00
int av_seek_frame ( 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
2003-11-10 19:37:55 +01:00
av_read_frame_flush ( s ) ;
2005-12-17 19:14:38 +01:00
2004-10-11 00:05:43 +02:00
if ( flags & AVSEEK_FLAG_BYTE )
return av_seek_frame_byte ( s , stream_index , timestamp , flags ) ;
2005-12-17 19:14:38 +01:00
2004-05-23 18:26:12 +02:00
if ( stream_index < 0 ) {
stream_index = av_find_default_stream_index ( s ) ;
if ( stream_index < 0 )
return - 1 ;
2005-12-17 19:14:38 +01:00
2004-10-11 00:05:43 +02:00
st = s - > streams [ stream_index ] ;
2004-10-11 21:42:18 +02:00
/* timestamp for default must be expressed in AV_TIME_BASE units */
2004-10-11 00:05:43 +02: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
}
st = s - > streams [ stream_index ] ;
2003-11-10 19:37:55 +01:00
/* first, we try the format specific seek */
if ( s - > iformat - > read_seek )
2004-10-11 00:05:43 +02:00
ret = s - > iformat - > read_seek ( s , stream_index , timestamp , flags ) ;
2003-11-10 19:37:55 +01:00
else
ret = - 1 ;
if ( ret > = 0 ) {
return 0 ;
}
2004-04-12 18:50:03 +02:00
if ( s - > iformat - > read_timestamp )
2004-10-11 00:05:43 +02:00
return av_seek_frame_binary ( s , stream_index , timestamp , flags ) ;
2004-04-12 18:50:03 +02:00
else
2004-10-11 00:05:43 +02:00
return av_seek_frame_generic ( s , stream_index , timestamp , flags ) ;
2003-11-10 19:37:55 +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
/**
* Returns TRUE if the stream has accurate timings in any stream .
*
* @ return TRUE if the stream has accurate timings for at least one component .
*/
2003-08-08 20:02:23 +02:00
static int av_has_timings ( AVFormatContext * ic )
{
int i ;
AVStream * st ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > start_time ! = AV_NOPTS_VALUE & &
st - > duration ! = AV_NOPTS_VALUE )
return 1 ;
}
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 .
*/
2003-08-08 20:02:23 +02:00
static void av_update_stream_timings ( AVFormatContext * ic )
{
2005-04-30 23:43:59 +02:00
int64_t start_time , start_time1 , end_time , end_time1 ;
2003-08-08 20:02:23 +02:00
int i ;
AVStream * st ;
2006-12-07 01:47:37 +01:00
start_time = INT64_MAX ;
end_time = INT64_MIN ;
2003-08-08 20:02:23 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > start_time ! = AV_NOPTS_VALUE ) {
2005-04-30 23:43:59 +02:00
start_time1 = av_rescale_q ( st - > start_time , st - > time_base , AV_TIME_BASE_Q ) ;
if ( start_time1 < start_time )
start_time = start_time1 ;
2003-08-08 20:02:23 +02:00
if ( st - > duration ! = AV_NOPTS_VALUE ) {
2005-04-30 23:43:59 +02:00
end_time1 = start_time1
+ av_rescale_q ( st - > duration , st - > time_base , AV_TIME_BASE_Q ) ;
2003-08-08 20:02:23 +02:00
if ( end_time1 > end_time )
end_time = end_time1 ;
}
}
}
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 ;
2006-12-07 01:47:37 +01:00
if ( end_time ! = INT64_MIN ) {
2003-08-08 20:02:23 +02:00
ic - > duration = end_time - start_time ;
if ( ic - > file_size > 0 ) {
/* compute the bit rate */
2005-12-17 19:14:38 +01:00
ic - > bit_rate = ( double ) ic - > file_size * 8.0 * AV_TIME_BASE /
2003-08-08 20:02:23 +02:00
( double ) ic - > duration ;
}
}
}
}
static void fill_all_stream_timings ( AVFormatContext * ic )
{
int i ;
AVStream * st ;
av_update_stream_timings ( ic ) ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > start_time = = AV_NOPTS_VALUE ) {
2005-04-30 23:43:59 +02: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
}
}
}
static void av_estimate_timings_from_bit_rate ( AVFormatContext * ic )
{
int64_t filesize , duration ;
int bit_rate , i ;
AVStream * st ;
/* if bit_rate is already set, we believe it */
if ( ic - > bit_rate = = 0 ) {
bit_rate = 0 ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
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 & &
ic - > bit_rate ! = 0 & &
2003-08-08 20:02:23 +02:00
ic - > file_size ! = 0 ) {
filesize = ic - > file_size ;
if ( filesize > 0 ) {
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-04-30 23:43:59 +02: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
if ( st - > start_time = = AV_NOPTS_VALUE | |
st - > duration = = AV_NOPTS_VALUE ) {
st - > start_time = 0 ;
st - > duration = duration ;
}
}
}
}
}
# define DURATION_MAX_READ_SIZE 250000
/* only usable for MPEG-PS streams */
static void av_estimate_timings_from_pts ( AVFormatContext * ic )
{
AVPacket pkt1 , * pkt = & pkt1 ;
AVStream * st ;
int read_size , i , ret ;
2005-08-14 17:42:40 +02:00
int64_t end_time ;
2003-08-08 20:02:23 +02:00
int64_t filesize , offset , duration ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* free previous packet */
if ( ic - > cur_st & & ic - > cur_st - > parser )
2005-12-17 19:14:38 +01:00
av_free_packet ( & ic - > cur_pkt ) ;
2003-11-10 19:37:55 +01:00
ic - > cur_st = NULL ;
/* flush packet queue */
flush_packet_queue ( ic ) ;
2004-06-30 19:34:15 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > parser ) {
av_parser_close ( st - > parser ) ;
st - > parser = NULL ;
}
}
2005-12-17 19:14:38 +01:00
2003-08-08 20:02:23 +02:00
/* we read the first packets to get the first PTS (not fully
accurate , but it is enough now ) */
url_fseek ( & ic - > pb , 0 , SEEK_SET ) ;
read_size = 0 ;
for ( ; ; ) {
if ( read_size > = DURATION_MAX_READ_SIZE )
break ;
/* if all info is available, we can stop */
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > start_time = = AV_NOPTS_VALUE )
break ;
}
if ( i = = ic - > nb_streams )
break ;
ret = av_read_packet ( ic , pkt ) ;
if ( ret ! = 0 )
break ;
read_size + = pkt - > size ;
st = ic - > streams [ pkt - > stream_index ] ;
if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
if ( st - > start_time = = AV_NOPTS_VALUE )
2005-04-30 23:43:59 +02:00
st - > start_time = pkt - > pts ;
2003-09-07 11:26:39 +02:00
}
av_free_packet ( pkt ) ;
}
2003-08-08 20:02:23 +02:00
/* estimate the end time (duration) */
/* XXX: may need to support wrapping */
filesize = ic - > file_size ;
offset = filesize - DURATION_MAX_READ_SIZE ;
if ( offset < 0 )
offset = 0 ;
url_fseek ( & ic - > pb , offset , SEEK_SET ) ;
read_size = 0 ;
for ( ; ; ) {
if ( read_size > = DURATION_MAX_READ_SIZE )
break ;
/* if all info is available, we can stop */
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > duration = = AV_NOPTS_VALUE )
break ;
}
if ( i = = ic - > nb_streams )
break ;
2005-12-17 19:14:38 +01:00
2003-08-08 20:02:23 +02:00
ret = av_read_packet ( ic , pkt ) ;
if ( ret ! = 0 )
break ;
read_size + = pkt - > size ;
st = ic - > streams [ pkt - > stream_index ] ;
if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
2005-04-30 23:43:59 +02:00
end_time = pkt - > pts ;
2003-08-08 20:02:23 +02:00
duration = end_time - st - > start_time ;
if ( duration > 0 ) {
if ( st - > duration = = AV_NOPTS_VALUE | |
st - > duration < duration )
st - > duration = duration ;
}
}
av_free_packet ( pkt ) ;
}
2005-12-17 19:14:38 +01:00
2005-04-30 23:43:59 +02:00
fill_all_stream_timings ( ic ) ;
2003-08-08 20:02:23 +02:00
url_fseek ( & ic - > pb , 0 , SEEK_SET ) ;
}
static void av_estimate_timings ( AVFormatContext * ic )
{
int64_t file_size ;
/* get the file size, if possible */
if ( ic - > iformat - > flags & AVFMT_NOFILE ) {
file_size = 0 ;
} else {
2005-05-19 02:06:27 +02:00
file_size = url_fsize ( & ic - > pb ) ;
2003-08-08 20:02:23 +02:00
if ( file_size < 0 )
file_size = 0 ;
}
ic - > file_size = file_size ;
2006-07-10 23:14:37 +02:00
if ( ( ! strcmp ( ic - > iformat - > name , " mpeg " ) | |
! strcmp ( ic - > iformat - > name , " mpegts " ) ) & &
file_size & & ! ic - > pb . is_streamed ) {
2003-08-08 20:02:23 +02:00
/* get accurate estimate from the PTSes */
av_estimate_timings_from_pts ( ic ) ;
} else if ( av_has_timings ( ic ) ) {
/* at least one components has timings - we use them for all
the components */
fill_all_stream_timings ( ic ) ;
} else {
/* less precise: use bit rate info */
av_estimate_timings_from_bit_rate ( ic ) ;
}
av_update_stream_timings ( ic ) ;
#if 0
{
int i ;
AVStream * st ;
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-12-17 19:14:38 +01:00
printf ( " %d: start_time: %0.3f duration: %0.3f \n " ,
i , ( double ) st - > start_time / AV_TIME_BASE ,
2003-08-08 20:02:23 +02:00
( double ) st - > duration / AV_TIME_BASE ) ;
}
2005-12-17 19:14:38 +01:00
printf ( " stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s \n " ,
( double ) ic - > start_time / AV_TIME_BASE ,
2003-08-08 20:02:23 +02:00
( double ) ic - > duration / AV_TIME_BASE ,
ic - > bit_rate / 1000 ) ;
}
# endif
}
2002-05-20 18:28:47 +02:00
static int has_codec_parameters ( AVCodecContext * enc )
{
int val ;
switch ( enc - > codec_type ) {
case CODEC_TYPE_AUDIO :
val = enc - > sample_rate ;
break ;
case CODEC_TYPE_VIDEO :
2005-04-25 20:29:06 +02:00
val = enc - > width & & enc - > pix_fmt ! = PIX_FMT_NONE ;
2002-05-20 18:28:47 +02:00
break ;
default :
val = 1 ;
break ;
}
return ( val ! = 0 ) ;
}
2003-11-10 19:37:55 +01:00
static int try_decode_frame ( AVStream * st , const uint8_t * data , int size )
{
int16_t * samples ;
AVCodec * codec ;
2005-06-27 22:54:36 +02:00
int got_picture , ret = 0 ;
2003-11-10 19:37:55 +01:00
AVFrame picture ;
2005-12-17 19:14:38 +01:00
2005-07-18 00:24:36 +02:00
if ( ! st - > codec - > codec ) {
codec = avcodec_find_decoder ( st - > codec - > codec_id ) ;
2003-11-10 19:37:55 +01:00
if ( ! codec )
return - 1 ;
2005-07-18 00:24:36 +02:00
ret = avcodec_open ( st - > codec , codec ) ;
2003-11-10 19:37:55 +01:00
if ( ret < 0 )
return ret ;
2005-06-27 22:54:36 +02:00
}
2005-04-25 20:29:06 +02:00
2005-07-18 00:24:36 +02:00
if ( ! has_codec_parameters ( st - > codec ) ) {
switch ( st - > codec - > codec_type ) {
2003-11-10 19:37:55 +01:00
case CODEC_TYPE_VIDEO :
2005-12-17 19:14:38 +01:00
ret = avcodec_decode_video ( st - > codec , & picture ,
2003-11-10 19:37:55 +01:00
& got_picture , ( uint8_t * ) data , size ) ;
break ;
case CODEC_TYPE_AUDIO :
samples = av_malloc ( AVCODEC_MAX_AUDIO_FRAME_SIZE ) ;
if ( ! samples )
goto fail ;
2005-12-17 19:14:38 +01:00
ret = avcodec_decode_audio ( st - > codec , samples ,
2003-11-10 19:37:55 +01:00
& got_picture , ( uint8_t * ) data , size ) ;
av_free ( samples ) ;
break ;
default :
break ;
}
2005-04-25 20:29:06 +02:00
}
2003-11-10 19:37:55 +01:00
fail :
return ret ;
}
/* absolute maximum size we read until we abort */
# define MAX_READ_SIZE 5000000
2006-12-12 15:07:46 +01:00
# define MAX_STD_TIMEBASES (60*12+5)
2006-12-11 17:59:10 +01:00
static int get_std_framerate ( int i ) {
if ( i < 60 * 12 ) return i * 1001 ;
2006-12-12 15:07:46 +01:00
else return ( ( int [ ] ) { 24 , 30 , 60 , 12 , 15 } ) [ i - 60 * 12 ] * 1000 * 12 ;
2006-12-11 17:59:10 +01:00
}
2002-05-20 18:28:47 +02:00
/**
* Read the beginning of a media file to get stream information . This
* is useful for file formats with no headers such as MPEG . This
* function also compute the real frame rate in case of mpeg2 repeat
* frame mode .
*
* @ param ic media file handle
2005-12-17 19:14:38 +01:00
* @ return > = 0 if OK . AVERROR_xxx if error .
2005-04-25 20:29:06 +02:00
* @ todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
2002-05-20 18:28:47 +02:00
*/
int av_find_stream_info ( AVFormatContext * ic )
{
2006-02-02 21:54:41 +01:00
int i , count , ret , read_size , j ;
2002-05-20 18:28:47 +02:00
AVStream * st ;
2003-11-10 19:37:55 +01:00
AVPacket pkt1 , * pkt ;
2002-05-20 18:28:47 +02:00
AVPacketList * pktl = NULL , * * ppktl ;
2004-12-19 02:23:22 +01:00
int64_t last_dts [ MAX_STREAMS ] ;
2005-05-07 01:41:47 +02:00
int duration_count [ MAX_STREAMS ] = { 0 } ;
2006-12-11 17:59:10 +01:00
double duration_error [ MAX_STREAMS ] [ MAX_STD_TIMEBASES ] = { { 0 } } ; //FIXME malloc()?
2002-05-20 18:28:47 +02:00
2005-04-30 23:43:59 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
2005-04-30 23:43:59 +02:00
/* if(!st->time_base.num)
st - > time_base = */
2005-07-18 00:24:36 +02:00
if ( ! st - > codec - > time_base . num )
st - > codec - > time_base = st - > time_base ;
2005-04-30 23:43:59 +02:00
}
2005-06-27 02:04:03 +02:00
//only for the split stuff
if ( ! st - > parser ) {
2005-07-18 00:24:36 +02:00
st - > parser = av_parser_init ( st - > codec - > codec_id ) ;
2005-08-15 17:58:21 +02:00
if ( st - > need_parsing = = 2 & & st - > parser ) {
st - > parser - > flags | = PARSER_FLAG_COMPLETE_FRAMES ;
}
2005-06-27 02:04:03 +02:00
}
2005-04-30 23:43:59 +02:00
}
2004-12-19 02:23:22 +01:00
for ( i = 0 ; i < MAX_STREAMS ; i + + ) {
last_dts [ i ] = AV_NOPTS_VALUE ;
}
2005-12-17 19:14:38 +01:00
2002-05-20 18:28:47 +02:00
count = 0 ;
read_size = 0 ;
ppktl = & ic - > packet_buffer ;
for ( ; ; ) {
/* check if one codec still needs to be handled */
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( ! has_codec_parameters ( st - > codec ) )
2002-05-20 18:28:47 +02:00
break ;
2004-12-21 03:16:11 +01:00
/* variable fps and no guess at the real fps */
2006-02-02 21:54:41 +01:00
if ( st - > codec - > time_base . den > = 101LL * st - > codec - > time_base . num
2005-07-18 00:24:36 +02:00
& & duration_count [ i ] < 20 & & st - > codec - > codec_type = = CODEC_TYPE_VIDEO )
2004-12-21 03:16:11 +01:00
break ;
2005-07-18 00:24:36 +02:00
if ( st - > parser & & st - > parser - > parser - > split & & ! st - > codec - > extradata )
2005-06-27 02:04:03 +02:00
break ;
2002-05-20 18:28:47 +02:00
}
if ( i = = ic - > nb_streams ) {
/* 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 ) ) {
2002-05-20 18:28:47 +02:00
/* if we found the info for all the codecs, we can stop */
ret = count ;
break ;
}
2006-09-26 19:25:28 +02:00
}
2006-09-26 19:27:08 +02:00
/* we did not get all the codec info, but we read too much data */
if ( read_size > = MAX_READ_SIZE ) {
ret = count ;
break ;
}
2002-05-20 18:28:47 +02:00
2003-11-10 19:37:55 +01:00
/* NOTE: a new stream can be added there if no header in file
( AVFMTCTX_NOHEADER ) */
ret = av_read_frame_internal ( ic , & pkt1 ) ;
if ( ret < 0 ) {
/* EOF or error */
ret = - 1 ; /* we could not have all the codec parameters before EOF */
2005-01-22 03:30:45 +01:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2006-03-21 12:29:50 +01:00
if ( ! has_codec_parameters ( st - > codec ) ) {
char buf [ 256 ] ;
avcodec_string ( buf , sizeof ( buf ) , st - > codec , 0 ) ;
av_log ( ic , AV_LOG_INFO , " Could not find codec parameters (%s) \n " , buf ) ;
2006-06-29 21:02:15 +02:00
} else {
ret = 0 ;
2006-03-21 12:29:50 +01:00
}
2005-01-22 03:30:45 +01:00
}
2003-11-10 19:37:55 +01:00
break ;
}
2002-05-20 18:28:47 +02:00
pktl = av_mallocz ( sizeof ( AVPacketList ) ) ;
if ( ! pktl ) {
ret = AVERROR_NOMEM ;
break ;
}
/* add the packet in the buffered packet list */
* ppktl = pktl ;
ppktl = & pktl - > next ;
pkt = & pktl - > pkt ;
2003-11-10 19:37:55 +01:00
* pkt = pkt1 ;
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +01:00
/* duplicate the packet */
if ( av_dup_packet ( pkt ) < 0 ) {
2006-11-01 22:09:14 +01:00
ret = AVERROR_NOMEM ;
break ;
2002-05-20 18:28:47 +02:00
}
2003-11-10 19:37:55 +01:00
read_size + = pkt - > size ;
2002-05-20 18:28:47 +02:00
st = ic - > streams [ pkt - > stream_index ] ;
2006-12-29 22:41:06 +01:00
if ( st - > codec_info_nb_frames > 1 ) //FIXME move codec_info_nb_frames and codec_info_duration from AVStream into this func
st - > codec_info_duration + = pkt - > duration ;
2003-11-10 19:37:55 +01:00
if ( pkt - > duration ! = 0 )
st - > codec_info_nb_frames + + ;
2005-05-22 10:47:09 +02:00
{
2005-05-07 01:41:47 +02:00
int index = pkt - > stream_index ;
int64_t last = last_dts [ index ] ;
int64_t duration = pkt - > dts - last ;
if ( pkt - > dts ! = AV_NOPTS_VALUE & & last ! = AV_NOPTS_VALUE & & duration > 0 ) {
2006-12-11 17:59:10 +01:00
double dur = duration * av_q2d ( st - > time_base ) ;
// if(st->codec->codec_type == CODEC_TYPE_VIDEO)
// av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2007-01-02 21:32:01 +01:00
if ( duration_count [ index ] < 2 )
memset ( duration_error , 0 , sizeof ( duration_error ) ) ;
2007-01-02 21:35:46 +01:00
for ( i = 1 ; i < MAX_STD_TIMEBASES ; i + + ) {
int framerate = get_std_framerate ( i ) ;
int ticks = lrintf ( dur * framerate / ( 1001 * 12 ) ) ;
double error = dur - ticks * 1001 * 12 / ( double ) framerate ;
duration_error [ index ] [ i ] + = error * error ;
}
2006-12-11 17:59:10 +01:00
duration_count [ index ] + + ;
2005-06-27 22:54:36 +02:00
if ( st - > codec_info_nb_frames = = 0 & & 0 )
2005-05-22 10:47:09 +02:00
st - > codec_info_duration + = duration ;
2004-12-19 02:23:22 +01:00
}
2006-12-12 15:07:46 +01:00
if ( last = = AV_NOPTS_VALUE | | duration_count [ index ] < = 1 )
last_dts [ pkt - > stream_index ] = pkt - > dts ;
2004-12-19 02:23:22 +01:00
}
2005-07-18 00:24:36 +02:00
if ( st - > parser & & st - > parser - > parser - > split & & ! st - > codec - > extradata ) {
int i = st - > parser - > parser - > split ( st - > codec , pkt - > data , pkt - > size ) ;
2005-06-27 02:04:03 +02:00
if ( i ) {
2005-07-18 00:24:36 +02:00
st - > codec - > extradata_size = i ;
2006-06-29 21:42:34 +02:00
st - > codec - > extradata = av_malloc ( st - > codec - > extradata_size + FF_INPUT_BUFFER_PADDING_SIZE ) ;
2005-07-18 00:24:36 +02:00
memcpy ( st - > codec - > extradata , pkt - > data , st - > codec - > extradata_size ) ;
2006-06-29 21:42:34 +02:00
memset ( st - > codec - > extradata + i , 0 , FF_INPUT_BUFFER_PADDING_SIZE ) ;
2005-06-27 02:04:03 +02:00
}
}
2005-12-17 19:14:38 +01:00
2003-11-10 19:37:55 +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 MPEG4 , we need to
decompress for Quicktime . */
2005-07-18 00:24:36 +02:00
if ( ! has_codec_parameters ( st - > codec ) /*&&
( st - > codec - > codec_id = = CODEC_ID_FLV1 | |
st - > codec - > codec_id = = CODEC_ID_H264 | |
st - > codec - > codec_id = = CODEC_ID_H263 | |
st - > codec - > codec_id = = CODEC_ID_H261 | |
st - > codec - > codec_id = = CODEC_ID_VORBIS | |
st - > codec - > codec_id = = CODEC_ID_MJPEG | |
st - > codec - > codec_id = = CODEC_ID_PNG | |
st - > codec - > codec_id = = CODEC_ID_PAM | |
st - > codec - > codec_id = = CODEC_ID_PGM | |
st - > codec - > codec_id = = CODEC_ID_PGMYUV | |
st - > codec - > codec_id = = CODEC_ID_PBM | |
st - > codec - > codec_id = = CODEC_ID_PPM | |
st - > codec - > codec_id = = CODEC_ID_SHORTEN | |
( st - > codec - > codec_id = = CODEC_ID_MPEG4 & & ! st - > need_parsing ) ) */ )
2003-11-10 19:37:55 +01:00
try_decode_frame ( st , pkt - > data , pkt - > size ) ;
2005-12-17 19:14:38 +01:00
2007-01-23 18:34:26 +01:00
if ( av_rescale_q ( st - > codec_info_duration , st - > time_base , AV_TIME_BASE_Q ) > = ic - > max_analyze_duration ) {
2003-11-10 19:37:55 +01:00
break ;
2002-05-20 18:28:47 +02:00
}
count + + ;
}
2005-06-27 22:54:36 +02:00
// close codecs which where opened in try_decode_frame()
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec )
avcodec_close ( st - > codec ) ;
2005-06-27 22:54:36 +02:00
}
2002-05-20 18:28:47 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
if ( st - > codec - > codec_id = = CODEC_ID_RAWVIDEO & & ! st - > codec - > codec_tag & & ! st - > codec - > bits_per_sample )
st - > codec - > codec_tag = avcodec_pix_fmt_to_codec_tag ( st - > codec - > pix_fmt ) ;
2004-12-19 02:23:22 +01:00
2007-01-02 21:32:01 +01:00
if ( duration_count [ i ]
2006-12-11 17:59:10 +01:00
& & ( st - > codec - > time_base . num * 101LL < = st - > codec - > time_base . den | | st - > codec - > codec_id = = CODEC_ID_MPEG2VIDEO ) /*&&
2006-09-26 20:34:07 +02:00
//FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
2006-12-11 17:59:10 +01:00
st - > time_base . num * duration_sum [ i ] / duration_count [ i ] * 101LL > st - > time_base . den */ ) {
double best_error = 2 * av_q2d ( st - > time_base ) ;
best_error = best_error * best_error * duration_count [ i ] * 1000 * 12 * 30 ;
for ( j = 1 ; j < MAX_STD_TIMEBASES ; j + + ) {
double error = duration_error [ i ] [ j ] * get_std_framerate ( j ) ;
// if(st->codec->codec_type == CODEC_TYPE_VIDEO)
// av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2006-02-02 21:54:41 +01:00
if ( error < best_error ) {
best_error = error ;
2006-12-11 17:59:10 +01:00
av_reduce ( & st - > r_frame_rate . num , & st - > r_frame_rate . den , get_std_framerate ( j ) , 12 * 1001 , INT_MAX ) ;
2006-02-02 21:54:41 +01:00
}
2005-05-07 01:41:47 +02:00
}
2004-12-19 02:23:22 +01:00
}
2005-04-30 23:43:59 +02:00
if ( ! st - > r_frame_rate . num ) {
2006-10-03 21:13:27 +02:00
if ( st - > codec - > time_base . den * ( int64_t ) st - > time_base . num
< = st - > codec - > time_base . num * ( int64_t ) st - > time_base . den ) {
st - > r_frame_rate . num = st - > codec - > time_base . den ;
st - > r_frame_rate . den = st - > codec - > time_base . num ;
} else {
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
}
2002-05-20 18:28:47 +02:00
}
2001-07-22 16:18:56 +02:00
}
2002-05-20 18:28:47 +02:00
2003-08-08 20:02:23 +02:00
av_estimate_timings ( ic ) ;
2004-05-29 04:06:32 +02:00
#if 0
/* correct DTS for b frame streams with no timestamps */
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
2004-05-29 04:06:32 +02:00
if ( b - frames ) {
ppktl = & ic - > packet_buffer ;
while ( ppkt1 ) {
if ( ppkt1 - > stream_index ! = i )
continue ;
if ( ppkt1 - > pkt - > dts < 0 )
break ;
if ( ppkt1 - > pkt - > pts ! = AV_NOPTS_VALUE )
break ;
ppkt1 - > pkt - > dts - = delta ;
ppkt1 = ppkt1 - > next ;
}
if ( ppkt1 )
continue ;
st - > cur_dts - = delta ;
}
}
}
# endif
2002-05-20 18:28:47 +02:00
return ret ;
2001-07-22 16:18:56 +02:00
}
2003-11-10 19:37:55 +01:00
/*******************************************************/
/**
* start playing a network based stream ( e . g . RTSP stream ) at the
2005-12-17 19:14:38 +01:00
* current position
2003-11-10 19:37:55 +01:00
*/
int av_read_play ( AVFormatContext * s )
{
if ( ! s - > iformat - > read_play )
return AVERROR_NOTSUPP ;
return s - > iformat - > read_play ( s ) ;
}
/**
2005-06-28 14:55:08 +02:00
* Pause a network based stream ( e . g . RTSP stream ) .
*
* Use av_read_play ( ) to resume it .
2003-11-10 19:37:55 +01:00
*/
int av_read_pause ( AVFormatContext * s )
{
if ( ! s - > iformat - > read_pause )
return AVERROR_NOTSUPP ;
return s - > iformat - > read_pause ( s ) ;
}
2002-05-20 18:28:47 +02:00
/**
2005-06-28 14:55:08 +02:00
* Close a media file ( but not its codecs ) .
2002-05-20 18:28:47 +02:00
*
* @ param s media file handle
*/
2001-07-22 16:18:56 +02:00
void av_close_input_file ( AVFormatContext * s )
{
2003-07-15 18:57:35 +02:00
int i , must_open_file ;
2003-10-29 15:20:56 +01:00
AVStream * st ;
2001-07-22 16:18:56 +02:00
2003-11-10 19:37:55 +01:00
/* free previous packet */
if ( s - > cur_st & & s - > cur_st - > parser )
2005-12-17 19:14:38 +01:00
av_free_packet ( & s - > cur_pkt ) ;
2003-11-10 19:37:55 +01:00
2002-05-20 18:28:47 +02:00
if ( s - > iformat - > read_close )
s - > iformat - > read_close ( s ) ;
2001-07-22 16:18:56 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2003-10-29 15:20:56 +01:00
/* free all data in a stream component */
st = s - > streams [ i ] ;
2003-11-10 19:37:55 +01:00
if ( st - > parser ) {
av_parser_close ( st - > parser ) ;
2001-07-22 16:18:56 +02:00
}
2003-11-10 19:37:55 +01:00
av_free ( st - > index_entries ) ;
2006-06-16 09:54:37 +02:00
av_free ( st - > codec - > extradata ) ;
2005-07-18 00:24:36 +02:00
av_free ( st - > codec ) ;
2003-11-10 19:37:55 +01:00
av_free ( st ) ;
2001-07-22 16:18:56 +02:00
}
2003-11-10 19:37:55 +01:00
flush_packet_queue ( s ) ;
2003-07-15 18:57:35 +02:00
must_open_file = 1 ;
2003-10-29 15:20:56 +01:00
if ( s - > iformat - > flags & AVFMT_NOFILE ) {
2003-07-15 18:57:35 +02:00
must_open_file = 0 ;
}
if ( must_open_file ) {
2001-09-25 01:25:28 +02:00
url_fclose ( & s - > pb ) ;
}
2002-05-24 04:09:40 +02:00
av_freep ( & s - > priv_data ) ;
2002-05-19 01:11:09 +02:00
av_free ( s ) ;
2001-07-22 16:18:56 +02:00
}
2002-05-20 18:28:47 +02:00
/**
2005-06-28 14:55:08 +02:00
* Add a new stream to a media file .
2002-05-20 18:28:47 +02:00
*
2005-06-28 14:55:08 +02:00
* Can only be called in the read_header ( ) function . If the flag
* AVFMTCTX_NOHEADER is in the format context , then new streams
* can be added in read_packet too .
2002-05-20 18:28:47 +02:00
*
* @ param s media file handle
2005-12-17 19:14:38 +01:00
* @ param id file format dependent stream id
2002-05-20 18:28:47 +02:00
*/
AVStream * av_new_stream ( AVFormatContext * s , int id )
{
AVStream * st ;
2006-08-30 23:18:17 +02:00
int i ;
2002-05-20 18:28:47 +02:00
if ( s - > nb_streams > = MAX_STREAMS )
return NULL ;
st = av_mallocz ( sizeof ( AVStream ) ) ;
if ( ! st )
return NULL ;
2005-12-17 19:14:38 +01:00
2005-07-18 00:24:36 +02:00
st - > codec = avcodec_alloc_context ( ) ;
2003-08-08 20:13:43 +02:00
if ( s - > iformat ) {
/* no default bitrate if decoding */
2005-07-18 00:24:36 +02:00
st - > codec - > bit_rate = 0 ;
2003-08-08 20:13:43 +02:00
}
2002-05-20 18:28:47 +02:00
st - > index = s - > nb_streams ;
st - > id = id ;
2003-08-08 20:02:23 +02:00
st - > start_time = AV_NOPTS_VALUE ;
st - > duration = AV_NOPTS_VALUE ;
2004-05-29 04:06:32 +02:00
st - > cur_dts = AV_NOPTS_VALUE ;
2004-05-21 22:43:21 +02:00
/* default pts settings is MPEG like */
av_set_pts_info ( st , 33 , 1 , 90000 ) ;
2004-05-23 23:36:23 +02:00
st - > last_IP_pts = AV_NOPTS_VALUE ;
2006-08-30 23:18:17 +02: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
2002-05-20 18:28:47 +02:00
s - > streams [ s - > nb_streams + + ] = st ;
return st ;
}
/************************************************************/
/* output media file */
2001-07-22 16:18:56 +02:00
2003-01-11 06:02:14 +01:00
int av_set_parameters ( AVFormatContext * s , AVFormatParameters * ap )
{
int ret ;
2005-12-17 19:14:38 +01:00
2003-01-23 23:00:57 +01:00
if ( s - > oformat - > priv_data_size > 0 ) {
s - > priv_data = av_mallocz ( s - > oformat - > priv_data_size ) ;
if ( ! s - > priv_data )
return AVERROR_NOMEM ;
} else
s - > priv_data = NULL ;
2005-12-17 19:14:38 +01:00
2003-01-11 06:02:14 +01:00
if ( s - > oformat - > set_parameters ) {
ret = s - > oformat - > set_parameters ( s , ap ) ;
if ( ret < 0 )
return ret ;
}
return 0 ;
}
2002-05-20 18:28:47 +02:00
/**
* allocate the stream private data and write the stream header to an
* output media file
*
* @ param s media file handle
2005-12-17 19:14:38 +01:00
* @ return 0 if OK . AVERROR_xxx if error .
2002-05-20 18:28:47 +02:00
*/
int av_write_header ( AVFormatContext * s )
{
2002-10-21 19:40:23 +02:00
int ret , i ;
AVStream * st ;
2005-08-14 18:19:20 +02:00
// some sanity checks
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
st = s - > streams [ i ] ;
switch ( st - > codec - > codec_type ) {
case CODEC_TYPE_AUDIO :
if ( st - > codec - > sample_rate < = 0 ) {
av_log ( s , AV_LOG_ERROR , " sample rate not set \n " ) ;
return - 1 ;
}
break ;
case CODEC_TYPE_VIDEO :
if ( st - > codec - > time_base . num < = 0 | | st - > codec - > time_base . den < = 0 ) { //FIXME audio too?
av_log ( s , AV_LOG_ERROR , " time base not set \n " ) ;
return - 1 ;
}
if ( st - > codec - > width < = 0 | | st - > codec - > height < = 0 ) {
av_log ( s , AV_LOG_ERROR , " dimensions not set \n " ) ;
return - 1 ;
}
break ;
}
2007-01-21 13:31:58 +01:00
if ( s - > oformat - > codec_tag ) {
if ( st - > codec - > codec_tag ) {
//FIXME
//check that tag + id is in the table
//if neither is in the table -> ok
//if tag is in the table with another id -> FAIL
//if id is in the table with another tag -> FAIL unless strict < ?
} else
st - > codec - > codec_tag = av_codec_get_tag ( s - > oformat - > codec_tag , st - > codec - > codec_id ) ;
}
2005-08-14 18:19:20 +02:00
}
2007-01-08 15:22:00 +01:00
if ( ! s - > priv_data & & s - > oformat - > priv_data_size > 0 ) {
2007-01-08 13:57:08 +01:00
s - > priv_data = av_mallocz ( s - > oformat - > priv_data_size ) ;
if ( ! s - > priv_data )
return AVERROR_NOMEM ;
2007-01-08 15:22:00 +01:00
}
2007-01-08 13:57:08 +01:00
2005-11-05 00:50:11 +01:00
if ( s - > oformat - > write_header ) {
ret = s - > oformat - > write_header ( s ) ;
if ( ret < 0 )
return ret ;
}
2002-10-21 19:40:23 +02:00
/* init PTS generation */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2005-08-14 18:37:29 +02:00
int64_t den = AV_NOPTS_VALUE ;
2002-10-21 19:40:23 +02:00
st = s - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2002-10-21 19:40:23 +02:00
case CODEC_TYPE_AUDIO :
2005-08-14 18:37:29 +02:00
den = ( int64_t ) st - > time_base . num * st - > codec - > sample_rate ;
2002-10-21 19:40:23 +02:00
break ;
case CODEC_TYPE_VIDEO :
2005-08-14 18:37:29 +02:00
den = ( int64_t ) st - > time_base . num * st - > codec - > time_base . den ;
2002-10-21 19:40:23 +02:00
break ;
default :
break ;
}
2005-08-14 18:37:29 +02:00
if ( den ! = AV_NOPTS_VALUE ) {
if ( den < = 0 )
return AVERROR_INVALIDDATA ;
av_frac_init ( & st - > pts , 0 , 0 , den ) ;
}
2002-10-21 19:40:23 +02:00
}
return 0 ;
2002-05-20 18:28:47 +02:00
}
2004-05-29 20:50:31 +02:00
//FIXME merge with compute_pkt_fields
2004-12-14 17:19:26 +01:00
static int compute_pkt_fields2 ( AVStream * st , AVPacket * pkt ) {
2006-08-30 23:18:17 +02:00
int delay = FFMAX ( st - > codec - > has_b_frames , ! ! st - > codec - > max_b_frames ) ;
int num , den , frame_size , i ;
2004-04-04 20:33:07 +02:00
2006-11-01 23:39:58 +01:00
// av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2005-12-17 19:14:38 +01:00
2004-05-29 04:06:32 +02:00
/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
return - 1 ; */
2005-12-17 19:14:38 +01:00
2004-05-29 04:06:32 +02:00
/* duration field */
2004-05-29 20:50:31 +02:00
if ( pkt - > duration = = 0 ) {
compute_frame_duration ( & num , & den , st , NULL , pkt ) ;
if ( den & & num ) {
pkt - > duration = av_rescale ( 1 , num * ( int64_t ) st - > time_base . den , den * ( int64_t ) st - > time_base . num ) ;
}
}
2004-05-29 04:06:32 +02:00
//XXX/FIXME this is a temporary hack until all encoders output pts
2006-08-30 23:18:17 +02:00
if ( ( pkt - > pts = = 0 | | pkt - > pts = = AV_NOPTS_VALUE ) & & pkt - > dts = = AV_NOPTS_VALUE & & ! delay ) {
2004-05-29 04:06:32 +02:00
pkt - > dts =
// pkt->pts= st->cur_dts;
pkt - > pts = st - > pts . val ;
}
2005-12-17 19:14:38 +01:00
//calculate dts from pts
2004-05-29 04:06:32 +02:00
if ( pkt - > pts ! = AV_NOPTS_VALUE & & pkt - > dts = = AV_NOPTS_VALUE ) {
2006-08-30 23:18:17 +02:00
st - > pts_buffer [ 0 ] = pkt - > pts ;
for ( i = 1 ; i < delay + 1 & & st - > pts_buffer [ i ] = = AV_NOPTS_VALUE ; i + + )
st - > pts_buffer [ i ] = ( i - delay - 1 ) * pkt - > duration ;
for ( i = 0 ; i < delay & & st - > pts_buffer [ i ] > st - > pts_buffer [ i + 1 ] ; i + + )
2006-11-01 22:28:36 +01:00
FFSWAP ( int64_t , st - > pts_buffer [ i ] , st - > pts_buffer [ i + 1 ] ) ;
2006-08-30 23:18:17 +02:00
pkt - > dts = st - > pts_buffer [ 0 ] ;
2004-05-29 04:06:32 +02:00
}
2005-12-17 19:14:38 +01:00
2004-12-14 17:19:26 +01:00
if ( st - > cur_dts & & st - > cur_dts ! = AV_NOPTS_VALUE & & st - > cur_dts > = pkt - > dts ) {
2005-12-12 02:56:46 +01:00
av_log ( NULL , AV_LOG_ERROR , " error, non monotone timestamps % " PRId64 " >= % " PRId64 " \n " , st - > cur_dts , pkt - > dts ) ;
2004-12-14 17:19:26 +01:00
return - 1 ;
}
if ( pkt - > dts ! = AV_NOPTS_VALUE & & pkt - > pts ! = AV_NOPTS_VALUE & & pkt - > pts < pkt - > dts ) {
av_log ( NULL , AV_LOG_ERROR , " error, pts < dts \n " ) ;
return - 1 ;
}
2006-11-01 23:39:58 +01:00
// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2004-05-29 04:06:32 +02:00
st - > cur_dts = pkt - > dts ;
st - > pts . val = pkt - > dts ;
2002-10-21 19:40:23 +02:00
/* update pts */
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2002-10-21 19:40:23 +02:00
case CODEC_TYPE_AUDIO :
2005-07-18 00:24:36 +02:00
frame_size = get_audio_frame_size ( st - > codec , pkt - > size ) ;
2004-04-04 16:39:20 +02:00
2004-04-04 20:33:07 +02:00
/* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2004-04-04 16:39:20 +02:00
but it would be better if we had the real timestamps from the encoder */
2004-05-29 04:06:32 +02:00
if ( frame_size > = 0 & & ( pkt - > size | | st - > pts . num ! = st - > pts . den > > 1 | | st - > pts . val ) ) {
2004-05-21 22:43:21 +02:00
av_frac_add ( & st - > pts , ( int64_t ) st - > time_base . den * frame_size ) ;
2002-11-19 19:30:03 +01:00
}
2002-10-21 19:40:23 +02:00
break ;
case CODEC_TYPE_VIDEO :
2005-07-18 00:24:36 +02:00
av_frac_add ( & st - > pts , ( int64_t ) st - > time_base . den * st - > codec - > time_base . num ) ;
2002-10-21 19:40:23 +02:00
break ;
default :
break ;
}
2004-12-14 17:19:26 +01:00
return 0 ;
2004-05-29 20:50:31 +02:00
}
static void truncate_ts ( AVStream * st , AVPacket * pkt ) {
int64_t pts_mask = ( 2LL < < ( st - > pts_wrap_bits - 1 ) ) - 1 ;
2005-12-17 19:14:38 +01:00
2004-10-03 14:58:14 +02:00
// if(pkt->dts < 0)
// pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2005-12-17 19:14:38 +01:00
2006-12-06 18:17:33 +01:00
if ( pkt - > pts ! = AV_NOPTS_VALUE )
2006-12-06 16:46:12 +01:00
pkt - > pts & = pts_mask ;
2006-12-06 18:17:33 +01:00
if ( pkt - > dts ! = AV_NOPTS_VALUE )
2006-12-06 16:46:12 +01:00
pkt - > dts & = pts_mask ;
2004-05-29 20:50:31 +02:00
}
/**
2005-06-28 14:55:08 +02:00
* Write a packet to an output media file .
*
* The packet shall contain one audio or video frame .
2007-02-02 12:19:58 +01:00
* The packet must be correctly interleaved according to the container specification ,
* if not then av_interleaved_write_frame must be used
2004-05-29 20:50:31 +02:00
*
* @ param s media file handle
* @ param pkt the packet , which contains the stream_index , buf / buf_size , dts / pts , . . .
* @ return < 0 if error , = 0 if OK , 1 if end of stream wanted .
*/
int av_write_frame ( AVFormatContext * s , AVPacket * pkt )
{
2004-10-08 22:09:52 +02:00
int ret ;
2004-12-14 17:19:26 +01:00
ret = compute_pkt_fields2 ( s - > streams [ pkt - > stream_index ] , pkt ) ;
2006-08-08 22:31:19 +02:00
if ( ret < 0 & & ! ( s - > oformat - > flags & AVFMT_NOTIMESTAMPS ) )
2004-12-14 17:19:26 +01:00
return ret ;
2005-12-17 19:14:38 +01:00
2004-05-29 20:50:31 +02:00
truncate_ts ( s - > streams [ pkt - > stream_index ] , pkt ) ;
2004-10-08 22:09:52 +02:00
ret = s - > oformat - > write_packet ( s , pkt ) ;
if ( ! ret )
ret = url_ferror ( & s - > pb ) ;
return ret ;
2004-05-29 20:50:31 +02:00
}
2004-09-30 01:25:01 +02:00
/**
2006-08-11 23:24:54 +02:00
* Interleave a packet per DTS in an output media file .
*
* Packets with pkt - > destruct = = av_destruct_packet will be freed inside this function ,
* so they cannot be used after it , note calling av_free_packet ( ) on them is still safe .
*
* @ param s media file handle
* @ param out the interleaved packet will be output here
* @ param in the input packet
* @ param flush 1 if no further packets are available as input and all
* remaining packets should be output
* @ return 1 if a packet was output , 0 if no packet could be output ,
* < 0 if an error occured
2004-09-30 01:25:01 +02:00
*/
2006-08-11 23:21:51 +02:00
int av_interleave_packet_per_dts ( AVFormatContext * s , AVPacket * out , AVPacket * pkt , int flush ) {
2004-09-30 01:25:01 +02:00
AVPacketList * pktl , * * next_point , * this_pktl ;
int stream_count = 0 ;
int streams [ MAX_STREAMS ] ;
if ( pkt ) {
AVStream * st = s - > streams [ pkt - > stream_index ] ;
2005-06-29 10:48:26 +02:00
// assert(pkt->destruct != av_destruct_packet); //FIXME
2004-09-30 01:25:01 +02:00
this_pktl = av_mallocz ( sizeof ( AVPacketList ) ) ;
this_pktl - > pkt = * pkt ;
2005-06-29 10:48:26 +02:00
if ( pkt - > destruct = = av_destruct_packet )
pkt - > destruct = NULL ; // non shared -> must keep original from being freed
else
av_dup_packet ( & this_pktl - > pkt ) ; //shared -> must dup
2004-09-30 01:25:01 +02:00
next_point = & s - > packet_buffer ;
while ( * next_point ) {
AVStream * st2 = s - > streams [ ( * next_point ) - > pkt . stream_index ] ;
int64_t left = st2 - > time_base . num * ( int64_t ) st - > time_base . den ;
int64_t right = st - > time_base . num * ( int64_t ) st2 - > time_base . den ;
if ( ( * next_point ) - > pkt . dts * left > pkt - > dts * right ) //FIXME this can overflow
break ;
next_point = & ( * next_point ) - > next ;
}
this_pktl - > next = * next_point ;
* next_point = this_pktl ;
}
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
memset ( streams , 0 , sizeof ( streams ) ) ;
pktl = s - > packet_buffer ;
while ( pktl ) {
2006-11-01 23:39:58 +01:00
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2004-09-30 01:25:01 +02:00
if ( streams [ pktl - > pkt . stream_index ] = = 0 )
stream_count + + ;
streams [ pktl - > pkt . stream_index ] + + ;
pktl = pktl - > next ;
}
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
if ( s - > nb_streams = = stream_count | | ( flush & & stream_count ) ) {
pktl = s - > packet_buffer ;
* out = pktl - > pkt ;
2005-12-17 19:14:38 +01:00
s - > packet_buffer = pktl - > next ;
2004-09-30 01:25:01 +02:00
av_freep ( & pktl ) ;
return 1 ;
} else {
av_init_packet ( out ) ;
return 0 ;
}
}
/**
* Interleaves a AVPacket correctly so it can be muxed .
* @ param out the interleaved packet will be output here
* @ param in the input packet
* @ param flush 1 if no further packets are available as input and all
* remaining packets should be output
2005-12-17 19:14:38 +01:00
* @ return 1 if a packet was output , 0 if no packet could be output ,
2004-09-30 01:25:01 +02:00
* < 0 if an error occured
*/
static int av_interleave_packet ( AVFormatContext * s , AVPacket * out , AVPacket * in , int flush ) {
if ( s - > oformat - > interleave_packet )
return s - > oformat - > interleave_packet ( s , out , in , flush ) ;
else
return av_interleave_packet_per_dts ( s , out , in , flush ) ;
}
2004-05-29 20:50:31 +02:00
/**
2005-06-28 14:55:08 +02:00
* Writes a packet to an output media file ensuring correct interleaving .
*
* The packet must contain one audio or video frame .
2004-05-29 20:50:31 +02:00
* If the packets are already correctly interleaved the application should
* call av_write_frame ( ) instead as its slightly faster , its also important
2004-09-30 01:25:01 +02:00
* to keep in mind that completly non interleaved input will need huge amounts
2004-05-29 20:50:31 +02:00
* of memory to interleave with this , so its prefereable to interleave at the
* demuxer level
*
* @ param s media file handle
* @ param pkt the packet , which contains the stream_index , buf / buf_size , dts / pts , . . .
* @ return < 0 if error , = 0 if OK , 1 if end of stream wanted .
*/
int av_interleaved_write_frame ( AVFormatContext * s , AVPacket * pkt ) {
AVStream * st = s - > streams [ pkt - > stream_index ] ;
2004-06-22 23:14:01 +02:00
//FIXME/XXX/HACK drop zero sized packets
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_AUDIO & & pkt - > size = = 0 )
2004-06-22 23:14:01 +02:00
return 0 ;
2005-03-24 02:51:57 +01:00
2006-11-01 23:39:58 +01:00
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2006-08-08 22:31:19 +02:00
if ( compute_pkt_fields2 ( st , pkt ) < 0 & & ! ( s - > oformat - > flags & AVFMT_NOTIMESTAMPS ) )
2005-03-24 02:51:57 +01:00
return - 1 ;
2005-12-17 19:14:38 +01:00
2004-05-29 20:50:31 +02:00
if ( pkt - > dts = = AV_NOPTS_VALUE )
return - 1 ;
2004-09-30 01:25:01 +02:00
for ( ; ; ) {
AVPacket opkt ;
int ret = av_interleave_packet ( s , & opkt , pkt , 0 ) ;
if ( ret < = 0 ) //FIXME cleanup needed for ret<0 ?
return ret ;
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
truncate_ts ( s - > streams [ opkt . stream_index ] , & opkt ) ;
ret = s - > oformat - > write_packet ( s , & opkt ) ;
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
av_free_packet ( & opkt ) ;
pkt = NULL ;
2005-12-17 19:14:38 +01:00
2004-05-29 20:50:31 +02:00
if ( ret < 0 )
return ret ;
2004-10-08 22:09:52 +02:00
if ( url_ferror ( & s - > pb ) )
return url_ferror ( & s - > pb ) ;
2004-05-29 20:50:31 +02:00
}
2002-05-20 18:28:47 +02:00
}
/**
2005-06-28 14:55:08 +02:00
* @ brief Write the stream trailer to an output media file and
* free the file private data .
2002-05-20 18:28:47 +02:00
*
* @ param s media file handle
2005-06-28 14:55:08 +02:00
* @ return 0 if OK . AVERROR_xxx if error .
*/
2002-05-20 18:28:47 +02:00
int av_write_trailer ( AVFormatContext * s )
{
2004-10-01 18:30:15 +02:00
int ret , i ;
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
for ( ; ; ) {
AVPacket pkt ;
ret = av_interleave_packet ( s , & pkt , NULL , 1 ) ;
if ( ret < 0 ) //FIXME cleanup needed for ret<0 ?
2004-10-01 18:30:15 +02:00
goto fail ;
2004-09-30 01:25:01 +02:00
if ( ! ret )
break ;
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
truncate_ts ( s - > streams [ pkt . stream_index ] , & pkt ) ;
ret = s - > oformat - > write_packet ( s , & pkt ) ;
2005-12-17 19:14:38 +01:00
2004-09-30 01:25:01 +02:00
av_free_packet ( & pkt ) ;
2005-12-17 19:14:38 +01:00
2004-05-29 20:50:31 +02:00
if ( ret < 0 )
2004-10-01 18:30:15 +02:00
goto fail ;
2004-10-08 22:09:52 +02:00
if ( url_ferror ( & s - > pb ) )
goto fail ;
2004-05-29 20:50:31 +02:00
}
2005-11-05 00:50:11 +01:00
if ( s - > oformat - > write_trailer )
ret = s - > oformat - > write_trailer ( s ) ;
2004-10-01 18:30:15 +02:00
fail :
2004-10-08 22:09:52 +02:00
if ( ret = = 0 )
ret = url_ferror ( & s - > pb ) ;
2004-10-01 18:30:15 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + )
av_freep ( & s - > streams [ i ] - > priv_data ) ;
2002-05-20 18:28:47 +02:00
av_freep ( & s - > priv_data ) ;
return ret ;
2001-07-22 16:18:56 +02:00
}
/* "user interface" functions */
void dump_format ( AVFormatContext * ic ,
2005-12-17 19:14:38 +01:00
int index ,
2001-07-22 16:18:56 +02:00
const char * url ,
int is_output )
{
2002-05-20 18:28:47 +02:00
int i , flags ;
2001-07-22 16:18:56 +02:00
char buf [ 256 ] ;
2005-12-17 19:14:38 +01:00
av_log ( NULL , AV_LOG_INFO , " %s #%d, %s, %s '%s': \n " ,
2001-07-22 16:18:56 +02:00
is_output ? " Output " : " Input " ,
2005-12-17 19:14:38 +01:00
index ,
is_output ? ic - > oformat - > name : ic - > iformat - > name ,
2001-07-22 16:18:56 +02:00
is_output ? " to " : " from " , url ) ;
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 ;
secs = ic - > duration / AV_TIME_BASE ;
us = ic - > duration % AV_TIME_BASE ;
mins = secs / 60 ;
secs % = 60 ;
hours = mins / 60 ;
mins % = 60 ;
2005-12-17 19:14:38 +01:00
av_log ( NULL , AV_LOG_INFO , " %02d:%02d:%02d.%01d " , hours , mins , secs ,
2003-08-08 20:02:23 +02:00
( 10 * us ) / AV_TIME_BASE ) ;
} 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 ;
us = ic - > start_time % AV_TIME_BASE ;
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " %d.%06d " ,
2004-10-11 19:12:52 +02:00
secs , ( int ) av_rescale ( us , 1000000 , AV_TIME_BASE ) ) ;
}
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " , bitrate: " ) ;
2003-08-08 20:02:23 +02:00
if ( ic - > bit_rate ) {
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " %d kb/s " , ic - > bit_rate / 1000 ) ;
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
}
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2003-08-08 20:02:23 +02:00
}
2001-07-22 16:18:56 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
AVStream * st = ic - > streams [ i ] ;
2005-09-18 16:45:17 +02:00
int g = ff_gcd ( st - > time_base . num , st - > time_base . den ) ;
2005-07-18 00:24:36 +02:00
avcodec_string ( buf , sizeof ( buf ) , st - > codec , is_output ) ;
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " Stream #%d.%d " , index , i ) ;
2002-05-20 18:28:47 +02:00
/* the pid is an important information, so we display it */
/* XXX: add a generic system */
if ( is_output )
flags = ic - > oformat - > flags ;
else
flags = ic - > iformat - > flags ;
if ( flags & AVFMT_SHOW_IDS ) {
2005-05-29 13:44:21 +02:00
av_log ( NULL , AV_LOG_INFO , " [0x%x] " , st - > id ) ;
2002-05-20 18:28:47 +02:00
}
2005-07-17 02:28:12 +02:00
if ( strlen ( st - > language ) > 0 ) {
av_log ( NULL , AV_LOG_INFO , " (%s) " , st - > language ) ;
}
2005-09-18 16:45:17 +02:00
av_log ( NULL , AV_LOG_DEBUG , " , %d/%d " , st - > time_base . num / g , st - > time_base . den / g ) ;
2006-06-16 01:26:48 +02:00
av_log ( NULL , AV_LOG_INFO , " : %s " , buf ) ;
2005-09-18 16:45:17 +02:00
if ( st - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
2005-12-16 16:51:16 +01:00
if ( st - > r_frame_rate . den & & st - > r_frame_rate . num )
av_log ( NULL , AV_LOG_INFO , " , %5.2f fps(r) " , av_q2d ( st - > r_frame_rate ) ) ;
/* else if(st->time_base.den && st->time_base.num)
av_log ( NULL , AV_LOG_INFO , " , %5.2f fps(m) " , 1 / av_q2d ( st - > time_base ) ) ; */
else
av_log ( NULL , AV_LOG_INFO , " , %5.2f fps(c) " , 1 / av_q2d ( st - > codec - > time_base ) ) ;
2005-09-18 16:45:17 +02:00
}
2006-06-16 01:26:48 +02:00
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2001-07-22 16:18:56 +02:00
}
}
typedef struct {
2003-07-12 09:37:05 +02:00
const char * abv ;
2001-07-22 16:18:56 +02:00
int width , height ;
2003-07-12 09:37:05 +02:00
int frame_rate , frame_rate_base ;
} AbvEntry ;
static AbvEntry frame_abvs [ ] = {
2003-08-29 08:58:55 +02:00
{ " ntsc " , 720 , 480 , 30000 , 1001 } ,
{ " pal " , 720 , 576 , 25 , 1 } ,
{ " qntsc " , 352 , 240 , 30000 , 1001 } , /* VCD compliant ntsc */
{ " qpal " , 352 , 288 , 25 , 1 } , /* VCD compliant pal */
2003-08-29 19:27:48 +02:00
{ " sntsc " , 640 , 480 , 30000 , 1001 } , /* square pixel ntsc */
{ " spal " , 768 , 576 , 25 , 1 } , /* square pixel pal */
2003-07-12 09:37:05 +02:00
{ " film " , 352 , 240 , 24 , 1 } ,
{ " ntsc-film " , 352 , 240 , 24000 , 1001 } ,
{ " sqcif " , 128 , 96 , 0 , 0 } ,
{ " qcif " , 176 , 144 , 0 , 0 } ,
{ " cif " , 352 , 288 , 0 , 0 } ,
{ " 4cif " , 704 , 576 , 0 , 0 } ,
2001-07-22 16:18:56 +02:00
} ;
2003-07-12 09:37:05 +02:00
2005-06-28 14:55:08 +02:00
/**
* parses width and height out of string str .
*/
2001-07-22 16:18:56 +02:00
int parse_image_size ( int * width_ptr , int * height_ptr , const char * str )
{
int i ;
2003-07-12 09:37:05 +02:00
int n = sizeof ( frame_abvs ) / sizeof ( AbvEntry ) ;
2001-07-22 16:18:56 +02:00
const char * p ;
int frame_width = 0 , frame_height = 0 ;
for ( i = 0 ; i < n ; i + + ) {
2003-07-12 09:37:05 +02:00
if ( ! strcmp ( frame_abvs [ i ] . abv , str ) ) {
frame_width = frame_abvs [ i ] . width ;
frame_height = frame_abvs [ i ] . height ;
2001-07-22 16:18:56 +02:00
break ;
}
}
if ( i = = n ) {
p = str ;
frame_width = strtol ( p , ( char * * ) & p , 10 ) ;
if ( * p )
p + + ;
frame_height = strtol ( p , ( char * * ) & p , 10 ) ;
}
if ( frame_width < = 0 | | frame_height < = 0 )
return - 1 ;
* width_ptr = frame_width ;
* height_ptr = frame_height ;
return 0 ;
}
2005-06-28 14:55:08 +02:00
/**
* Converts frame rate from string to a fraction .
*
* First we try to get an exact integer or fractional frame rate .
* If this fails we convert the frame rate to a double and return
* an approximate fraction using the DEFAULT_FRAME_RATE_BASE .
*/
2003-07-12 09:37:05 +02:00
int parse_frame_rate ( int * frame_rate , int * frame_rate_base , const char * arg )
{
int i ;
char * cp ;
2005-12-17 19:14:38 +01:00
2003-07-12 09:37:05 +02:00
/* First, we check our abbreviation table */
for ( i = 0 ; i < sizeof ( frame_abvs ) / sizeof ( * frame_abvs ) ; + + i )
if ( ! strcmp ( frame_abvs [ i ] . abv , arg ) ) {
2005-12-22 02:10:11 +01:00
* frame_rate = frame_abvs [ i ] . frame_rate ;
* frame_rate_base = frame_abvs [ i ] . frame_rate_base ;
return 0 ;
}
2003-07-12 09:37:05 +02:00
/* Then, we try to parse it as fraction */
cp = strchr ( arg , ' / ' ) ;
2005-01-27 17:11:31 +01:00
if ( ! cp )
cp = strchr ( arg , ' : ' ) ;
2003-07-12 09:37:05 +02:00
if ( cp ) {
char * cpp ;
2005-12-22 02:10:11 +01:00
* frame_rate = strtol ( arg , & cpp , 10 ) ;
if ( cpp ! = arg | | cpp = = cp )
* frame_rate_base = strtol ( cp + 1 , & cpp , 10 ) ;
else
* frame_rate = 0 ;
2005-12-17 19:14:38 +01:00
}
2003-07-12 09:37:05 +02:00
else {
/* Finally we give up and parse it as double */
2006-03-24 16:47:44 +01:00
AVRational time_base = av_d2q ( strtod ( arg , 0 ) , DEFAULT_FRAME_RATE_BASE ) ;
* frame_rate_base = time_base . den ;
* frame_rate = time_base . num ;
2003-07-12 09:37:05 +02:00
}
if ( ! * frame_rate | | ! * frame_rate_base )
return - 1 ;
else
return 0 ;
}
2005-06-28 14:55:08 +02:00
/**
* Converts date string to number of seconds since Jan 1 st , 1970.
*
* @ code
* Syntax :
2002-10-21 17:54:49 +02:00
* - If not a duration :
* [ { YYYY - MM - DD | YYYYMMDD } ] { T | } { HH [ : MM [ : SS [ . m . . . ] ] ] [ Z ] | HH [ MM [ SS [ . m . . . ] ] ] [ Z ] }
2002-07-27 04:54:10 +02:00
* Time is localtime unless Z is suffixed to the end . In this case GMT
2005-12-17 19:14:38 +01:00
* Return the date in micro seconds since 1970
2005-06-28 14:55:08 +02:00
*
* - If a duration :
2002-10-21 17:54:49 +02:00
* HH [ : MM [ : SS [ . m . . . ] ] ]
* S + [ . m . . . ]
2005-06-28 14:55:08 +02:00
* @ endcode
2002-10-21 17:54:49 +02:00
*/
2006-01-22 19:34:17 +01:00
# ifndef CONFIG_WINCE
2003-02-11 17:35:48 +01:00
int64_t parse_date ( const char * datestr , int duration )
2001-07-22 16:18:56 +02:00
{
const char * p ;
2003-02-11 17:35:48 +01:00
int64_t t ;
2002-06-14 05:38:00 +02:00
struct tm dt ;
2002-07-27 04:54:10 +02:00
int i ;
static const char * date_fmt [ ] = {
" %Y-%m-%d " ,
" %Y%m%d " ,
} ;
static const char * time_fmt [ ] = {
" %H:%M:%S " ,
" %H%M%S " ,
} ;
const char * q ;
2002-10-21 17:54:49 +02:00
int is_utc , len ;
2002-07-27 04:54:10 +02:00
char lastch ;
2004-06-12 00:03:16 +02:00
int negative = 0 ;
2004-04-04 16:39:20 +02:00
# undef time
2002-07-27 04:54:10 +02:00
time_t now = time ( 0 ) ;
2002-10-21 17:54:49 +02:00
len = strlen ( datestr ) ;
if ( len > 0 )
lastch = datestr [ len - 1 ] ;
else
lastch = ' \0 ' ;
2002-07-27 04:54:10 +02:00
is_utc = ( lastch = = ' z ' | | lastch = = ' Z ' ) ;
2002-06-14 05:38:00 +02:00
memset ( & dt , 0 , sizeof ( dt ) ) ;
2001-07-22 16:18:56 +02:00
p = datestr ;
2002-10-21 17:54:49 +02:00
q = NULL ;
2001-07-22 16:18:56 +02:00
if ( ! duration ) {
2002-07-27 04:54:10 +02:00
for ( i = 0 ; i < sizeof ( date_fmt ) / sizeof ( date_fmt [ 0 ] ) ; i + + ) {
2003-09-08 23:20:55 +02:00
q = small_strptime ( p , date_fmt [ i ] , & dt ) ;
2002-07-27 04:54:10 +02:00
if ( q ) {
break ;
}
}
if ( ! q ) {
if ( is_utc ) {
dt = * gmtime ( & now ) ;
} else {
dt = * localtime ( & now ) ;
}
dt . tm_hour = dt . tm_min = dt . tm_sec = 0 ;
2001-07-22 16:18:56 +02:00
} else {
2002-07-27 04:54:10 +02:00
p = q ;
2001-07-22 16:18:56 +02:00
}
2002-07-27 04:54:10 +02:00
if ( * p = = ' T ' | | * p = = ' t ' | | * p = = ' ' )
p + + ;
2002-10-21 17:54:49 +02:00
for ( i = 0 ; i < sizeof ( time_fmt ) / sizeof ( time_fmt [ 0 ] ) ; i + + ) {
2003-09-08 23:20:55 +02:00
q = small_strptime ( p , time_fmt [ i ] , & dt ) ;
2002-10-21 17:54:49 +02:00
if ( q ) {
break ;
}
}
} else {
2005-12-22 02:10:11 +01:00
if ( p [ 0 ] = = ' - ' ) {
negative = 1 ;
+ + p ;
}
2003-09-08 23:20:55 +02:00
q = small_strptime ( p , time_fmt [ 0 ] , & dt ) ;
2002-10-21 17:54:49 +02:00
if ( ! q ) {
dt . tm_sec = strtol ( p , ( char * * ) & q , 10 ) ;
dt . tm_min = 0 ;
dt . tm_hour = 0 ;
2002-07-27 04:54:10 +02:00
}
}
/* Now we have all the fields that we can get */
if ( ! q ) {
if ( duration )
return 0 ;
else
2006-12-07 00:46:11 +01:00
return now * INT64_C ( 1000000 ) ;
2001-07-22 16:18:56 +02:00
}
2002-06-14 05:38:00 +02:00
if ( duration ) {
2002-07-27 04:54:10 +02:00
t = dt . tm_hour * 3600 + dt . tm_min * 60 + dt . tm_sec ;
2002-06-14 05:38:00 +02:00
} else {
2002-07-27 04:54:10 +02:00
dt . tm_isdst = - 1 ; /* unknown */
if ( is_utc ) {
t = mktimegm ( & dt ) ;
} else {
t = mktime ( & dt ) ;
}
2001-07-22 16:18:56 +02:00
}
2002-06-14 05:38:00 +02:00
2002-07-27 04:54:10 +02:00
t * = 1000000 ;
if ( * q = = ' . ' ) {
2001-07-22 16:18:56 +02:00
int val , n ;
2002-07-27 04:54:10 +02:00
q + + ;
for ( val = 0 , n = 100000 ; n > = 1 ; n / = 10 , q + + ) {
2005-12-17 19:14:38 +01:00
if ( ! isdigit ( * q ) )
2002-07-27 04:54:10 +02:00
break ;
val + = n * ( * q - ' 0 ' ) ;
2001-07-22 16:18:56 +02:00
}
t + = val ;
}
2004-06-12 00:03:16 +02:00
return negative ? - t : t ;
2001-07-22 16:18:56 +02:00
}
2006-01-22 19:34:17 +01:00
# endif /* CONFIG_WINCE */
2001-07-22 16:18:56 +02:00
2005-06-28 14:55:08 +02:00
/**
* Attempts to find a specific tag in a URL .
*
* syntax : ' ? tag1 = val1 & tag2 = val2 . . . ' . Little URL decoding is done .
* Return 1 if found .
*/
2001-07-22 16:18:56 +02:00
int find_info_tag ( char * arg , int arg_size , const char * tag1 , const char * info )
{
const char * p ;
char tag [ 128 ] , * q ;
p = info ;
if ( * p = = ' ? ' )
p + + ;
for ( ; ; ) {
q = tag ;
while ( * p ! = ' \0 ' & & * p ! = ' = ' & & * p ! = ' & ' ) {
if ( ( q - tag ) < sizeof ( tag ) - 1 )
* q + + = * p ;
p + + ;
}
* q = ' \0 ' ;
q = arg ;
if ( * p = = ' = ' ) {
p + + ;
while ( * p ! = ' & ' & & * p ! = ' \0 ' ) {
2002-06-14 05:38:00 +02:00
if ( ( q - arg ) < arg_size - 1 ) {
if ( * p = = ' + ' )
* q + + = ' ' ;
else
* q + + = * p ;
}
2001-07-22 16:18:56 +02:00
p + + ;
}
* q = ' \0 ' ;
}
2005-12-17 19:14:38 +01:00
if ( ! strcmp ( tag , tag1 ) )
2001-07-22 16:18:56 +02:00
return 1 ;
if ( * p ! = ' & ' )
break ;
2002-05-10 04:17:41 +02:00
p + + ;
2001-07-22 16:18:56 +02:00
}
return 0 ;
}
2005-06-28 14:55:08 +02:00
/**
* Returns in ' buf ' the path with ' % d ' replaced by number .
2006-09-04 11:57:47 +02:00
2005-06-28 14:55:08 +02:00
* Also handles the ' % 0 nd ' format where ' n ' is the total number
2006-09-04 11:57:47 +02:00
* of digits and ' % % ' .
*
* @ param buf destination buffer
* @ param buf_size destination buffer size
* @ param path numbered sequence string
* @ number frame number
* @ return 0 if OK , - 1 if format error .
2005-06-28 14:55:08 +02:00
*/
2006-09-04 11:57:47 +02: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 ;
for ( ; ; ) {
c = * p + + ;
if ( c = = ' \0 ' )
break ;
if ( c = = ' % ' ) {
2002-12-11 04:20:05 +01:00
do {
nd = 0 ;
while ( isdigit ( * p ) ) {
nd = nd * 10 + * p + + - ' 0 ' ;
}
c = * p + + ;
} while ( isdigit ( c ) ) ;
2001-09-16 23:50:48 +02:00
switch ( c ) {
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 {
addchar :
if ( ( q - buf ) < buf_size - 1 )
* q + + = c ;
}
}
if ( ! percentd_found )
goto fail ;
* q = ' \0 ' ;
return 0 ;
fail :
* q = ' \0 ' ;
return - 1 ;
}
2002-05-20 18:28:47 +02:00
/**
2003-11-10 19:37:55 +01:00
* Print nice hexa dump of a buffer
* @ param f stream for output
2002-05-20 18:28:47 +02:00
* @ param buf buffer
* @ param size buffer size
*/
2003-11-10 19:37:55 +01:00
void av_hex_dump ( FILE * f , uint8_t * buf , int size )
2002-05-20 18:28:47 +02:00
{
int len , i , j , c ;
for ( i = 0 ; i < size ; i + = 16 ) {
len = size - i ;
if ( len > 16 )
len = 16 ;
2003-11-10 19:37:55 +01:00
fprintf ( f , " %08x " , i ) ;
2002-05-20 18:28:47 +02:00
for ( j = 0 ; j < 16 ; j + + ) {
if ( j < len )
2003-11-10 19:37:55 +01:00
fprintf ( f , " %02x " , buf [ i + j ] ) ;
2002-05-20 18:28:47 +02:00
else
2003-11-10 19:37:55 +01:00
fprintf ( f , " " ) ;
2002-05-20 18:28:47 +02:00
}
2003-11-10 19:37:55 +01:00
fprintf ( f , " " ) ;
2002-05-20 18:28:47 +02:00
for ( j = 0 ; j < len ; j + + ) {
c = buf [ i + j ] ;
if ( c < ' ' | | c > ' ~ ' )
c = ' . ' ;
2003-11-10 19:37:55 +01:00
fprintf ( f , " %c " , c ) ;
2002-05-20 18:28:47 +02:00
}
2003-11-10 19:37:55 +01:00
fprintf ( f , " \n " ) ;
2002-05-20 18:28:47 +02:00
}
}
2003-11-10 19:37:55 +01:00
/**
* Print on ' f ' a nice dump of a packet
* @ param f stream for output
* @ param pkt packet to dump
* @ param dump_payload true if the payload must be displayed too
*/
2005-04-30 23:43:59 +02:00
//FIXME needs to know the time_base
2003-11-10 19:37:55 +01:00
void av_pkt_dump ( FILE * f , AVPacket * pkt , int dump_payload )
{
fprintf ( f , " stream #%d: \n " , pkt - > stream_index ) ;
fprintf ( f , " keyframe=%d \n " , ( ( pkt - > flags & PKT_FLAG_KEY ) ! = 0 ) ) ;
fprintf ( f , " duration=%0.3f \n " , ( double ) pkt - > duration / AV_TIME_BASE ) ;
2003-12-15 15:45:37 +01:00
/* DTS is _always_ valid after av_read_frame() */
fprintf ( f , " dts= " ) ;
if ( pkt - > dts = = AV_NOPTS_VALUE )
fprintf ( f , " N/A " ) ;
else
fprintf ( f , " %0.3f " , ( double ) pkt - > dts / AV_TIME_BASE ) ;
2003-11-10 19:37:55 +01:00
/* PTS may be not known if B frames are present */
fprintf ( f , " pts= " ) ;
if ( pkt - > pts = = AV_NOPTS_VALUE )
fprintf ( f , " N/A " ) ;
else
fprintf ( f , " %0.3f " , ( double ) pkt - > pts / AV_TIME_BASE ) ;
fprintf ( f , " \n " ) ;
fprintf ( f , " size=%d \n " , pkt - > size ) ;
if ( dump_payload )
av_hex_dump ( f , pkt - > data , pkt - > size ) ;
}
2002-07-24 20:04:50 +02:00
void url_split ( char * proto , int proto_size ,
2004-08-12 02:09:32 +02:00
char * authorization , int authorization_size ,
2002-07-24 20:04:50 +02:00
char * hostname , int hostname_size ,
int * port_ptr ,
char * path , int path_size ,
const char * url )
{
const char * p ;
char * q ;
int port ;
port = - 1 ;
p = url ;
q = proto ;
while ( * p ! = ' : ' & & * p ! = ' \0 ' ) {
if ( ( q - proto ) < proto_size - 1 )
* q + + = * p ;
p + + ;
}
if ( proto_size > 0 )
* q = ' \0 ' ;
2004-08-12 02:09:32 +02:00
if ( authorization_size > 0 )
authorization [ 0 ] = ' \0 ' ;
2002-07-24 20:04:50 +02:00
if ( * p = = ' \0 ' ) {
if ( proto_size > 0 )
proto [ 0 ] = ' \0 ' ;
if ( hostname_size > 0 )
hostname [ 0 ] = ' \0 ' ;
p = url ;
} else {
2004-08-12 02:09:32 +02:00
char * at , * slash ; // PETR: position of '@' character and '/' character
2002-07-24 20:04:50 +02:00
p + + ;
if ( * p = = ' / ' )
p + + ;
if ( * p = = ' / ' )
p + + ;
2004-08-12 02:09:32 +02:00
at = strchr ( p , ' @ ' ) ; // PETR: get the position of '@'
slash = strchr ( p , ' / ' ) ; // PETR: get position of '/' - end of hostname
if ( at & & slash & & at > slash ) at = NULL ; // PETR: not interested in '@' behind '/'
q = at ? authorization : hostname ; // PETR: if '@' exists starting with auth.
while ( ( at | | * p ! = ' : ' ) & & * p ! = ' / ' & & * p ! = ' ? ' & & * p ! = ' \0 ' ) { // PETR:
if ( * p = = ' @ ' ) { // PETR: passed '@'
if ( authorization_size > 0 )
* q = ' \0 ' ;
q = hostname ;
at = NULL ;
} else if ( ! at ) { // PETR: hostname
if ( ( q - hostname ) < hostname_size - 1 )
* q + + = * p ;
} else {
if ( ( q - authorization ) < authorization_size - 1 )
2002-07-24 20:04:50 +02:00
* q + + = * p ;
2004-08-12 02:09:32 +02:00
}
2002-07-24 20:04:50 +02:00
p + + ;
}
if ( hostname_size > 0 )
* q = ' \0 ' ;
if ( * p = = ' : ' ) {
p + + ;
port = strtoul ( p , ( char * * ) & p , 10 ) ;
}
}
if ( port_ptr )
* port_ptr = port ;
pstrcpy ( path , path_size , p ) ;
}
2002-10-21 17:54:49 +02:00
/**
2005-06-28 14:55:08 +02:00
* Set the pts for a given stream .
*
2005-12-17 19:14:38 +01:00
* @ param s stream
2002-10-21 17:54:49 +02:00
* @ param pts_wrap_bits number of bits effectively used by the pts
2005-12-17 19:14:38 +01:00
* ( used for wrap control , 33 is the value for MPEG )
* @ param pts_num numerator to convert to seconds ( MPEG : 1 )
2002-10-21 17:54:49 +02:00
* @ param pts_den denominator to convert to seconds ( MPEG : 90000 )
*/
2004-05-21 22:43:21 +02:00
void av_set_pts_info ( AVStream * s , int pts_wrap_bits ,
2002-10-21 17:54:49 +02:00
int pts_num , int pts_den )
{
s - > pts_wrap_bits = pts_wrap_bits ;
2004-05-21 22:43:21 +02:00
s - > time_base . num = pts_num ;
s - > time_base . den = pts_den ;
2002-10-21 17:54:49 +02:00
}
/* fraction handling */
/**
2005-06-28 14:55:08 +02:00
* f = val + ( num / den ) + 0.5 .
*
* ' num ' is normalized so that it is such as 0 < = num < den .
2002-10-21 17:54:49 +02:00
*
* @ param f fractional number
* @ param val integer value
* @ param num must be > = 0
2005-12-17 19:14:38 +01:00
* @ param den must be > = 1
2002-10-21 17:54:49 +02:00
*/
2006-06-25 19:37:12 +02:00
static void av_frac_init ( AVFrac * f , int64_t val , int64_t num , int64_t den )
2002-10-21 17:54:49 +02:00
{
num + = ( den > > 1 ) ;
if ( num > = den ) {
val + = num / den ;
num = num % den ;
}
f - > val = val ;
f - > num = num ;
f - > den = den ;
}
/**
2005-06-28 14:55:08 +02:00
* Fractionnal addition to f : f = f + ( incr / f - > den ) .
2002-10-21 17:54:49 +02:00
*
* @ param f fractional number
* @ param incr increment , can be positive or negative
*/
2006-06-25 19:37:12 +02:00
static void av_frac_add ( AVFrac * f , int64_t incr )
2002-10-21 17:54:49 +02:00
{
2003-02-11 17:35:48 +01:00
int64_t num , den ;
2002-10-21 17:54:49 +02:00
num = f - > num + incr ;
den = f - > den ;
if ( num < 0 ) {
f - > val + = num / den ;
num = num % den ;
if ( num < 0 ) {
num + = den ;
f - > val - - ;
}
} else if ( num > = den ) {
f - > val + = num / den ;
num = num % den ;
}
f - > num = num ;
}