/*
* producer_avformat.c -- avformat producer
- * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
+ * Copyright (C) 2003-2009 Ushodaya Enterprises Limited
* Author: Charles Yates <charles.yates@pandora.be>
+ * Author: Dan Dennedy <dan@dennedy.org>
* Much code borrowed from ffmpeg.c: Copyright (c) 2000-2003 Fabrice Bellard
*
* This library is free software; you can redistribute it and/or
#include <framework/mlt_frame.h>
#include <framework/mlt_profile.h>
#include <framework/mlt_log.h>
+#include <framework/mlt_deque.h>
+#include <framework/mlt_factory.h>
+#include <framework/mlt_cache.h>
// ffmpeg Header files
#include <avformat.h>
#if (LIBAVCODEC_VERSION_INT >= ((51<<16)+(71<<8)+0))
# include "audioconvert.h"
#endif
+#ifdef VDPAU
+#include <vdpau.h>
+#endif
// System header files
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <limits.h>
+#include <dlfcn.h>
#if LIBAVUTIL_VERSION_INT < (50<<16)
#define PIX_FMT_RGB32 PIX_FMT_RGBA32
#define POSITION_INVALID (-1)
#define MAX_AUDIO_STREAMS (8)
+#define MAX_VDPAU_SURFACES (10)
void avformat_lock( );
void avformat_unlock( );
struct producer_avformat_s
{
- struct mlt_producer_s parent;
+ mlt_producer parent;
AVFormatContext *dummy_context;
AVFormatContext *audio_format;
AVFormatContext *video_format;
int max_channel;
int max_frequency;
unsigned int invalid_pts_counter;
+ double resample_factor;
+#ifdef VDPAU
+ struct
+ {
+ // from FFmpeg
+ struct vdpau_render_state render_states[MAX_VDPAU_SURFACES];
+
+ // internal
+ mlt_deque deque;
+ int b_age;
+ int ip_age[2];
+ int is_decoded;
+ uint8_t *buffer;
+ } *vdpau;
+#endif
};
typedef struct producer_avformat_s *producer_avformat;
static int producer_open( producer_avformat this, mlt_profile profile, char *file );
static int producer_get_frame( mlt_producer this, mlt_frame_ptr frame, int index );
static void producer_format_close( void *context );
+static void producer_avformat_close( producer_avformat );
static void producer_close( mlt_producer parent );
+#ifdef VDPAU
+#include "vdpau.c"
+#endif
+
/** Constructor for libavformat.
*/
if ( !skip && file )
{
// Construct the producer
+ mlt_producer producer = calloc( 1, sizeof( struct mlt_producer_s ) );
producer_avformat this = calloc( 1, sizeof( struct producer_avformat_s ) );
// Initialise it
- if ( mlt_producer_init( &this->parent, this ) == 0 )
+ if ( mlt_producer_init( producer, this ) == 0 )
{
- mlt_producer producer = &this->parent;
+ this->parent = producer;
// Get the properties
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
// Register our get_frame implementation
producer->get_frame = producer_get_frame;
-
+
// Open the file
if ( producer_open( this, profile, file ) != 0 )
{
}
else
{
- // Close the file to release resources for large playlists - reopen later as needed
- producer_format_close( this->dummy_context );
- this->dummy_context = NULL;
- producer_format_close( this->audio_format );
- this->audio_format = NULL;
- producer_format_close( this->video_format );
- this->video_format = NULL;
-
// Default the user-selectable indices from the auto-detected indices
mlt_properties_set_int( properties, "audio_index", this->audio_index );
mlt_properties_set_int( properties, "video_index", this->video_index );
+
+#ifdef VDPAU
+ mlt_service_cache_set_size( MLT_PRODUCER_SERVICE(producer), "producer_avformat", 5 );
+#endif
+ mlt_service_cache_put( MLT_PRODUCER_SERVICE(producer), "producer_avformat", this, 0, (mlt_destructor) producer_avformat_close );
}
return producer;
}
AVFormatContext *context = NULL;
// Get the properties
- mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent );
+ mlt_properties properties = MLT_PRODUCER_PROPERTIES( this->parent );
// We will treat everything with the producer fps
double fps = mlt_profile_fps( profile );
}
mlt_log_verbose( NULL, "[producer avformat] audio: total_streams %d max_stream %d total_channels %d max_channels %d\n",
this->audio_streams, this->audio_max_stream, this->total_channels, this->max_channel );
+
+ // Other audio-specific initializations
+ this->resample_factor = 1.0;
}
static inline void convert_image( AVFrame *frame, uint8_t *buffer, int pix_fmt, mlt_image_format *format, int width, int height )
{
// Get the producer
producer_avformat this = mlt_frame_pop_service( frame );
- mlt_producer producer = &this->parent;
+ mlt_producer producer = this->parent;
// Get the properties from the frame
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
{
// Duplicate it
if ( allocate_buffer( frame_properties, codec_context, buffer, format, width, height ) )
+#ifdef VDPAU
+ if ( this->vdpau && this->vdpau->buffer )
+ {
+ AVPicture picture;
+ picture.data[0] = this->vdpau->buffer;
+ picture.data[2] = this->vdpau->buffer + codec_context->width * codec_context->height;
+ picture.data[1] = this->vdpau->buffer + codec_context->width * codec_context->height * 5 / 4;
+ picture.linesize[0] = codec_context->width;
+ picture.linesize[1] = codec_context->width / 2;
+ picture.linesize[2] = codec_context->width / 2;
+ convert_image( (AVFrame*) &picture, *buffer, PIX_FMT_YUV420P, format, *width, *height );
+ }
+ else
+#endif
convert_image( this->av_frame, *buffer, codec_context->pix_fmt, format, *width, *height );
else
mlt_frame_get_image( frame, buffer, format, width, height, writable );
{
this->invalid_pts_counter = 0;
}
- mlt_log_debug( MLT_PRODUCER_SERVICE(producer), "pkt.pts %llu req_pos %d cur_pos %d pkt_pos %d",
+ mlt_log_debug( MLT_PRODUCER_SERVICE(producer), "pkt.pts %llu req_pos %d cur_pos %d pkt_pos %d\n",
pkt.pts, req_position, this->current_position, int_position );
}
else
{
int_position = req_position;
}
- mlt_log_debug( MLT_PRODUCER_SERVICE(producer), "pkt.dts %llu req_pos %d cur_pos %d pkt_pos %d",
+ mlt_log_debug( MLT_PRODUCER_SERVICE(producer), "pkt.dts %llu req_pos %d cur_pos %d pkt_pos %d\n",
pkt.dts, req_position, this->current_position, int_position );
// Make a dumb assumption on streams that contain wild timestamps
if ( abs( req_position - int_position ) > 999 )
// Decode the image
if ( must_decode || int_position >= req_position )
{
+#ifdef VDPAU
+ if ( g_vdpau && this->vdpau )
+ {
+ if ( g_vdpau->producer != this )
+ {
+ vdpau_decoder_close();
+ vdpau_decoder_init( this );
+ }
+ if ( this->vdpau )
+ this->vdpau->is_decoded = 0;
+ }
+#endif
codec_context->reordered_opaque = pkt.pts;
if ( int_position >= req_position )
codec_context->skip_loop_filter = AVDISCARD_NONE;
{
if ( allocate_buffer( frame_properties, codec_context, buffer, format, width, height ) )
{
+#ifdef VDPAU
+ if ( this->vdpau )
+ {
+ if ( this->vdpau->is_decoded )
+ {
+ struct vdpau_render_state *render = (struct vdpau_render_state*) this->av_frame->data[0];
+ void *planes[3];
+ uint32_t pitches[3];
+ VdpYCbCrFormat dest_format = VDP_YCBCR_FORMAT_YV12;
+ AVPicture picture;
+
+ if ( !this->vdpau->buffer )
+ this->vdpau->buffer = mlt_pool_alloc( codec_context->width * codec_context->height * 3 / 2 );
+ picture.data[0] = planes[0] = this->vdpau->buffer;
+ picture.data[2] = planes[1] = this->vdpau->buffer + codec_context->width * codec_context->height;
+ picture.data[1] = planes[2] = this->vdpau->buffer + codec_context->width * codec_context->height * 5 / 4;
+ picture.linesize[0] = pitches[0] = codec_context->width;
+ picture.linesize[1] = pitches[1] = codec_context->width / 2;
+ picture.linesize[2] = pitches[2] = codec_context->width / 2;
+
+ VdpStatus status = vdp_surface_get_bits( render->surface, dest_format, planes, pitches );
+ if ( status == VDP_STATUS_OK )
+ {
+ convert_image( (AVFrame*) &picture, *buffer, PIX_FMT_YUV420P, format, *width, *height );
+ }
+ else
+ {
+ mlt_log_error( MLT_PRODUCER_SERVICE(producer), "VDPAU Error: %s\n", vdp_get_error_string( status ) );
+ this->vdpau->is_decoded = 0;
+ }
+ }
+ else
+ {
+ mlt_log_error( MLT_PRODUCER_SERVICE(producer), "VDPAU error in VdpDecoderRender\n" );
+ got_picture = 0;
+ }
+ }
+ else
+#endif
convert_image( this->av_frame, *buffer, codec_context->pix_fmt, format, *width, *height );
if ( !mlt_properties_get( properties, "force_progressive" ) )
mlt_properties_set_int( frame_properties, "progressive", !this->av_frame->interlaced_frame );
// Find the codec
AVCodec *codec = avcodec_find_decoder( codec_context->codec_id );
+#ifdef VDPAU
+ if ( codec_context->codec_id == CODEC_ID_H264 )
+ {
+ if ( ( codec = avcodec_find_decoder_by_name( "h264_vdpau" ) ) )
+ {
+ if ( vdpau_init( this ) )
+ {
+ this->video_codec = codec_context;
+ if ( !vdpau_decoder_init( this ) )
+ vdpau_decoder_close();
+ }
+ }
+ if ( !this->vdpau )
+ codec = avcodec_find_decoder( codec_context->codec_id );
+ }
+#endif
// Initialise multi-threading
int thread_count = mlt_properties_get_int( properties, "threads" );
if ( codec && avcodec_open( codec_context, codec ) >= 0 )
{
// Now store the codec with its destructor
- producer_codec_close( this->video_codec );
this->video_codec = codec_context;
}
else
if ( source_fps > 0 )
mlt_properties_set_double( properties, "source_fps", source_fps );
else
- mlt_properties_set_double( properties, "source_fps", mlt_producer_get_fps( &this->parent ) );
+ mlt_properties_set_double( properties, "source_fps", mlt_producer_get_fps( this->parent ) );
}
return this->video_codec && this->video_index > -1;
}
static void producer_set_up_video( producer_avformat this, mlt_frame frame )
{
// Get the producer
- mlt_producer producer = &this->parent;
+ mlt_producer producer = this->parent;
// Get the properties
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
// If decoded successfully
if ( data_size > 0 )
{
+ // Figure out how many samples will be needed after resampling
+ int convert_samples = data_size / codec_context->channels / ( av_get_bits_per_sample_format( codec_context->sample_fmt ) / 8 );
+ int samples_needed = this->resample_factor * convert_samples + 1;
+
// Resize audio buffer to prevent overflow
- if ( audio_used * channels + data_size > this->audio_buffer_size[ index ] )
+ if ( audio_used * channels + samples_needed > this->audio_buffer_size[ index ] )
{
- mlt_pool_release( this->audio_buffer[ index ] );
- this->audio_buffer_size[ index ] = audio_used * channels * sizeof(int16_t) + data_size * 2;
- audio_buffer = this->audio_buffer[ index ] = mlt_pool_alloc( this->audio_buffer_size[ index ] );
+ this->audio_buffer_size[ index ] *= 2;
+ audio_buffer = this->audio_buffer[ index ] = mlt_pool_realloc( audio_buffer, this->audio_buffer_size[ index ] * sizeof(int16_t) );
}
if ( resample )
{
// Copy to audio buffer while resampling
int16_t *source = decode_buffer;
int16_t *dest = &audio_buffer[ audio_used * channels ];
- int convert_samples = data_size / codec_context->channels / ( av_get_bits_per_sample_format( codec_context->sample_fmt ) / 8 );
audio_used += audio_resample( resample, dest, source, convert_samples );
}
else
{
// Straight copy to audio buffer
memcpy( &audio_buffer[ audio_used * codec_context->channels ], decode_buffer, data_size );
- audio_used += data_size / codec_context->channels / ( av_get_bits_per_sample_format( codec_context->sample_fmt ) / 8 );
+ audio_used += convert_samples;
}
// Handle ignore
mlt_position position = mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame ), "avformat_position" );
// Calculate the real time code
- double real_timecode = producer_time_of_frame( &this->parent, position );
+ double real_timecode = producer_time_of_frame( this->parent, position );
// Get the source fps
- double source_fps = mlt_properties_get_double( MLT_PRODUCER_PROPERTIES( &this->parent ), "source_fps" );
+ double source_fps = mlt_properties_get_double( MLT_PRODUCER_PROPERTIES( this->parent ), "source_fps" );
// Number of frames to ignore (for ffwd)
int ignore = 0;
// Fetch the audio_format
AVFormatContext *context = this->audio_format;
-
+
// Determine the tracks to use
int index = this->audio_index;
int index_max = this->audio_index + 1;
// Check for resample and create if necessary
if ( codec_context->channels <= 2 )
{
+ // Determine by how much resampling will increase number of samples
+ double resample_factor = this->audio_index == INT_MAX ? 1 : (double) *channels / codec_context->channels;
+ resample_factor *= (double) *frequency / codec_context->sample_rate;
+ if ( resample_factor > this->resample_factor )
+ this->resample_factor = resample_factor;
+
// Create the resampler
#if (LIBAVCODEC_VERSION_INT >= ((52<<16)+(15<<8)+0))
this->audio_resample[ index ] = av_audio_resample_init(
}
// Check for audio buffer and create if necessary
- this->audio_buffer[ index ] = mlt_pool_alloc( AVCODEC_MAX_AUDIO_FRAME_SIZE * sizeof( int16_t ) );
this->audio_buffer_size[ index ] = AVCODEC_MAX_AUDIO_FRAME_SIZE;
+ this->audio_buffer[ index ] = mlt_pool_alloc( this->audio_buffer_size[ index ] * sizeof( int16_t ) );
// Check for decoder buffer and create if necessary
this->decode_buffer[ index ] = av_malloc( AVCODEC_MAX_AUDIO_FRAME_SIZE * sizeof( int16_t ) );
static void producer_set_up_audio( producer_avformat this, mlt_frame frame )
{
// Get the producer
- mlt_producer producer = &this->parent;
+ mlt_producer producer = this->parent;
// Get the properties
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Access the private data
- producer_avformat this = producer->child;
+ mlt_cache_item cache_item = mlt_service_cache_get( MLT_PRODUCER_SERVICE(producer), "producer_avformat" );
+ producer_avformat this = mlt_cache_item_data( cache_item, NULL );
// Create an empty frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
+
+ if ( *frame )
+ mlt_properties_set_data( MLT_FRAME_PROPERTIES(*frame), "avformat_cache", cache_item, 0, (mlt_destructor) mlt_cache_item_close, NULL );
+ else
+ mlt_cache_item_close( cache_item );
// Update timecode on the frame we're creating
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Set the position of this producer
mlt_properties_set_position( MLT_FRAME_PROPERTIES( *frame ), "avformat_position", mlt_producer_frame( producer ) );
+
+ // If cache miss
+ if ( !this )
+ {
+ this = calloc( 1, sizeof( struct producer_avformat_s ) );
+ producer->child = this;
+ this->parent = producer;
+ mlt_service_cache_put( MLT_PRODUCER_SERVICE(producer), "producer_avformat", this, 0, (mlt_destructor) producer_avformat_close );
+ }
// Set up the video
producer_set_up_video( this, *frame );
return 0;
}
-static void producer_close( mlt_producer parent )
+static void producer_avformat_close( producer_avformat this )
{
- // Obtain this
- producer_avformat this = parent->child;
-
+ mlt_log_debug( MLT_PRODUCER_SERVICE(this->parent), "producer_avformat_close\n" );
// Close the file
av_free( this->av_frame );
int i;
producer_format_close( this->dummy_context );
producer_format_close( this->audio_format );
producer_format_close( this->video_format );
+#ifdef VDPAU
+ vdpau_producer_close( this );
+#endif
+ free( this );
+}
+static void producer_close( mlt_producer parent )
+{
// Close the parent
parent->close = NULL;
mlt_producer_close( parent );
// Free the memory
- free( this );
+ free( parent );
}
projects / mlt / blobdiff