X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmodules%2Fsdl%2Fconsumer_sdl.c;h=eee6cdd79088168c59a1b7d13e58c0791c10d108;hb=24629fe02afcef099e19a78d838ec941d3616ab7;hp=aac59c887db54491e8b199b8bc319f27e0a4c0ab;hpb=11410cf74f5de6c8f4460a8b12119fa5558153a1;p=melted

diff --git a/src/modules/sdl/consumer_sdl.c b/src/modules/sdl/consumer_sdl.c
index aac59c8..eee6cdd 100644
--- a/src/modules/sdl/consumer_sdl.c
+++ b/src/modules/sdl/consumer_sdl.c
@@ -41,14 +41,17 @@ struct consumer_sdl_s
 	mlt_deque queue;
 	pthread_t thread;
 	int running;
-	uint8_t audio_buffer[ 4096 * 19 ];
+	uint8_t audio_buffer[ 4096 * 10 ];
 	int audio_avail;
 	pthread_mutex_t audio_mutex;
 	pthread_cond_t audio_cond;
+	pthread_mutex_t video_mutex;
+	pthread_cond_t video_cond;
 	int window_width;
 	int window_height;
 	float aspect_ratio;
 	float display_aspect;
+	double last_frame_aspect;
 	int width;
 	int height;
 	int playing;
@@ -100,6 +103,8 @@ mlt_consumer consumer_sdl_init( char *arg )
 		// This is the initialisation of the consumer
 		pthread_mutex_init( &this->audio_mutex, NULL );
 		pthread_cond_init( &this->audio_cond, NULL);
+		pthread_mutex_init( &this->video_mutex, NULL );
+		pthread_cond_init( &this->video_cond, NULL);
 		
 		// Default scaler (for now we'll use nearest)
 		mlt_properties_set( this->properties, "rescale", "nearest" );
@@ -335,13 +340,16 @@ static int consumer_play_audio( consumer_sdl this, mlt_frame frame, int init_aud
 		mlt_properties properties = mlt_frame_properties( frame );
 		bytes = ( samples * channels * 2 );
 		pthread_mutex_lock( &this->audio_mutex );
-		while ( bytes > ( sizeof( this->audio_buffer) - this->audio_avail ) )
+		while ( this->running && bytes > ( sizeof( this->audio_buffer) - this->audio_avail ) )
 			pthread_cond_wait( &this->audio_cond, &this->audio_mutex );
-		if ( mlt_properties_get_double( properties, "_speed" ) == 1 )
-			memcpy( &this->audio_buffer[ this->audio_avail ], pcm, bytes );
-		else
-			memset( &this->audio_buffer[ this->audio_avail ], 0, bytes );
-		this->audio_avail += bytes;
+		if ( this->running )
+		{
+			if ( mlt_properties_get_double( properties, "_speed" ) == 1 )
+				memcpy( &this->audio_buffer[ this->audio_avail ], pcm, bytes );
+			else
+				memset( &this->audio_buffer[ this->audio_avail ], 0, bytes );
+			this->audio_avail += bytes;
+		}
 		pthread_cond_broadcast( &this->audio_cond );
 		pthread_mutex_unlock( &this->audio_mutex );
 	}
@@ -403,10 +411,11 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 			}
 		}
 	
-		if ( width != this->width || height != this->height )
+		if ( width != this->width || height != this->height || this->last_frame_aspect != mlt_frame_get_aspect_ratio( frame ) )
 		{
 			this->width = width;
 			this->height = height;
+			this->last_frame_aspect = mlt_frame_get_aspect_ratio( frame );
 			changed = 1;
 		}
 
@@ -433,7 +442,7 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 				else
 				{
 					// Use hardware scaler to normalise display aspect ratio
-					this->rect.w = frame_aspect / this_aspect * this->window_width + 0.5;
+					this->rect.w = frame_aspect / this_aspect * this->window_width;
 					this->rect.h = this->window_height;
 					if ( this->rect.w > this->window_width )
 					{
@@ -450,14 +459,14 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 				this->rect.h = this->window_height;
 			}
 			// Use hardware scaler to normalise sample aspect ratio
-			else if ( this->window_height * frame_aspect > this->window_width )
+			else if ( this->window_height * this->display_aspect > this->window_width )
 			{
 				this->rect.w = this->window_width;
-				this->rect.h = this->window_width / frame_aspect + 0.5;
+				this->rect.h = this->window_width / this->display_aspect + 0.5;
 			}
 			else
 			{
-				this->rect.w = this->window_height * frame_aspect + 0.5;
+				this->rect.w = this->window_height * this->display_aspect + 0.5;
 				this->rect.h = this->window_height;
 			}
 			
@@ -469,7 +478,9 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 				SDL_FreeYUVOverlay( this->sdl_overlay );
 
 			// open SDL window with video overlay, if possible
+			sdl_lock_display();
 			this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 0, this->sdl_flags );
