/* return -1 if no image found */
static int find_image_range(int *pfirst_index, int *plast_index,
const char *path)
{
char buf[1024];
int range, last_index, range1, first_index;
/* find the first image */
for(first_index = 0; first_index < 5; first_index++)
{
if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0)
{
*pfirst_index =
*plast_index = 1;
if(url_exist(buf))
return 0;
return -1;
}
if (url_exist(buf))
break;
}
if (first_index == 5)
goto fail;
/* find the last image */
last_index = first_index;
for(;;)
{
range = 0;
for(;;)
{
if (!range)
range1 = 1;
else
range1 = 2 * range;
if (av_get_frame_filename(buf, sizeof(buf), path,
last_index + range1) < 0)
goto fail;
if (!url_exist(buf))
break;
range = range1;
/* just in case... */
if (range >= (1 << 30))
goto fail;
}
/* we are sure than image last_index + range exists */
if (!range)
break;
last_index += range;
}
*pfirst_index = first_index;
*plast_index = last_index;
return 0;
fail:
return -1;
}
static double get_aspect_ratio( AVStream *stream, AVCodecContext *codec_context, AVPacket *pkt )
{
double aspect_ratio = 1.0;
if ( codec_context->codec_id == CODEC_ID_DVVIDEO )
{
if ( pkt )
{
if ( dv_is_pal( pkt ) )
{
aspect_ratio = dv_is_wide( pkt )
? 64.0/45.0 // 16:9 PAL
: 16.0/15.0; // 4:3 PAL
}
else
{
aspect_ratio = dv_is_wide( pkt )
? 32.0/27.0 // 16:9 NTSC
: 8.0/9.0; // 4:3 NTSC
}
}
else
{
AVRational ar =
#if LIBAVFORMAT_VERSION_INT >= ((52<<16)+(21<<8)+0)
stream->sample_aspect_ratio;
#else
codec_context->sample_aspect_ratio;
#endif
// Override FFmpeg's notion of DV aspect ratios, which are
// based upon a width of 704. Since we do not have a normaliser
// that crops (nor is cropping 720 wide ITU-R 601 video always desirable)
// we just coerce the values to facilitate a passive behaviour through
// the rescale normaliser when using equivalent producers and consumers.
// = display_aspect / (width * height)
if ( ar.num == 10 && ar.den == 11 )
aspect_ratio = 8.0/9.0; // 4:3 NTSC
else if ( ar.num == 59 && ar.den == 54 )
aspect_ratio = 16.0/15.0; // 4:3 PAL
else if ( ar.num == 40 && ar.den == 33 )
aspect_ratio = 32.0/27.0; // 16:9 NTSC
else if ( ar.num == 118 && ar.den == 81 )
aspect_ratio = 64.0/45.0; // 16:9 PAL
}
}
else
{
AVRational codec_sar = codec_context->sample_aspect_ratio;
AVRational stream_sar =
#if LIBAVFORMAT_VERSION_INT >= ((52<<16)+(21<<8)+0)
stream->sample_aspect_ratio;
#else
{ 0, 1 };
#endif
if ( codec_sar.num > 0 )
aspect_ratio = av_q2d( codec_sar );
else if ( stream_sar.num > 0 )
aspect_ratio = av_q2d( stream_sar );
}
return aspect_ratio;
}
/** Open the file.
*/
static int producer_open( mlt_producer this, mlt_profile profile, char *file )
{
// Return an error code (0 == no error)
int error = 0;
// Context for avformat
AVFormatContext *context = NULL;
// Get the properties
mlt_properties properties = MLT_PRODUCER_PROPERTIES( this );
// We will treat everything with the producer fps
double fps = mlt_profile_fps( profile );
// Lock the mutex now
avformat_lock( );
// If "MRL", then create AVInputFormat
AVInputFormat *format = NULL;
AVFormatParameters *params = NULL;
char *standard = NULL;
char *mrl = strchr( file, ':' );
// AV option (0 = both, 1 = video, 2 = audio)
int av = 0;
// Only if there is not a protocol specification that avformat can handle
if ( mrl && !url_exist( file ) )
{
// 'file' becomes format abbreviation
mrl[0] = 0;
// Lookup the format
format = av_find_input_format( file );
// Eat the format designator
file = ++mrl;
if ( format )
{
// Allocate params
params = calloc( sizeof( AVFormatParameters ), 1 );
// These are required by video4linux (defaults)
params->width = 640;
params->height = 480;
params->time_base= (AVRational){1,25};
// params->device = file;
params->channels = 2;
params->sample_rate = 48000;
}
// XXX: this does not work anymore since avdevice
// TODO: make producer_avddevice?
// Parse out params
mrl = strchr( file, '?' );
while ( mrl )
{
mrl[0] = 0;
char *name = strdup( ++mrl );
char *value = strchr( name, ':' );
if ( value )
{
value[0] = 0;
value++;
char *t = strchr( value, '&' );
if ( t )
t[0] = 0;
if ( !strcmp( name, "frame_rate" ) )
params->time_base.den = atoi( value );
else if ( !strcmp( name, "frame_rate_base" ) )
params->time_base.num = atoi( value );
else if ( !strcmp( name, "sample_rate" ) )
params->sample_rate = atoi( value );
else if ( !strcmp( name, "channels" ) )
params->channels = atoi( value );
else if ( !strcmp( name, "width" ) )
params->width = atoi( value );
else if ( !strcmp( name, "height" ) )
params->height = atoi( value );
else if ( !strcmp( name, "standard" ) )
{
standard = strdup( value );
params->standard = standard;
}
else if ( !strcmp( name, "av" ) )
av = atoi( value );
}
free( name );
mrl = strchr( mrl, '&' );
}
}
// Now attempt to open the file
error = av_open_input_file( &context, file, format, 0, params ) < 0;
// Cleanup AVFormatParameters
free( standard );
free( params );
// If successful, then try to get additional info
if ( error == 0 )
{
// Get the stream info
error = av_find_stream_info( context ) < 0;
// Continue if no error
if ( error == 0 )
{
// We will default to the first audio and video streams found
int audio_index = -1;
int video_index = -1;
int av_bypass = 0;
// Now set properties where we can (use default unknowns if required)
if ( context->duration != AV_NOPTS_VALUE )
{
// This isn't going to be accurate for all formats
mlt_position frames = ( mlt_position )( ( ( double )context->duration / ( double )AV_TIME_BASE ) * fps + 0.5 );
mlt_properties_set_position( properties, "out", frames - 1 );
mlt_properties_set_position( properties, "length", frames );
}
// Find default audio and video streams
find_default_streams( properties, context, &audio_index, &video_index );
if ( context->start_time != AV_NOPTS_VALUE )
mlt_properties_set_double( properties, "_start_time", context->start_time );
// Check if we're seekable (something funny about mpeg here :-/)
if ( strcmp( file, "pipe:" ) && strncmp( file, "http://", 6 ) && strncmp( file, "udp:", 4 ) && strncmp( file, "tcp:", 4 ) && strncmp( file, "rtsp:", 5 ) && strncmp( file, "rtp:", 4 ) )
{
mlt_properties_set_int( properties, "seekable", av_seek_frame( context, -1, mlt_properties_get_double( properties, "_start_time" ), AVSEEK_FLAG_BACKWARD ) >= 0 );
mlt_properties_set_data( properties, "dummy_context", context, 0, producer_file_close, NULL );
av_open_input_file( &context, file, NULL, 0, NULL );
av_find_stream_info( context );
}
else
av_bypass = 1;
// Store selected audio and video indexes on properties
mlt_properties_set_int( properties, "_audio_index", audio_index );
mlt_properties_set_int( properties, "_video_index", video_index );
mlt_properties_set_int( properties, "_last_position", -1 );
// Fetch the width, height and aspect ratio
if ( video_index != -1 )
{
AVCodecContext *codec_context = context->streams[ video_index ]->codec;
mlt_properties_set_int( properties, "width", codec_context->width );
mlt_properties_set_int( properties, "height", codec_context->height );
if ( codec_context->codec_id == CODEC_ID_DVVIDEO )
{
// Fetch the first frame of DV so we can read it directly
AVPacket pkt;
int ret = 0;
while ( ret >= 0 )
{
ret = av_read_frame( context, &pkt );
if ( ret >= 0 && pkt.stream_index == video_index && pkt.size > 0 )
{
mlt_properties_set_double( properties, "aspect_ratio",
get_aspect_ratio( context->streams[ video_index ], codec_context, &pkt ) );
break;
}
}
}
else
{
mlt_properties_set_double( properties, "aspect_ratio",
get_aspect_ratio( context->streams[ video_index ], codec_context, NULL ) );
}
}
// Read Metadata
if (context->title != NULL)
mlt_properties_set(properties, "meta.attr.title.markup", context->title );
if (context->author != NULL)
mlt_properties_set(properties, "meta.attr.author.markup", context->author );
if (context->copyright != NULL)
mlt_properties_set(properties, "meta.attr.copyright.markup", context->copyright );
if (context->comment != NULL)
mlt_properties_set(properties, "meta.attr.comment.markup", context->comment );
if (context->album != NULL)
mlt_properties_set(properties, "meta.attr.album.markup", context->album );
if (context->year != 0)
mlt_properties_set_int(properties, "meta.attr.year.markup", context->year );
if (context->track != 0)
mlt_properties_set_int(properties, "meta.attr.track.markup", context->track );
// We're going to cheat here - for a/v files, we will have two contexts (reasoning will be clear later)
if ( av == 0 && audio_index != -1 && video_index != -1 )
{
// We'll use the open one as our video_context
mlt_properties_set_data( properties, "video_context", context, 0, producer_file_close, NULL );
// And open again for our audio context
av_open_input_file( &context, file, NULL, 0, NULL );
av_find_stream_info( context );
// Audio context
mlt_properties_set_data( properties, "audio_context", context, 0, producer_file_close, NULL );
}
else if ( av != 2 && video_index != -1 )
{
// We only have a video context
mlt_properties_set_data( properties, "video_context", context, 0, producer_file_close, NULL );
}
else if ( audio_index != -1 )
{
// We only have an audio context
mlt_properties_set_data( properties, "audio_context", context, 0, producer_file_close, NULL );
}
else
{
// Something has gone wrong
error = -1;
}
mlt_properties_set_int( properties, "av_bypass", av_bypass );
}
}
// Unlock the mutex now
avformat_unlock( );
return error;
}
/** Convert a frame position to a time code.
*/
static double producer_time_of_frame( mlt_producer this, mlt_position position )
{
return ( double )position / mlt_producer_get_fps( this );
}
static inline void convert_image( AVFrame *frame, uint8_t *buffer, int pix_fmt, mlt_image_format format, int width, int height )
{
#ifdef SWSCALE
if ( format == mlt_image_yuv420p )
{
struct SwsContext *context = sws_getContext( width, height, pix_fmt,
width, height, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
AVPicture output;
output.data[0] = buffer;
output.data[1] = buffer + width * height;
output.data[2] = buffer + ( 3 * width * height ) / 2;
output.linesize[0] = width;
output.linesize[1] = width >> 1;
output.linesize[2] = width >> 1;
sws_scale( context, frame->data, frame->linesize, 0, height,
output.data, output.linesize);
sws_freeContext( context );
}
else if ( format == mlt_image_rgb24 )
{
struct SwsContext *context = sws_getContext( width, height, pix_fmt,
width, height, PIX_FMT_RGB24, SWS_FAST_BILINEAR, NULL, NULL, NULL);
AVPicture output;
avpicture_fill( &output, buffer, PIX_FMT_RGB24, width, height );
sws_scale( context, frame->data, frame->linesize, 0, height,
output.data, output.linesize);
sws_freeContext( context );
}
else
{
struct SwsContext *context = sws_getContext( width, height, pix_fmt,
width, height, PIX_FMT_YUYV422, SWS_FAST_BILINEAR, NULL, NULL, NULL);
AVPicture output;
avpicture_fill( &output, buffer, PIX_FMT_YUYV422, width, height );
sws_scale( context, frame->data, frame->linesize, 0, height,
output.data, output.linesize);
sws_freeContext( context );
}
#else
if ( format == mlt_image_yuv420p )
{
AVPicture pict;
pict.data[0] = buffer;
pict.data[1] = buffer + width * height;
pict.data[2] = buffer + ( 3 * width * height ) / 2;
pict.linesize[0] = width;
pict.linesize[1] = width >> 1;
pict.linesize[2] = width >> 1;
img_convert( &pict, PIX_FMT_YUV420P, (AVPicture *)frame, pix_fmt, width, height );
}
