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
*
2002-05-26 00:34:32 +02:00
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2 of the License , or ( at your option ) any later version .
2001-07-22 16:18:56 +02:00
*
2002-05-26 00:34:32 +02:00
* This library 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
* License along with this library ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
2001-07-22 16:18:56 +02:00
*/
2001-08-13 23:37:10 +02:00
# include "avformat.h"
2002-07-27 04:54:10 +02:00
2004-01-13 23:02:49 +01:00
# undef NDEBUG
# include <assert.h>
2004-08-13 17:30:42 +02:00
AVInputFormat * first_iformat = NULL ;
AVOutputFormat * first_oformat = NULL ;
AVImageFormat * first_image_format = 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 ;
2001-07-22 16:18:56 +02:00
ext = strrchr ( filename , ' . ' ) ;
if ( ext ) {
ext + + ;
p = extensions ;
for ( ; ; ) {
q = ext1 ;
2005-01-12 01:16:25 +01:00
while ( * p ! = ' \0 ' & & * p ! = ' , ' & & q - ext1 < sizeof ( ext1 ) - 1 )
2001-07-22 16:18:56 +02:00
* q + + = * p + + ;
* q = ' \0 ' ;
if ( ! strcasecmp ( ext1 , ext ) )
return 1 ;
if ( * p = = ' \0 ' )
break ;
p + + ;
}
}
return 0 ;
}
2002-05-20 18:28:47 +02:00
AVOutputFormat * guess_format ( const char * short_name , const char * filename ,
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 */
2004-11-11 19:09:28 +01:00
if ( ! short_name & & filename & &
filename_number_test ( filename ) > = 0 & &
av_guess_image2_codec ( filename ) ! = CODEC_ID_NONE ) {
return guess_format ( " image2 " , NULL , NULL ) ;
}
2003-01-11 06:33:35 +01:00
if ( ! short_name & & filename & &
filename_number_test ( filename ) > = 0 & &
guess_image_format ( filename ) ) {
2003-01-11 06:02:14 +01:00
return guess_format ( " image " , NULL , NULL ) ;
}
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 ;
if ( filename & & fmt - > extensions & &
match_ext ( filename , fmt - > extensions ) ) {
score + = 5 ;
}
if ( score > score_max ) {
score_max = score ;
fmt_found = fmt ;
}
fmt = fmt - > next ;
}
return fmt_found ;
}
2002-07-27 04:54:10 +02:00
AVOutputFormat * guess_stream_format ( const char * short_name , const char * filename ,
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
/**
* guesses the codec id based upon muxer and filename .
*/
enum CodecID av_guess_codec ( AVOutputFormat * fmt , const char * short_name ,
const char * filename , const char * mime_type , enum CodecType type ) {
if ( type = = CODEC_TYPE_VIDEO ) {
enum CodecID codec_id = CODEC_ID_NONE ;
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 ) ;
}
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 ;
}
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
/**
* Default packet destructor
*/
static void av_destruct_packet ( AVPacket * pkt )
{
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 )
{
2005-01-08 15:21:33 +01:00
void * data ;
if ( ( unsigned ) size > ( unsigned ) size + FF_INPUT_BUFFER_PADDING_SIZE )
return AVERROR_NOMEM ;
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 ) ;
pkt - > data = data ;
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 )
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 ;
}
2001-07-22 16:18:56 +02:00
/* fifo handling */
int fifo_init ( FifoBuffer * f , int size )
{
2002-05-19 01:11:09 +02:00
f - > buffer = av_malloc ( size ) ;
2001-07-22 16:18:56 +02:00
if ( ! f - > buffer )
return - 1 ;
f - > end = f - > buffer + size ;
f - > wptr = f - > rptr = f - > buffer ;
return 0 ;
}
void fifo_free ( FifoBuffer * f )
{
2002-05-19 01:11:09 +02:00
av_free ( f - > buffer ) ;
2001-07-22 16:18:56 +02:00
}
2003-02-11 17:35:48 +01:00
int fifo_size ( FifoBuffer * f , uint8_t * rptr )
2001-07-22 16:18:56 +02:00
{
int size ;
2004-12-01 03:28:28 +01:00
if ( ! rptr )
rptr = f - > rptr ;
2001-07-22 16:18:56 +02:00
if ( f - > wptr > = rptr ) {
size = f - > wptr - rptr ;
} else {
size = ( f - > end - rptr ) + ( f - > wptr - f - > buffer ) ;
}
return size ;
}
/* get data from the fifo (return -1 if not enough data) */
2003-02-11 17:35:48 +01:00
int fifo_read ( FifoBuffer * f , uint8_t * buf , int buf_size , uint8_t * * rptr_ptr )
2001-07-22 16:18:56 +02:00
{
2004-12-01 03:28:28 +01:00
uint8_t * rptr ;
2001-07-22 16:18:56 +02:00
int size , len ;
2004-12-01 03:28:28 +01:00
if ( ! rptr_ptr )
rptr_ptr = & f - > rptr ;
rptr = * rptr_ptr ;
2001-07-22 16:18:56 +02:00
if ( f - > wptr > = rptr ) {
size = f - > wptr - rptr ;
} else {
size = ( f - > end - rptr ) + ( f - > wptr - f - > buffer ) ;
}
if ( size < buf_size )
return - 1 ;
while ( buf_size > 0 ) {
len = f - > end - rptr ;
if ( len > buf_size )
len = buf_size ;
memcpy ( buf , rptr , len ) ;
buf + = len ;
rptr + = len ;
if ( rptr > = f - > end )
rptr = f - > buffer ;
buf_size - = len ;
}
* rptr_ptr = rptr ;
return 0 ;
}
2005-01-08 15:21:33 +01:00
void fifo_realloc ( FifoBuffer * f , unsigned int new_size ) {
unsigned int old_size = f - > end - f - > buffer ;
2004-12-01 03:28:28 +01:00
if ( old_size < new_size ) {
uint8_t * old = f - > buffer ;
f - > buffer = av_realloc ( f - > buffer , new_size ) ;
f - > rptr + = f - > buffer - old ;
f - > wptr + = f - > buffer - old ;
if ( f - > wptr < f - > rptr ) {
memmove ( f - > rptr + new_size - old_size , f - > rptr , f - > buffer + old_size - f - > rptr ) ;
f - > rptr + = new_size - old_size ;
}
f - > end = f - > buffer + new_size ;
}
}
2003-02-11 17:35:48 +01:00
void fifo_write ( FifoBuffer * f , uint8_t * buf , int size , uint8_t * * wptr_ptr )
2001-07-22 16:18:56 +02:00
{
int len ;
2003-02-11 17:35:48 +01:00
uint8_t * wptr ;
2004-12-01 03:28:28 +01:00
if ( ! wptr_ptr )
wptr_ptr = & f - > wptr ;
2001-07-22 16:18:56 +02:00
wptr = * wptr_ptr ;
2004-12-01 03:28:28 +01:00
2001-07-22 16:18:56 +02:00
while ( size > 0 ) {
len = f - > end - wptr ;
if ( len > size )
len = size ;
memcpy ( wptr , buf , len ) ;
wptr + = len ;
if ( wptr > = f - > end )
wptr = f - > buffer ;
buf + = len ;
size - = len ;
}
* wptr_ptr = wptr ;
}
2004-10-03 04:42:01 +02:00
/* get data from the fifo (return -1 if not enough data) */
int put_fifo ( ByteIOContext * pb , FifoBuffer * f , int buf_size , uint8_t * * rptr_ptr )
{
uint8_t * rptr = * rptr_ptr ;
int size , len ;
if ( f - > wptr > = rptr ) {
size = f - > wptr - rptr ;
} else {
size = ( f - > end - rptr ) + ( f - > wptr - f - > buffer ) ;
}
if ( size < buf_size )
return - 1 ;
while ( buf_size > 0 ) {
len = f - > end - rptr ;
if ( len > buf_size )
len = buf_size ;
put_buffer ( pb , rptr , len ) ;
rptr + = len ;
if ( rptr > = f - > end )
rptr = f - > buffer ;
buf_size - = len ;
}
* rptr_ptr = rptr ;
return 0 ;
}
2002-05-20 18:28:47 +02:00
int filename_number_test ( const char * filename )
{
char buf [ 1024 ] ;
2004-04-27 04:55:05 +02:00
if ( ! filename )
return - 1 ;
2002-05-20 18:28:47 +02:00
return get_frame_filename ( buf , sizeof ( buf ) , filename , 1 ) ;
}
/* guess file format */
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 ) {
if ( ! is_opened & & ! ( fmt1 - > flags & AVFMT_NOFILE ) )
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 ;
}
2002-05-24 04:09:40 +02: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
/**
* open a media file from an IO stream . ' fmt ' must be specified .
*/
2004-03-03 16:41:21 +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 " ;
}
static const AVClass av_format_context_class = { " AVFormatContext " , format_to_name } ;
AVFormatContext * av_alloc_format_context ( void )
{
AVFormatContext * ic ;
ic = av_mallocz ( sizeof ( AVFormatContext ) ) ;
if ( ! ic ) return 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 ;
}
2003-10-29 15:20:56 +01:00
int av_open_input_stream ( AVFormatContext * * ic_ptr ,
ByteIOContext * pb , const char * filename ,
AVInputFormat * fmt , AVFormatParameters * ap )
{
int err ;
AVFormatContext * ic ;
2004-03-03 16:41:21 +01:00
ic = av_alloc_format_context ( ) ;
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
if ( pb )
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 ;
}
2002-05-20 18:28:47 +02:00
# define PROBE_BUF_SIZE 2048
/**
* 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 .
*/
int av_open_input_file ( AVFormatContext * * ic_ptr , const char * filename ,
AVInputFormat * fmt ,
int buf_size ,
AVFormatParameters * ap )
2001-07-22 16:18:56 +02:00
{
2003-10-29 15:20:56 +01:00
int err , must_open_file , file_opened ;
uint8_t buf [ PROBE_BUF_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 ;
file_opened = 0 ;
pd - > filename = " " ;
if ( filename )
pd - > filename = filename ;
2002-05-20 18:28:47 +02:00
pd - > buf = buf ;
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
}
2002-11-18 18:17:27 +01:00
if ( ! fmt ) {
/* read probe data */
2003-10-29 15:20:56 +01:00
pd - > buf_size = get_buffer ( pb , buf , PROBE_BUF_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 ) {
err = AVERROR_IO ;
goto fail ;
}
}
2002-11-18 18:17:27 +01:00
}
2001-09-25 01:25:28 +02:00
}
2002-05-20 18:28:47 +02:00
/* guess file format */
if ( ! fmt ) {
2002-07-25 18:05:52 +02:00
fmt = av_probe_input_format ( pd , 1 ) ;
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
}
2002-05-20 18:28:47 +02: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
2002-11-20 12:41:22 +01:00
if ( fmt = = & redir_demux ) {
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 ) {
if ( filename_number_test ( filename ) < 0 ) {
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 :
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 ;
2003-10-29 15:20:56 +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
/**
2003-11-10 19:37:55 +01:00
* Read a transport packet from a media file . This function is
* absolete and should never be used . Use av_read_frame ( ) instead .
2003-10-29 15:20:56 +01:00
*
2002-05-20 18:28:47 +02:00
* @ param s media file handle
* @ param pkt is filled
2003-10-29 15:20:56 +01:00
* @ 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 ) ;
}
/**********************************************************/
/* get the number of samples of an audio frame. Return (-1) if error */
static int get_audio_frame_size ( AVCodecContext * enc , int size )
{
int frame_size ;
if ( enc - > frame_size < = 1 ) {
/* specific hack for pcm codecs because no frame size is
provided */
switch ( enc - > codec_id ) {
case CODEC_ID_PCM_S16LE :
case CODEC_ID_PCM_S16BE :
case CODEC_ID_PCM_U16LE :
case CODEC_ID_PCM_U16BE :
if ( enc - > channels = = 0 )
return - 1 ;
frame_size = size / ( 2 * enc - > channels ) ;
break ;
case CODEC_ID_PCM_S8 :
case CODEC_ID_PCM_U8 :
case CODEC_ID_PCM_MULAW :
case CODEC_ID_PCM_ALAW :
if ( enc - > channels = = 0 )
return - 1 ;
frame_size = size / ( enc - > channels ) ;
break ;
default :
/* used for example by ADPCM codecs */
if ( enc - > bit_rate = = 0 )
return - 1 ;
frame_size = ( size * 8 * enc - > sample_rate ) / enc - > bit_rate ;
break ;
}
} else {
frame_size = enc - > frame_size ;
}
return frame_size ;
}
/* return the frame duration in seconds, return 0 if not available */
2004-05-29 20:50:31 +02: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 ;
switch ( st - > codec . codec_type ) {
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-05-12 18:27:05 +02:00
} else if ( st - > codec . time_base . num * 1000LL > st - > codec . time_base . den ) {
2005-04-30 23:43:59 +02:00
* pnum = st - > codec . time_base . num ;
* pden = st - > codec . time_base . den ;
2005-05-06 22:26:50 +02:00
if ( pc & & pc - > repeat_pict ) {
* pden * = 2 ;
* pnum = ( * pnum ) * ( 2 + pc - > repeat_pict ) ;
}
2003-11-10 19:37:55 +01:00
}
break ;
case CODEC_TYPE_AUDIO :
frame_size = get_audio_frame_size ( & st - > codec , pkt - > size ) ;
if ( frame_size < 0 )
break ;
* pnum = frame_size ;
* pden = st - > codec . sample_rate ;
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 ;
}
2003-11-10 19:37:55 +01:00
static void compute_pkt_fields ( AVFormatContext * s , AVStream * st ,
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 ) ;
}
2004-05-23 23:36:23 +02: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
}
}
2004-10-22 03:51:17 +02:00
if ( is_intra_only ( & st - > codec ) )
pkt - > flags | = PKT_FLAG_KEY ;
2003-11-10 19:37:55 +01:00
/* do we have a video B frame ? */
presentation_delayed = 0 ;
if ( st - > codec . codec_type = = CODEC_TYPE_VIDEO ) {
/* XXX: need has_b_frame, but cannot get it if the codec is
not initialized */
2004-12-14 13:04:45 +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
}
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
2004-05-29 20:50:31 +02:00
// av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld 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 ) {
int64_t old_diff = ABS ( st - > cur_dts - pkt - > duration - pkt - > pts ) ;
int64_t new_diff = ABS ( st - > cur_dts - pkt - > pts ) ;
if ( old_diff < new_diff & & old_diff < ( pkt - > duration > > 3 ) ) {
pkt - > pts + = pkt - > duration ;
2004-12-21 03:16:11 +01:00
// av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld 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
}
}
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 ;
}
2004-05-29 04:06:32 +02:00
// av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
2003-11-10 19:37:55 +01:00
/* update flags */
if ( pc ) {
pkt - > flags = 0 ;
/* key frame computation */
switch ( st - > codec . codec_type ) {
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 ) {
if ( ! st - > parser ) {
/* 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 ;
return 0 ;
2005-03-17 02:25:01 +01:00
} else if ( s - > cur_len > 0 & & st - > discard < AVDISCARD_ALL ) {
2003-11-10 19:37:55 +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 ;
/* 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 ) ;
return 0 ;
}
} else {
2003-11-20 12:22:25 +01:00
/* free packet */
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 ] ;
if ( st - > parser ) {
av_parser_parse ( st - > parser , & st - > codec ,
& pkt - > data , & pkt - > size ,
2003-12-16 12:21:25 +01:00
NULL , 0 ,
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
}
2004-05-21 22:43:21 +02:00
st = s - > streams [ s - > cur_pkt . stream_index ] ;
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 ) {
st - > parser = av_parser_init ( st - > codec . codec_id ) ;
if ( ! st - > parser ) {
/* no parser available : just output the raw packets */
st - > need_parsing = 0 ;
}
}
}
}
}
/**
* Return the next frame of a stream . The returned packet is valid
* 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 .
*
* 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 .
*
* Return 0 if OK , < 0 if error or end of file .
*/
int av_read_frame ( AVFormatContext * s , AVPacket * pkt )
2001-07-22 16:18:56 +02:00
{
AVPacketList * pktl ;
pktl = s - > packet_buffer ;
if ( pktl ) {
/* read packet from packet buffer, if there is data */
* pkt = pktl - > pkt ;
s - > packet_buffer = pktl - > next ;
2002-05-19 01:11:09 +02:00
av_free ( pktl ) ;
2001-07-22 16:18:56 +02:00
return 0 ;
} else {
2003-11-10 19:37:55 +01:00
return av_read_frame_internal ( s , pkt ) ;
}
}
/* XXX: suppress the packet queue */
static void flush_packet_queue ( AVFormatContext * s )
{
AVPacketList * pktl ;
for ( ; ; ) {
pktl = s - > packet_buffer ;
if ( ! pktl )
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 ] ;
if ( st - > codec . codec_type = = CODEC_TYPE_VIDEO ) {
return i ;
}
}
return 0 ;
}
2003-11-10 19:37:55 +01:00
/* flush the frame reader */
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 ;
/* for each stream, reset read state */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
st = s - > streams [ i ] ;
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
/**
2004-10-22 15:15:18 +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
* 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
*/
2004-10-22 15:15:18 +02:00
static 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
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
/**
* add a index entry into a sorted list updateing if it is already there .
* @ 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 ,
int64_t pos , int64_t timestamp , 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 ;
2003-11-10 19:37:55 +01:00
2005-01-08 15:21:33 +01:00
if ( ( unsigned ) st - > nb_index_entries + 1 > = UINT_MAX / sizeof ( AVIndexEntry ) )
return - 1 ;
2003-11-10 19:37:55 +01:00
entries = av_fast_realloc ( st - > index_entries ,
& st - > index_entries_allocated_size ,
( st - > nb_index_entries + 1 ) *
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 ;
2004-01-13 23:02:49 +01:00
ie - > flags = flags ;
2004-01-17 19:06:52 +01:00
return index ;
2003-11-10 19:37:55 +01:00
}
/* build an index for raw streams using a parser */
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-04-30 23:43:59 +02:00
av_add_index_entry ( st , st - > parser - > frame_offset , pkt - > dts ,
2004-01-17 19:06:52 +01:00
0 , AVINDEX_KEYFRAME ) ;
2003-11-10 19:37:55 +01:00
}
av_free_packet ( pkt ) ;
}
}
/* return TRUE if we deal with a raw stream (raw codec data and
parsing needed ) */
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
/**
* gets the index for a specific timestamp .
2005-03-13 01:13:01 +01:00
* @ param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
2004-10-11 00:05:43 +02:00
* the timestamp which is < = the requested one , if backward is 0
* 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 ;
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
if ( m = = nb_entries )
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 ;
int64_t start_pos ;
2004-10-12 12:28:27 +02:00
int index , no_change ;
2004-04-12 18:50:03 +02:00
AVStream * st ;
2004-05-23 18:26:12 +02:00
if ( stream_index < 0 )
return - 1 ;
2004-04-12 18:50:03 +02:00
# ifdef DEBUG_SEEK
av_log ( s , AV_LOG_DEBUG , " read_seek: %d %lld \n " , stream_index , target_ts ) ;
# 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
2004-06-12 00:03:16 +02:00
av_log ( s , AV_LOG_DEBUG , " using cached pos_min=0x%llx dts_min=%lld \n " ,
2004-04-12 18:50:03 +02:00
pos_min , ts_min ) ;
# endif
} else {
assert ( index = = 0 ) ;
}
2005-03-13 01:13:01 +01:00
index = av_index_search_timestamp ( st , target_ts , flags & ~ AVSEEK_FLAG_BACKWARD ) ;
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
2004-06-12 00:03:16 +02:00
av_log ( s , AV_LOG_DEBUG , " using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld \n " ,
2004-04-12 18:50:03 +02:00
pos_max , pos_limit , ts_max ) ;
# endif
}
}
if ( ts_min = = AV_NOPTS_VALUE ) {
pos_min = s - > data_offset ;
ts_min = avif - > read_timestamp ( s , stream_index , & pos_min , INT64_MAX ) ;
if ( ts_min = = AV_NOPTS_VALUE )
return - 1 ;
}
if ( ts_max = = AV_NOPTS_VALUE ) {
int step = 1024 ;
2005-05-19 02:06:27 +02:00
pos_max = url_fsize ( & s - > pb ) - 1 ;
2004-04-12 18:50:03 +02:00
do {
pos_max - = step ;
ts_max = avif - > read_timestamp ( s , stream_index , & pos_max , pos_max + step ) ;
step + = step ;
} while ( ts_max = = AV_NOPTS_VALUE & & pos_max > = step ) ;
if ( ts_max = = AV_NOPTS_VALUE )
return - 1 ;
for ( ; ; ) {
int64_t tmp_pos = pos_max + 1 ;
int64_t tmp_ts = avif - > read_timestamp ( s , stream_index , & tmp_pos , INT64_MAX ) ;
if ( tmp_ts = = AV_NOPTS_VALUE )
break ;
ts_max = tmp_ts ;
pos_max = tmp_pos ;
}
pos_limit = pos_max ;
}
no_change = 0 ;
while ( pos_min < pos_limit ) {
# ifdef DEBUG_SEEK
av_log ( s , AV_LOG_DEBUG , " pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld \n " ,
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 ;
ts = avif - > read_timestamp ( s , stream_index , & pos , INT64_MAX ) ; //may pass pos_limit instead of -1
if ( pos = = pos_max )
no_change + + ;
else
no_change = 0 ;
# ifdef DEBUG_SEEK
av_log ( s , AV_LOG_DEBUG , " %Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d \n " , pos_min , pos , pos_max , ts_min , ts , ts_max , target_ts , pos_limit , start_pos , no_change ) ;
# 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 ;
}
}
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 ;
ts_min = avif - > read_timestamp ( s , stream_index , & pos_min , INT64_MAX ) ;
pos_min + + ;
ts_max = avif - > read_timestamp ( s , stream_index , & pos_min , INT64_MAX ) ;
av_log ( s , AV_LOG_DEBUG , " pos=0x%llx %lld<=%lld<=%lld \n " ,
pos , ts_min , target_ts , ts_max ) ;
# endif
/* do the seek */
url_fseek ( & s - > pb , pos , SEEK_SET ) ;
2004-05-23 18:26:12 +02:00
2004-10-12 12:28:27 +02:00
av_update_cur_dts ( s , st , ts ) ;
2004-04-12 18:50:03 +02:00
return 0 ;
}
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 ;
}
2003-11-10 19:37:55 +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
2004-10-11 21:42:18 +02:00
* stream is selected , and timestamp is automatically converted
* 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
* @ 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 ;
2003-11-10 19:37:55 +01:00
av_read_frame_flush ( s ) ;
2004-05-23 18:26:12 +02:00
2004-10-11 00:05:43 +02:00
if ( flags & AVSEEK_FLAG_BYTE )
return av_seek_frame_byte ( s , stream_index , timestamp , flags ) ;
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 ;
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
/* return TRUE if the stream has accurate timings for at least one component */
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 ;
}
/* estimate the stream timings from the one of each components. Also
compute the global bitrate if possible */
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 ;
start_time = MAXINT64 ;
end_time = MININT64 ;
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 ;
}
}
}
if ( start_time ! = MAXINT64 ) {
ic - > start_time = start_time ;
if ( end_time ! = MAXINT64 ) {
ic - > duration = end_time - start_time ;
if ( ic - > file_size > 0 ) {
/* compute the bit rate */
ic - > bit_rate = ( double ) ic - > file_size * 8.0 * AV_TIME_BASE /
( 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 ] ;
bit_rate + = st - > codec . bit_rate ;
}
ic - > bit_rate = bit_rate ;
}
/* if duration is already set, we believe it */
if ( ic - > duration = = AV_NOPTS_VALUE & &
ic - > bit_rate ! = 0 & &
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 ;
int64_t start_time , end_time , end_time1 ;
int64_t filesize , offset , duration ;
2003-11-10 19:37:55 +01:00
/* free previous packet */
if ( ic - > cur_st & & ic - > cur_st - > parser )
av_free_packet ( & ic - > cur_pkt ) ;
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 ;
}
}
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 ;
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-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 ;
2004-12-06 01:15:52 +01:00
if ( ( ic - > iformat = = & mpegps_demux | | ic - > iformat = = & mpegts_demux ) & & 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 ] ;
printf ( " %d: start_time: %0.3f duration: %0.3f \n " ,
i , ( double ) st - > start_time / AV_TIME_BASE ,
( double ) st - > duration / AV_TIME_BASE ) ;
}
printf ( " stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s \n " ,
( double ) ic - > start_time / AV_TIME_BASE ,
( 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 ;
int got_picture , ret ;
AVFrame picture ;
codec = avcodec_find_decoder ( st - > codec . codec_id ) ;
if ( ! codec )
return - 1 ;
ret = avcodec_open ( & st - > codec , codec ) ;
if ( ret < 0 )
return ret ;
2005-04-25 20:29:06 +02:00
if ( ! has_codec_parameters ( & st - > codec ) ) {
2003-11-10 19:37:55 +01:00
switch ( st - > codec . codec_type ) {
case CODEC_TYPE_VIDEO :
ret = avcodec_decode_video ( & st - > codec , & picture ,
& got_picture , ( uint8_t * ) data , size ) ;
break ;
case CODEC_TYPE_AUDIO :
samples = av_malloc ( AVCODEC_MAX_AUDIO_FRAME_SIZE ) ;
if ( ! samples )
goto fail ;
ret = avcodec_decode_audio ( & st - > codec , samples ,
& 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 :
avcodec_close ( & st - > codec ) ;
return ret ;
}
/* absolute maximum size we read until we abort */
# define MAX_READ_SIZE 5000000
/* maximum duration until we stop analysing the stream */
# define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
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
* @ 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 )
{
2003-11-10 19:37:55 +01:00
int i , count , ret , read_size ;
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
int64_t duration_sum [ MAX_STREAMS ] ;
int duration_count [ MAX_STREAMS ] = { 0 } ;
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 ] ;
if ( st - > codec . codec_type = = CODEC_TYPE_VIDEO ) {
/* if(!st->time_base.num)
st - > time_base = */
if ( ! st - > codec . time_base . num )
st - > codec . time_base = st - > time_base ;
}
}
2004-12-19 02:23:22 +01:00
for ( i = 0 ; i < MAX_STREAMS ; i + + ) {
last_dts [ i ] = AV_NOPTS_VALUE ;
2005-05-07 01:41:47 +02:00
duration_sum [ i ] = INT64_MAX ;
2004-12-19 02:23:22 +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 ] ;
2003-11-10 19:37:55 +01: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 */
2005-04-30 23:43:59 +02:00
if ( st - > codec . time_base . den > = 1000LL * st - > codec . time_base . num
2005-05-07 01:41:47 +02:00
& & duration_count [ i ] < 20 & & st - > codec . codec_type = = CODEC_TYPE_VIDEO )
2004-12-21 03:16:11 +01: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 ;
}
} else {
/* we did not get all the codec info, but we read too much data */
2003-11-10 19:37:55 +01:00
if ( read_size > = MAX_READ_SIZE ) {
2002-05-20 18:28:47 +02:00
ret = count ;
break ;
}
}
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 ] ;
if ( ! has_codec_parameters ( & st - > codec ) )
break ;
}
2005-05-07 01:41:47 +02:00
if ( i = = ic - > nb_streams )
2003-11-10 19:37:55 +01:00
ret = 0 ;
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 ;
/* duplicate the packet */
if ( av_dup_packet ( pkt ) < 0 ) {
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 ] ;
2003-11-10 19:37:55 +01:00
st - > codec_info_duration + = pkt - > duration ;
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 ) {
if ( duration * duration_count [ index ] * 10 / 9 < duration_sum [ index ] ) {
duration_sum [ index ] = duration ;
duration_count [ index ] = 1 ;
} else {
int factor = av_rescale ( duration , duration_count [ index ] , duration_sum [ index ] ) ;
duration_sum [ index ] + = duration ;
duration_count [ index ] + = factor ;
}
2005-05-22 10:47:09 +02:00
if ( st - > codec_info_nb_frames = = 0 )
st - > codec_info_duration + = duration ;
2004-12-19 02:23:22 +01:00
}
last_dts [ pkt - > stream_index ] = pkt - > dts ;
}
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-04-25 20:29:06 +02:00
if ( ! has_codec_parameters ( & st - > codec ) /*&&
2003-11-10 19:37:55 +01:00
( st - > codec . codec_id = = CODEC_ID_FLV1 | |
st - > codec . codec_id = = CODEC_ID_H264 | |
st - > codec . codec_id = = CODEC_ID_H263 | |
2004-11-13 18:35:09 +01:00
st - > codec . codec_id = = CODEC_ID_H261 | |
2004-04-04 03:10:50 +02:00
st - > codec . codec_id = = CODEC_ID_VORBIS | |
2004-07-15 20:32:54 +02:00
st - > codec . codec_id = = CODEC_ID_MJPEG | |
2004-11-10 00:31:46 +01:00
st - > codec . codec_id = = CODEC_ID_PNG | |
2004-11-11 19:09:28 +01:00
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 | |
2005-02-26 04:36:04 +01:00
st - > codec . codec_id = = CODEC_ID_SHORTEN | |
2005-04-25 20:29:06 +02:00
( 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-05-22 10:47:09 +02:00
if ( av_rescale_q ( st - > codec_info_duration , st - > time_base , AV_TIME_BASE_Q ) > = MAX_STREAM_DURATION ) {
2003-11-10 19:37:55 +01:00
break ;
2002-05-20 18:28:47 +02:00
}
count + + ;
}
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
st = ic - > streams [ i ] ;
if ( st - > codec . codec_type = = CODEC_TYPE_VIDEO ) {
2004-11-30 19:45:34 +01:00
if ( st - > codec . codec_id = = CODEC_ID_RAWVIDEO & & ! st - > codec . codec_tag & & ! st - > codec . bits_per_sample )
2004-11-09 00:36:32 +01:00
st - > codec . codec_tag = avcodec_pix_fmt_to_codec_tag ( st - > codec . pix_fmt ) ;
2004-12-19 02:23:22 +01:00
2005-05-12 18:27:05 +02:00
if ( duration_count [ i ] & & st - > codec . time_base . num * 1000LL < = st - > codec . time_base . den & &
2005-05-07 01:41:47 +02:00
st - > time_base . num * duration_sum [ i ] / duration_count [ i ] * 1000LL > st - > time_base . den ) {
AVRational fps1 ;
int64_t num , den ;
2004-12-21 03:27:40 +01:00
2005-05-07 01:41:47 +02:00
num = st - > time_base . den * duration_count [ i ] ;
den = st - > time_base . num * duration_sum [ i ] ;
2004-12-21 03:27:40 +01:00
2005-05-07 01:41:47 +02:00
av_reduce ( & fps1 . num , & fps1 . den , num * 1001 , den * 1000 , FFMAX ( st - > time_base . den , st - > time_base . num ) / 4 ) ;
av_reduce ( & st - > r_frame_rate . num , & st - > r_frame_rate . den , num , den , FFMAX ( st - > time_base . den , st - > time_base . num ) / 4 ) ;
if ( fps1 . num < st - > r_frame_rate . num & & fps1 . den = = 1 & & ( fps1 . num = = 24 | | fps1 . num = = 30 ) ) { //FIXME better decission
st - > r_frame_rate . num = fps1 . num * 1000 ;
st - > r_frame_rate . den = fps1 . den * 1001 ;
}
2004-12-19 02:23:22 +01:00
}
2004-11-09 00:36:32 +01:00
/* set real frame rate info */
2003-11-10 19:37:55 +01:00
/* compute the real frame rate for telecine */
if ( ( st - > codec . codec_id = = CODEC_ID_MPEG1VIDEO | |
st - > codec . codec_id = = CODEC_ID_MPEG2VIDEO ) & &
st - > codec . sub_id = = 2 ) {
if ( st - > codec_info_nb_frames > = 20 ) {
float coded_frame_rate , est_frame_rate ;
est_frame_rate = ( ( double ) st - > codec_info_nb_frames * AV_TIME_BASE ) /
( double ) st - > codec_info_duration ;
2005-04-30 23:43:59 +02:00
coded_frame_rate = 1.0 / av_q2d ( st - > codec . time_base ) ;
2003-11-10 19:37:55 +01:00
#if 0
printf ( " telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f \n " ,
coded_frame_rate , est_frame_rate ) ;
# endif
/* if we detect that it could be a telecine, we
signal it . It would be better to do it at a
higher level as it can change in a film */
if ( coded_frame_rate > = 24.97 & &
( est_frame_rate > = 23.5 & & est_frame_rate < 24.5 ) ) {
2005-04-30 23:43:59 +02:00
st - > r_frame_rate = ( AVRational ) { 24000 , 1001 } ;
2003-11-10 19:37:55 +01:00
}
}
}
/* if no real frame rate, use the codec one */
2005-04-30 23:43:59 +02:00
if ( ! st - > r_frame_rate . num ) {
st - > r_frame_rate . num = st - > codec . time_base . den ;
st - > r_frame_rate . den = st - > codec . 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 ] ;
if ( st - > codec . codec_type = = CODEC_TYPE_VIDEO ) {
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
* current position
*/
int av_read_play ( AVFormatContext * s )
{
if ( ! s - > iformat - > read_play )
return AVERROR_NOTSUPP ;
return s - > iformat - > read_play ( s ) ;
}
/**
* pause a network based stream ( e . g . RTSP stream ) . Use av_read_play ( )
* to resume it .
*/
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
/**
* Close a media file ( but not its codecs )
*
* @ 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 )
av_free_packet ( & s - > cur_pkt ) ;
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 ) ;
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
/**
* Add a new stream to a media file . Can only be called in the
2003-10-29 15:20:56 +01:00
* 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
2003-10-29 15:20:56 +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 ;
if ( s - > nb_streams > = MAX_STREAMS )
return NULL ;
st = av_mallocz ( sizeof ( AVStream ) ) ;
if ( ! st )
return NULL ;
2002-12-04 11:04:03 +01:00
avcodec_get_context_defaults ( & st - > codec ) ;
2003-08-08 20:13:43 +02:00
if ( s - > iformat ) {
/* no default bitrate if decoding */
st - > codec . bit_rate = 0 ;
}
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 ;
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 ;
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 ;
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
* @ return 0 if OK . AVERROR_xxx if error .
*/
int av_write_header ( AVFormatContext * s )
{
2002-10-21 19:40:23 +02:00
int ret , i ;
AVStream * st ;
ret = s - > oformat - > write_header ( s ) ;
if ( ret < 0 )
return ret ;
/* init PTS generation */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
st = s - > streams [ i ] ;
switch ( st - > codec . codec_type ) {
case CODEC_TYPE_AUDIO :
av_frac_init ( & st - > pts , 0 , 0 ,
2004-05-21 22:43:21 +02:00
( int64_t ) st - > time_base . num * st - > codec . sample_rate ) ;
2002-10-21 19:40:23 +02:00
break ;
case CODEC_TYPE_VIDEO :
av_frac_init ( & st - > pts , 0 , 0 ,
2005-04-30 23:43:59 +02:00
( int64_t ) st - > time_base . num * st - > codec . time_base . den ) ;
2002-10-21 19:40:23 +02:00
break ;
default :
break ;
}
}
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 ) {
2004-05-29 20:50:31 +02:00
int b_frames = FFMAX ( st - > codec . has_b_frames , st - > codec . max_b_frames ) ;
int num , den , frame_size ;
2004-04-04 20:33:07 +02:00
2004-05-29 20:50:31 +02:00
// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
2004-05-29 04:06:32 +02:00
/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
return - 1 ; */
/* 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
if ( ( pkt - > pts = = 0 | | pkt - > pts = = AV_NOPTS_VALUE ) & & pkt - > dts = = AV_NOPTS_VALUE & & ! b_frames ) {
pkt - > dts =
// pkt->pts= st->cur_dts;
pkt - > pts = st - > pts . val ;
}
//calculate dts from pts
if ( pkt - > pts ! = AV_NOPTS_VALUE & & pkt - > dts = = AV_NOPTS_VALUE ) {
if ( b_frames ) {
if ( st - > last_IP_pts = = AV_NOPTS_VALUE ) {
2004-05-29 20:50:31 +02:00
st - > last_IP_pts = - pkt - > duration ;
2004-05-29 04:06:32 +02:00
}
if ( st - > last_IP_pts < pkt - > pts ) {
pkt - > dts = st - > last_IP_pts ;
st - > last_IP_pts = pkt - > pts ;
} else
pkt - > dts = pkt - > pts ;
} else
pkt - > dts = pkt - > pts ;
}
2004-12-14 17:19:26 +01:00
if ( st - > cur_dts & & st - > cur_dts ! = AV_NOPTS_VALUE & & st - > cur_dts > = pkt - > dts ) {
av_log ( NULL , AV_LOG_ERROR , " error, non monotone timestamps %Ld >= %Ld \n " , st - > cur_dts , pkt - > dts ) ;
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 ;
}
2004-05-29 20:50:31 +02:00
// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\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 */
switch ( st - > codec . codec_type ) {
case CODEC_TYPE_AUDIO :
2004-05-29 04:06:32 +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-04-30 23:43:59 +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 ;
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
2004-05-29 20:50:31 +02:00
pkt - > pts & = pts_mask ;
pkt - > dts & = pts_mask ;
}
/**
* Write a packet to an output media file . The packet shall contain
* one audio or video frame .
*
* @ 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 ) ;
if ( ret < 0 )
return ret ;
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
/**
* interleave_packet implementation which will interleave per DTS .
*/
static int av_interleave_packet_per_dts ( AVFormatContext * s , AVPacket * out , AVPacket * pkt , int flush ) {
AVPacketList * pktl , * * next_point , * this_pktl ;
int stream_count = 0 ;
int streams [ MAX_STREAMS ] ;
if ( pkt ) {
AVStream * st = s - > streams [ pkt - > stream_index ] ;
assert ( pkt - > destruct ! = av_destruct_packet ) ; //FIXME
this_pktl = av_mallocz ( sizeof ( AVPacketList ) ) ;
this_pktl - > pkt = * pkt ;
av_dup_packet ( & this_pktl - > pkt ) ;
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 ;
}
memset ( streams , 0 , sizeof ( streams ) ) ;
pktl = s - > packet_buffer ;
while ( pktl ) {
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
if ( streams [ pktl - > pkt . stream_index ] = = 0 )
stream_count + + ;
streams [ pktl - > pkt . stream_index ] + + ;
pktl = pktl - > next ;
}
if ( s - > nb_streams = = stream_count | | ( flush & & stream_count ) ) {
pktl = s - > packet_buffer ;
* out = pktl - > pkt ;
s - > packet_buffer = pktl - > next ;
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
* @ return 1 if a packet was output , 0 if no packet could be output ,
* < 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
/**
* Writes a packet to an output media file ensuring correct interleaving .
* The packet shall contain one audio or video frame .
* 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
if ( st - > codec . codec_type = = CODEC_TYPE_AUDIO & & pkt - > size = = 0 )
return 0 ;
2005-03-24 02:51:57 +01:00
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
if ( compute_pkt_fields2 ( st , pkt ) < 0 )
return - 1 ;
2004-09-30 01:25:01 +02: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 ;
2004-05-29 20:50:31 +02:00
2004-09-30 01:25:01 +02:00
truncate_ts ( s - > streams [ opkt . stream_index ] , & opkt ) ;
ret = s - > oformat - > write_packet ( s , & opkt ) ;
av_free_packet ( & opkt ) ;
pkt = NULL ;
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
}
/**
* write the stream trailer to an output media file and and free the
* file private data .
*
* @ param s media file handle
* @ return 0 if OK . AVERROR_xxx if error . */
int av_write_trailer ( AVFormatContext * s )
{
2004-10-01 18:30:15 +02:00
int ret , i ;
2004-05-29 20:50:31 +02: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 ;
2004-05-29 20:50:31 +02:00
2004-09-30 01:25:01 +02:00
truncate_ts ( s - > streams [ pkt . stream_index ] , & pkt ) ;
ret = s - > oformat - > write_packet ( s , & pkt ) ;
av_free_packet ( & pkt ) ;
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
}
2002-05-20 18:28:47 +02:00
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 ,
int index ,
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 ] ;
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " %s #%d, %s, %s '%s': \n " ,
2001-07-22 16:18:56 +02:00
is_output ? " Output " : " Input " ,
2002-05-20 18:28:47 +02: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 ) {
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " 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 ;
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " %02d:%02d:%02d.%01d " , hours , mins , secs ,
2003-08-08 20:02:23 +02:00
( 10 * us ) / AV_TIME_BASE ) ;
} else {
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " 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 ;
av_log ( NULL , AV_LOG_DEBUG , " , start: " ) ;
secs = ic - > start_time / AV_TIME_BASE ;
us = ic - > start_time % AV_TIME_BASE ;
av_log ( NULL , AV_LOG_DEBUG , " %d.%06d " ,
secs , ( int ) av_rescale ( us , 1000000 , AV_TIME_BASE ) ) ;
}
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " , bitrate: " ) ;
2003-08-08 20:02:23 +02:00
if ( ic - > bit_rate ) {
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " %d kb/s " , ic - > bit_rate / 1000 ) ;
2003-08-08 20:02:23 +02:00
} else {
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " N/A " ) ;
2003-08-08 20:02:23 +02:00
}
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " \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 ] ;
avcodec_string ( buf , sizeof ( buf ) , & st - > codec , is_output ) ;
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " 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 ) {
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " [0x%x] " , st - > id ) ;
2002-05-20 18:28:47 +02:00
}
2004-03-03 18:53:55 +01:00
av_log ( NULL , AV_LOG_DEBUG , " : %s \n " , buf ) ;
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
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 ;
}
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 ;
/* First, we check our abbreviation table */
for ( i = 0 ; i < sizeof ( frame_abvs ) / sizeof ( * frame_abvs ) ; + + i )
if ( ! strcmp ( frame_abvs [ i ] . abv , arg ) ) {
* frame_rate = frame_abvs [ i ] . frame_rate ;
* frame_rate_base = frame_abvs [ i ] . frame_rate_base ;
return 0 ;
}
/* 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 ;
* frame_rate = strtol ( arg , & cpp , 10 ) ;
if ( cpp ! = arg | | cpp = = cp )
* frame_rate_base = strtol ( cp + 1 , & cpp , 10 ) ;
else
* frame_rate = 0 ;
}
else {
/* Finally we give up and parse it as double */
2004-04-04 03:10:50 +02:00
* frame_rate_base = DEFAULT_FRAME_RATE_BASE ; //FIXME use av_d2q()
2003-07-12 09:37:05 +02:00
* frame_rate = ( int ) ( strtod ( arg , 0 ) * ( * frame_rate_base ) + 0.5 ) ;
}
if ( ! * frame_rate | | ! * frame_rate_base )
return - 1 ;
else
return 0 ;
}
2002-10-21 17:54:49 +02:00
/* Syntax:
* - 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
2002-10-21 17:54:49 +02:00
* Return the date in micro seconds since 1970
* - If duration :
* HH [ : MM [ : SS [ . m . . . ] ] ]
* S + [ . m . . . ]
*/
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 {
2004-06-12 00:03:16 +02: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
2003-02-11 17:35:48 +01:00
return now * int64_t_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 + + ) {
if ( ! isdigit ( * q ) )
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
}
2002-06-14 05:38:00 +02:00
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2001-07-22 16:18:56 +02:00
1 if found */
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 ' ;
}
if ( ! strcmp ( tag , tag1 ) )
return 1 ;
if ( * p ! = ' & ' )
break ;
2002-05-10 04:17:41 +02:00
p + + ;
2001-07-22 16:18:56 +02:00
}
return 0 ;
}
2001-09-16 23:50:48 +02:00
/* Return in 'buf' the path with '%d' replaced by number. Also handles
the ' % 0 nd ' format where ' n ' is the total number of digits and
' % % ' . Return 0 if OK , and - 1 if format error */
int get_frame_filename ( char * buf , int buf_size ,
const char * path , int number )
{
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
/**
* Set the pts for a given stream
* @ param s stream
* @ param pts_wrap_bits number of bits effectively used by the pts
* ( used for wrap control , 33 is the value for MPEG )
* @ param pts_num numerator to convert to seconds ( MPEG : 1 )
* @ 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 */
/**
* f = val + ( num / den ) + 0.5 . ' num ' is normalized so that it is such
* as 0 < = num < den .
*
* @ param f fractional number
* @ param val integer value
* @ param num must be > = 0
* @ param den must be > = 1
*/
2003-02-11 17:35:48 +01:00
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 ;
}
/* set f to (val + 0.5) */
2003-02-11 17:35:48 +01:00
void av_frac_set ( AVFrac * f , int64_t val )
2002-10-21 17:54:49 +02:00
{
f - > val = val ;
f - > num = f - > den > > 1 ;
}
/**
* Fractionnal addition to f : f = f + ( incr / f - > den )
*
* @ param f fractional number
* @ param incr increment , can be positive or negative
*/
2003-02-11 17:35:48 +01:00
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 ;
}
2003-01-11 06:02:14 +01:00
/**
* register a new image format
* @ param img_fmt Image format descriptor
*/
void av_register_image_format ( AVImageFormat * img_fmt )
{
AVImageFormat * * p ;
p = & first_image_format ;
while ( * p ! = NULL ) p = & ( * p ) - > next ;
* p = img_fmt ;
img_fmt - > next = NULL ;
}
/* guess image format */
AVImageFormat * av_probe_image_format ( AVProbeData * pd )
{
AVImageFormat * fmt1 , * fmt ;
int score , score_max ;
fmt = NULL ;
score_max = 0 ;
for ( fmt1 = first_image_format ; fmt1 ! = NULL ; fmt1 = fmt1 - > next ) {
if ( fmt1 - > img_probe ) {
score = fmt1 - > img_probe ( pd ) ;
if ( score > score_max ) {
score_max = score ;
fmt = fmt1 ;
}
}
}
return fmt ;
}
AVImageFormat * guess_image_format ( const char * filename )
{
AVImageFormat * fmt1 ;
for ( fmt1 = first_image_format ; fmt1 ! = NULL ; fmt1 = fmt1 - > next ) {
if ( fmt1 - > extensions & & match_ext ( filename , fmt1 - > extensions ) )
return fmt1 ;
}
return NULL ;
}
/**
* Read an image from a stream .
* @ param gb byte stream containing the image
* @ param fmt image format , NULL if probing is required
*/
int av_read_image ( ByteIOContext * pb , const char * filename ,
AVImageFormat * fmt ,
int ( * alloc_cb ) ( void * , AVImageInfo * info ) , void * opaque )
{
char buf [ PROBE_BUF_SIZE ] ;
AVProbeData probe_data , * pd = & probe_data ;
offset_t pos ;
int ret ;
if ( ! fmt ) {
2003-02-10 10:35:32 +01:00
pd - > filename = filename ;
2003-01-11 06:02:14 +01:00
pd - > buf = buf ;
pos = url_ftell ( pb ) ;
pd - > buf_size = get_buffer ( pb , buf , PROBE_BUF_SIZE ) ;
url_fseek ( pb , pos , SEEK_SET ) ;
fmt = av_probe_image_format ( pd ) ;
}
if ( ! fmt )
return AVERROR_NOFMT ;
ret = fmt - > img_read ( pb , alloc_cb , opaque ) ;
return ret ;
}
/**
* Write an image to a stream .
* @ param pb byte stream for the image output
* @ param fmt image format
* @ param img image data and informations
*/
int av_write_image ( ByteIOContext * pb , AVImageFormat * fmt , AVImageInfo * img )
{
return fmt - > img_write ( pb , img ) ;
}