+			sdl_unlock_display();
 
 			if ( this->sdl_screen != NULL )
 			{
@@ -493,6 +504,7 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 		if ( this->sdl_screen != NULL && this->sdl_overlay != NULL )
 		{
 			this->buffer = this->sdl_overlay->pixels[ 0 ];
+			sdl_lock_display();
 			if ( SDL_LockYUVOverlay( this->sdl_overlay ) >= 0 )
 			{
 				if ( image != NULL )
@@ -500,13 +512,92 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 				SDL_UnlockYUVOverlay( this->sdl_overlay );
 				SDL_DisplayYUVOverlay( this->sdl_overlay, &this->sdl_screen->clip_rect );
 			}
+			sdl_unlock_display();
 		}
-
 	}
 
 	return 0;
 }
 
+static void *video_thread( void *arg )
+{
+	// Identify the arg
+	consumer_sdl this = arg;
+
+	// Obtain time of thread start
+	struct timeval now;
+	int64_t start = 0;
+	int64_t elapsed = 0;
+	struct timespec tm;
+	mlt_frame next = NULL;
+	mlt_properties properties = NULL;
+	double speed = 0;
+
+	// Get real time flag
+	int real_time = mlt_properties_get_int( this->properties, "real_time" );
+
+	// Get the current time
+	gettimeofday( &now, NULL );
+
+	// Determine start time
+	start = ( int64_t )now.tv_sec * 1000000 + now.tv_usec;
+
+	while ( this->running )
+	{
+		// Pop the next frame
+		pthread_mutex_lock( &this->video_mutex );
+		while ( ( next = mlt_deque_pop_front( this->queue ) ) == NULL && this->running )
+			pthread_cond_wait( &this->video_cond, &this->video_mutex );
+		pthread_mutex_unlock( &this->video_mutex );
+
+		// Get the properties
+		properties =  mlt_frame_properties( next );
+
+		// Get the speed of the frame
+		speed = mlt_properties_get_double( properties, "_speed" );
+
+		// Get the current time
+		gettimeofday( &now, NULL );
+
+		// Get the elapsed time
+		elapsed = ( ( int64_t )now.tv_sec * 1000000 + now.tv_usec ) - start;
+
+		// See if we have to delay the display of the current frame
+		if ( mlt_properties_get_int( properties, "rendered" ) == 1 && this->running )
+		{
+			// Obtain the scheduled playout time
+			mlt_position scheduled = mlt_properties_get_position( properties, "playtime" );
+
+			// Determine the difference between the elapsed time and the scheduled playout time
+			mlt_position difference = scheduled - elapsed;
+
+			// Smooth playback a bit
+			if ( real_time && ( difference > 20000 && speed == 1.0 ) )
+			{
+				tm.tv_sec = difference / 1000000;
+				tm.tv_nsec = ( difference % 1000000 ) * 500;
+				nanosleep( &tm, NULL );
+			}
+
+			// Show current frame if not too old
+			if ( !real_time || ( difference > -10000 || speed != 1.0 || mlt_deque_count( this->queue ) < 2 ) )
+				consumer_play_video( this, next );
+
+			// If the queue is empty, recalculate start to allow build up again
+			if ( real_time && ( mlt_deque_count( this->queue ) == 0 && speed == 1.0 ) )
+			{
+				gettimeofday( &now, NULL );
+				start = ( ( int64_t )now.tv_sec * 1000000 + now.tv_usec ) - scheduled + 20000;
+			}
+		}
+
+		// This frame can now be closed
+		mlt_frame_close( next );
+	}
+
+	return NULL;
+}
+
 /** Threaded wrapper for pipe.
 */
 
@@ -518,19 +609,17 @@ static void *consumer_thread( void *arg )
 	// Get the consumer
 	mlt_consumer consumer = &this->parent;
 
+	// Video thread
+	pthread_t thread;
+
 	// internal intialization
 	int init_audio = 1;
-
-	// Obtain time of thread start
-	struct timeval now;
-	int64_t start = 0;
-	int64_t elapsed = 0;
-	int duration = 0;
-	int64_t playtime = 0;
-	struct timespec tm;
-	mlt_frame next = NULL;
+	int init_video = 1;
 	mlt_frame frame = NULL;
 	mlt_properties properties = NULL;
+	int duration = 0;
+	int64_t playtime = 0;
+	struct timespec tm = { 0, 100000 };
 
 	if ( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_NOPARACHUTE ) < 0 )
 	{
@@ -557,81 +646,42 @@ static void *consumer_thread( void *arg )
 			init_audio = consumer_play_audio( this, frame, init_audio, &duration );
 
 			// Determine the start time now
-			if ( this->playing && start == 0 )
+			if ( this->playing && init_video )
 			{
-				// Get the current time
-				gettimeofday( &now, NULL );
+				// Create the video thread
+				pthread_create( &thread, NULL, video_thread, this );
 
-				// Determine start time
-				start = ( int64_t )now.tv_sec * 1000000 + now.tv_usec;
+				// Video doesn't need to be initialised any more
+				init_video = 0;
 			}
 
 			// Set playtime for this frame
 			mlt_properties_set_position( properties, "playtime", playtime );
 
+			while ( this->running && mlt_deque_count( this->queue ) > 15 )
+				nanosleep( &tm, NULL );
+
 			// Push this frame to the back of the queue
+			pthread_mutex_lock( &this->video_mutex );
 			mlt_deque_push_back( this->queue, frame );
+			pthread_cond_broadcast( &this->video_cond );
+			pthread_mutex_unlock( &this->video_mutex );
 
 			// Calculate the next playtime
 			playtime += ( duration * 1000 );
 		}
+	}
 
-		// Pop the next frame
-		next = mlt_deque_pop_front( this->queue );
-
-		while ( next != NULL && this->playing )
-		{
-			// Get the properties
-			properties =  mlt_frame_properties( next );
-
-			// Get the current time
-			gettimeofday( &now, NULL );
-
-			// Get the elapsed time
-			elapsed = ( ( int64_t )now.tv_sec * 1000000 + now.tv_usec ) - start;
-
-			// See if we have to delay the display of the current frame
-			if ( mlt_properties_get_int( properties, "rendered" ) == 1 )
-			{
-				// Obtain the scheduled playout time
-				mlt_position scheduled = mlt_properties_get_position( properties, "playtime" );
-
-				// Determine the difference between the elapsed time and the scheduled playout time
-				mlt_position difference = scheduled - elapsed;
-
-				// If the frame is quite some way in the future, go get another
-				if ( difference >= 30000 && mlt_deque_count( this->queue ) < 10 )
-					break;
-
-				// Smooth playback a bit
-				if ( difference > 20000 && mlt_properties_get_double( properties, "_speed" ) == 1.0 )
-				{
-					tm.tv_sec = difference / 1000000;
-					tm.tv_nsec = ( difference % 1000000 ) * 1000;
-					nanosleep( &tm, NULL );
-				}
-
-				// Show current frame if not too old
-				if ( difference > -10000 || mlt_properties_get_double( properties, "_speed" ) != 1.0 )
-					consumer_play_video( this, next );
-				else
-					start = start - difference;
-			}
-
-			// This is an unrendered frame - just close it
-			mlt_frame_close( next );
-
-			// Pop the next frame
-			next = mlt_deque_pop_front( this->queue );
-		}
-
-		if ( next != NULL )
-			mlt_deque_push_front( this->queue, next );
+	// Kill the video thread
+	if ( init_video == 0 )
+	{
+		pthread_mutex_lock( &this->video_mutex );
+		pthread_cond_broadcast( &this->video_cond );
+		pthread_mutex_unlock( &this->video_mutex );
+		pthread_join( thread, NULL );
 	}
 
 	// internal cleanup
-	if ( init_audio == 0 )
-		SDL_AudioQuit( );
 	if ( this->sdl_overlay != NULL )
 		SDL_FreeYUVOverlay( this->sdl_overlay );
 	SDL_Quit( );
@@ -656,6 +706,9 @@ static int consumer_get_dimensions( int *width, int *height )
 	// Specify the SDL Version
 	SDL_VERSION( &wm.version );
 
+	// Lock the display
+	sdl_lock_display();
+
 	// Get the wm structure
 	if ( SDL_GetWMInfo( &wm ) == 1 )
 	{
@@ -681,6 +734,9 @@ static int consumer_get_dimensions( int *width, int *height )
 		}
 	}
 
+	// Unlock the display
+	sdl_lock_display();
+
 	return changed;
 }