]> git.sesse.net Git - mlt/blob - src/framework/mlt_consumer.c
Transitions reworked (always_active capabilities); remaining audio handling switched...
[mlt] / src / framework / mlt_consumer.c
1 /*
2  * mlt_consumer.c -- abstraction for all consumer services
3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4  * Author: Charles Yates <charles.yates@pandora.be>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  */
20
21 #include "config.h"
22 #include "mlt_consumer.h"
23 #include "mlt_factory.h"
24 #include "mlt_producer.h"
25 #include "mlt_frame.h"
26 #include <stdio.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <sys/time.h>
30
31 static void mlt_consumer_frame_show( mlt_listener listener, mlt_properties owner, mlt_service this, void **args );
32
33 /** Public final methods
34 */
35
36 int mlt_consumer_init( mlt_consumer this, void *child )
37 {
38         int error = 0;
39         memset( this, 0, sizeof( struct mlt_consumer_s ) );
40         this->child = child;
41         error = mlt_service_init( &this->parent, this );
42         if ( error == 0 )
43         {
44                 // Get the properties from the service
45                 mlt_properties properties = MLT_SERVICE_PROPERTIES( &this->parent );
46
47                 // Get the normalisation preference
48                 char *normalisation = mlt_environment( "MLT_NORMALISATION" );
49
50                 // Deal with normalisation
51                 if ( normalisation == NULL || strcmp( normalisation, "NTSC" ) )
52                 {
53                         mlt_properties_set( properties, "normalisation", "PAL" );
54                         mlt_properties_set_double( properties, "fps", 25.0 );
55                         mlt_properties_set_int( properties, "width", 720 );
56                         mlt_properties_set_int( properties, "height", 576 );
57                         mlt_properties_set_int( properties, "progressive", 0 );
58                         mlt_properties_set_double( properties, "aspect_ratio", 59.0 / 54.0 );
59                 }
60                 else
61                 {
62                         mlt_properties_set( properties, "normalisation", "NTSC" );
63                         mlt_properties_set_double( properties, "fps", 30000.0 / 1001.0 );
64                         mlt_properties_set_int( properties, "width", 720 );
65                         mlt_properties_set_int( properties, "height", 480 );
66                         mlt_properties_set_int( properties, "progressive", 0 );
67                         mlt_properties_set_double( properties, "aspect_ratio", 10.0 / 11.0 );
68                 }
69
70                 // Default rescaler for all consumers
71                 mlt_properties_set( properties, "rescale", "bilinear" );
72
73                 // Default read ahead buffer size
74                 mlt_properties_set_int( properties, "buffer", 25 );
75
76                 // Default audio frequency and channels
77                 mlt_properties_set_int( properties, "frequency", 48000 );
78                 mlt_properties_set_int( properties, "channels", 2 );
79
80                 // Default of all consumers is real time
81                 mlt_properties_set_int( properties, "real_time", 1 );
82
83                 // Default to environment test card
84                 mlt_properties_set( properties, "test_card", mlt_environment( "MLT_TEST_CARD" ) );
85
86                 // Hmm - default all consumers to yuv422 :-/
87                 this->format = mlt_image_yuv422;
88
89                 mlt_events_register( properties, "consumer-frame-show", ( mlt_transmitter )mlt_consumer_frame_show );
90                 mlt_events_register( properties, "consumer-stopped", NULL );
91
92                 // Create the push mutex and condition
93                 pthread_mutex_init( &this->put_mutex, NULL );
94                 pthread_cond_init( &this->put_cond, NULL );
95
96         }
97         return error;
98 }
99
100 static void mlt_consumer_frame_show( mlt_listener listener, mlt_properties owner, mlt_service this, void **args )
101 {
102         if ( listener != NULL )
103                 listener( owner, this, ( mlt_frame )args[ 0 ] );
104 }
105
106 /** Create a new consumer.
107 */
108
109 mlt_consumer mlt_consumer_new( )
110 {
111         // Create the memory for the structure
112         mlt_consumer this = malloc( sizeof( struct mlt_consumer_s ) );
113
114         // Initialise it
115         if ( this != NULL )
116                 mlt_consumer_init( this, NULL );
117
118         // Return it
119         return this;
120 }
121
122 /** Get the parent service object.
123 */
124
125 mlt_service mlt_consumer_service( mlt_consumer this )
126 {
127         return this != NULL ? &this->parent : NULL;
128 }
129
130 /** Get the consumer properties.
131 */
132
133 mlt_properties mlt_consumer_properties( mlt_consumer this )
134 {
135         return this != NULL ? MLT_SERVICE_PROPERTIES( &this->parent ) : NULL;
136 }
137
138 /** Connect the consumer to the producer.
139 */
140
141 int mlt_consumer_connect( mlt_consumer this, mlt_service producer )
142 {
143         return mlt_service_connect_producer( &this->parent, producer, 0 );
144 }
145
146 /** Start the consumer.
147 */
148
149 int mlt_consumer_start( mlt_consumer this )
150 {
151         // Get the properies
152         mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
153
154         // Determine if there's a test card producer
155         char *test_card = mlt_properties_get( properties, "test_card" );
156
157         // Just to make sure nothing is hanging around...
158         mlt_frame_close( this->put );
159         this->put = NULL;
160
161         // Deal with it now.
162         if ( test_card != NULL )
163         {
164                 if ( mlt_properties_get_data( properties, "test_card_producer", NULL ) == NULL )
165                 {
166                         // Create a test card producer
167                         mlt_producer producer = mlt_factory_producer( NULL, test_card );
168
169                         // Do we have a producer
170                         if ( producer != NULL )
171                         {
172                                 // Test card should loop I guess...
173                                 mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer ), "eof", "pause" );
174                                 mlt_producer_set_speed( producer, 0 );
175                                 mlt_producer_set_in_and_out( producer, 0, 0 );
176
177                                 // Set the test card on the consumer
178                                 mlt_properties_set_data( properties, "test_card_producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
179                         }
180                 }
181         }
182         else
183         {
184                 // Allow the hash table to speed things up
185                 mlt_properties_set_data( properties, "test_card_producer", NULL, 0, NULL, NULL );
186         }
187
188         // Check and run an ante command
189         if ( mlt_properties_get( properties, "ante" ) )
190                 system( mlt_properties_get( properties, "ante" ) );
191
192         // Set the real_time preference
193         this->real_time = mlt_properties_get_int( properties, "real_time" );
194
195         // Start the service
196         if ( this->start != NULL )
197                 return this->start( this );
198
199         return 0;
200 }
201
202 /** An alternative method to feed frames into the consumer - only valid if
203         the consumer itself is not connected.
204 */
205
206 int mlt_consumer_put_frame( mlt_consumer this, mlt_frame frame )
207 {
208         int error = 1;
209
210         // Get the service assoicated to the consumer
211         mlt_service service = MLT_CONSUMER_SERVICE( this );
212
213         if ( mlt_service_producer( service ) == NULL )
214         {
215                 struct timeval now;
216                 struct timespec tm;
217                 pthread_mutex_lock( &this->put_mutex );
218                 while ( !mlt_consumer_is_stopped( this ) && this->put != NULL )
219                 {
220                         gettimeofday( &now, NULL );
221                         tm.tv_sec = now.tv_sec + 1;
222                         tm.tv_nsec = now.tv_usec * 1000;
223                         pthread_cond_timedwait( &this->put_cond, &this->put_mutex, &tm );
224                 }
225                 if ( !mlt_consumer_is_stopped( this ) && this->put == NULL )
226                         this->put = frame;
227                 else
228                         mlt_frame_close( frame );
229                 pthread_cond_broadcast( &this->put_cond );
230                 pthread_mutex_unlock( &this->put_mutex );
231         }
232         else
233         {
234                 mlt_frame_close( frame );
235         }
236
237         return error;
238 }
239
240 /** Protected method for consumer to get frames from connected service
241 */
242
243 mlt_frame mlt_consumer_get_frame( mlt_consumer this )
244 {
245         // Frame to return
246         mlt_frame frame = NULL;
247
248         // Get the service assoicated to the consumer
249         mlt_service service = MLT_CONSUMER_SERVICE( this );
250
251         // Get the consumer properties
252         mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
253
254         // Get the frame
255         if ( mlt_service_producer( service ) == NULL && mlt_properties_get_int( properties, "put_mode" ) )
256         {
257                 struct timeval now;
258                 struct timespec tm;
259                 pthread_mutex_lock( &this->put_mutex );
260                 while ( !mlt_consumer_is_stopped( this ) && this->put == NULL )
261                 {
262                         gettimeofday( &now, NULL );
263                         tm.tv_sec = now.tv_sec + 1;
264                         tm.tv_nsec = now.tv_usec * 1000;
265                         pthread_cond_timedwait( &this->put_cond, &this->put_mutex, &tm );
266                 }
267                 frame = this->put;
268                 this->put = NULL;
269                 pthread_cond_broadcast( &this->put_cond );
270                 pthread_mutex_unlock( &this->put_mutex );
271                 if ( frame != NULL )
272                         mlt_service_apply_filters( service, frame, 0 );
273         }
274         else if ( mlt_service_producer( service ) != NULL )
275         {
276                 mlt_service_get_frame( service, &frame, 0 );
277         }
278
279         if ( frame != NULL )
280         {
281                 // Get the frame properties
282                 mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
283
284                 // Get the test card producer
285                 mlt_producer test_card = mlt_properties_get_data( properties, "test_card_producer", NULL );
286
287                 // Attach the test frame producer to it.
288                 if ( test_card != NULL )
289                         mlt_properties_set_data( frame_properties, "test_card_producer", test_card, 0, NULL, NULL );
290
291                 // Attach the rescale property
292                 mlt_properties_set( frame_properties, "rescale.interp", mlt_properties_get( properties, "rescale" ) );
293
294                 // Aspect ratio and other jiggery pokery
295                 mlt_properties_set_double( frame_properties, "consumer_aspect_ratio", mlt_properties_get_double( properties, "aspect_ratio" ) );
296                 if ( mlt_properties_get_int( properties, "progressive" ) || mlt_properties_get_int( properties, "deinterlace" ) )
297                         mlt_properties_set_int( frame_properties, "consumer_deinterlace", 1 );
298         }
299
300         // Return the frame
301         return frame;
302 }
303
304 static inline long time_difference( struct timeval *time1 )
305 {
306         struct timeval time2;
307         time2.tv_sec = time1->tv_sec;
308         time2.tv_usec = time1->tv_usec;
309         gettimeofday( time1, NULL );
310         return time1->tv_sec * 1000000 + time1->tv_usec - time2.tv_sec * 1000000 - time2.tv_usec;
311 }
312
313 static void *consumer_read_ahead_thread( void *arg )
314 {
315         // The argument is the consumer
316         mlt_consumer this = arg;
317
318         // Get the properties of the consumer
319         mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
320
321         // Get the width and height
322         int width = mlt_properties_get_int( properties, "width" );
323         int height = mlt_properties_get_int( properties, "height" );
324
325         // See if video is turned off
326         int video_off = mlt_properties_get_int( properties, "video_off" );
327
328         // Get the audio settings
329         mlt_audio_format afmt = mlt_audio_pcm;
330         int counter = 0;
331         double fps = mlt_properties_get_double( properties, "fps" );
332         int channels = mlt_properties_get_int( properties, "channels" );
333         int frequency = mlt_properties_get_int( properties, "frequency" );
334         int samples = 0;
335         int16_t *pcm = NULL;
336
337         // See if audio is turned off
338         int audio_off = mlt_properties_get_int( properties, "audio_off" );
339
340         // Get the maximum size of the buffer
341         int buffer = mlt_properties_get_int( properties, "buffer" ) + 1;
342
343         // General frame variable
344         mlt_frame frame = NULL;
345         uint8_t *image = NULL;
346
347         // Time structures
348         struct timeval ante;
349
350         // Average time for get_frame and get_image
351         int count = 1;
352         int skipped = 0;
353         int64_t time_wait = 0;
354         int64_t time_frame = 0;
355         int64_t time_process = 0;
356         int skip_next = 0;
357
358         // Get the first frame
359         frame = mlt_consumer_get_frame( this );
360
361         // Get the image of the first frame
362         if ( !video_off )
363                 mlt_frame_get_image( frame, &image, &this->format, &width, &height, 0 );
364
365         if ( !audio_off )
366         {
367                 samples = mlt_sample_calculator( fps, frequency, counter++ );
368                 mlt_frame_get_audio( frame, &pcm, &afmt, &frequency, &channels, &samples );
369         }
370
371         mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 1 );
372
373         // Get the starting time (can ignore the times above)
374         gettimeofday( &ante, NULL );
375
376         // Continue to read ahead
377         while ( this->ahead )
378         {
379                 // Put the current frame into the queue
380                 pthread_mutex_lock( &this->mutex );
381                 while( this->ahead && mlt_deque_count( this->queue ) >= buffer )
382                         pthread_cond_wait( &this->cond, &this->mutex );
383                 mlt_deque_push_back( this->queue, frame );
384                 pthread_cond_broadcast( &this->cond );
385                 pthread_mutex_unlock( &this->mutex );
386
387                 time_wait += time_difference( &ante );
388
389                 // Get the next frame
390                 frame = mlt_consumer_get_frame( this );
391                 time_frame += time_difference( &ante );
392
393                 // If there's no frame, we're probably stopped...
394                 if ( frame == NULL )
395                         continue;
396
397                 // Increment the count
398                 count ++;
399
400                 // All non normal playback frames should be shown
401                 if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame ), "_speed" ) != 1 )
402                 {
403                         skipped = 0;
404                         time_frame = 0;
405                         time_process = 0;
406                         time_wait = 0;
407                         count = 1;
408                         skip_next = 0;
409                 }
410
411                 // Get the image
412                 if ( !skip_next )
413                 {
414                         // Get the image, mark as rendered and time it
415                         if ( !video_off )
416                                 mlt_frame_get_image( frame, &image, &this->format, &width, &height, 0 );
417                         mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 1 );
418                 }
419                 else
420                 {
421                         // Increment the number of sequentially skipped frames
422                         skipped ++;
423                         skip_next = 0;
424
425                         // If we've reached an unacceptable level, reset everything
426                         if ( skipped > 5 )
427                         {
428                                 skipped = 0;
429                                 time_frame = 0;
430                                 time_process = 0;
431                                 time_wait = 0;
432                                 count = 1;
433                         }
434                 }
435
436                 // Always process audio
437                 if ( !audio_off )
438                 {
439                         samples = mlt_sample_calculator( fps, frequency, counter++ );
440                         mlt_frame_get_audio( frame, &pcm, &afmt, &frequency, &channels, &samples );
441                 }
442
443                 // Increment the time take for this frame
444                 time_process += time_difference( &ante );
445
446                 // Determine if the next frame should be skipped
447                 if ( mlt_deque_count( this->queue ) <= 5 && ( ( time_wait + time_frame + time_process ) / count ) > 40000 )
448                         skip_next = 1;
449         }
450
451         // Remove the last frame
452         mlt_frame_close( frame );
453
454         return NULL;
455 }
456
457 static void consumer_read_ahead_start( mlt_consumer this )
458 {
459         pthread_attr_t thread_attributes;
460         
461         // We're running now
462         this->ahead = 1;
463
464         // Create the frame queue
465         this->queue = mlt_deque_init( );
466
467         // Create the mutex
468         pthread_mutex_init( &this->mutex, NULL );
469
470         // Create the condition
471         pthread_cond_init( &this->cond, NULL );
472
473         // Inherit the scheduling priority
474         pthread_attr_init( &thread_attributes );
475         pthread_attr_setinheritsched( &thread_attributes, PTHREAD_INHERIT_SCHED );
476         
477         // Create the read ahead 
478         pthread_create( &this->ahead_thread, &thread_attributes, consumer_read_ahead_thread, this );
479 }
480
481 static void consumer_read_ahead_stop( mlt_consumer this )
482 {
483         // Make sure we're running
484         if ( this->ahead )
485         {
486                 // Inform thread to stop
487                 this->ahead = 0;
488
489                 // Broadcast to the condition in case it's waiting
490                 pthread_mutex_lock( &this->mutex );
491                 pthread_cond_broadcast( &this->cond );
492                 pthread_mutex_unlock( &this->mutex );
493
494                 // Broadcast to the put condition in case it's waiting
495                 pthread_mutex_lock( &this->put_mutex );
496                 pthread_cond_broadcast( &this->put_cond );
497                 pthread_mutex_unlock( &this->put_mutex );
498
499                 // Join the thread
500                 pthread_join( this->ahead_thread, NULL );
501
502                 // Destroy the mutex
503                 pthread_mutex_destroy( &this->mutex );
504
505                 // Destroy the condition
506                 pthread_cond_destroy( &this->cond );
507
508                 // Wipe the queue
509                 while ( mlt_deque_count( this->queue ) )
510                         mlt_frame_close( mlt_deque_pop_back( this->queue ) );
511
512                 // Close the queue
513                 mlt_deque_close( this->queue );
514         }
515 }
516
517 void mlt_consumer_purge( mlt_consumer this )
518 {
519         if ( this->ahead )
520         {
521                 pthread_mutex_lock( &this->mutex );
522                 while ( mlt_deque_count( this->queue ) )
523                         mlt_frame_close( mlt_deque_pop_back( this->queue ) );
524                 pthread_cond_broadcast( &this->cond );
525                 pthread_mutex_unlock( &this->mutex );
526         }
527 }
528
529 mlt_frame mlt_consumer_rt_frame( mlt_consumer this )
530 {
531         // Frame to return
532         mlt_frame frame = NULL;
533
534         // Get the properties
535         mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
536
537         // Check if the user has requested real time or not
538         if ( this->real_time )
539         {
540                 int size = 1;
541
542                 // Is the read ahead running?
543                 if ( this->ahead == 0 )
544                 {
545                         int buffer = mlt_properties_get_int( properties, "buffer" );
546                         int prefill = mlt_properties_get_int( properties, "prefill" );
547                         consumer_read_ahead_start( this );
548                         if ( buffer > 1 )
549                                 size = prefill > 0 && prefill < buffer ? prefill : buffer;
550                 }
551         
552                 // Get frame from queue
553                 pthread_mutex_lock( &this->mutex );
554                 while( this->ahead && mlt_deque_count( this->queue ) < size )
555                         pthread_cond_wait( &this->cond, &this->mutex );
556                 frame = mlt_deque_pop_front( this->queue );
557                 pthread_cond_broadcast( &this->cond );
558                 pthread_mutex_unlock( &this->mutex );
559         }
560         else
561         {
562                 // Get the frame in non real time
563                 frame = mlt_consumer_get_frame( this );
564
565                 // This isn't true, but from the consumers perspective it is
566                 if ( frame != NULL )
567                         mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 1 );
568         }
569
570         return frame;
571 }
572
573 /** Callback for the implementation to indicate a stopped condition.
574 */
575
576 void mlt_consumer_stopped( mlt_consumer this )
577 {
578         mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( this ), "running", 0 );
579         mlt_events_fire( MLT_CONSUMER_PROPERTIES( this ), "consumer-stopped", NULL );
580 }
581
582 /** Stop the consumer.
583 */
584
585 int mlt_consumer_stop( mlt_consumer this )
586 {
587         // Get the properies
588         mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
589
590         // Stop the consumer
591         if ( this->stop != NULL )
592                 this->stop( this );
593
594         // Check if the user has requested real time or not and stop if necessary
595         if ( mlt_properties_get_int( properties, "real_time" ) )
596                 consumer_read_ahead_stop( this );
597
598         // Just in case...
599         pthread_mutex_lock( &this->put_mutex );
600         if ( this->put != NULL )
601         {
602                 mlt_frame_close( this->put );
603                 this->put = NULL;
604         }
605         pthread_cond_broadcast( &this->put_cond );
606         pthread_mutex_unlock( &this->put_mutex );
607
608         // Kill the test card
609         mlt_properties_set_data( properties, "test_card_producer", NULL, 0, NULL, NULL );
610
611         // Check and run a post command
612         if ( mlt_properties_get( properties, "post" ) )
613                 system( mlt_properties_get( properties, "post" ) );
614
615         return 0;
616 }
617
618 /** Determine if the consumer is stopped.
619 */
620
621 int mlt_consumer_is_stopped( mlt_consumer this )
622 {
623         // Check if the consumer is stopped
624         if ( this->is_stopped != NULL )
625                 return this->is_stopped( this );
626
627         return 0;
628 }
629
630 /** Close the consumer.
631 */
632
633 void mlt_consumer_close( mlt_consumer this )
634 {
635         if ( this != NULL && mlt_properties_dec_ref( MLT_CONSUMER_PROPERTIES( this ) ) <= 0 )
636         {
637                 // Get the childs close function
638                 void ( *consumer_close )( ) = this->close;
639
640                 if ( consumer_close )
641                 {
642                         // Just in case...
643                         mlt_consumer_stop( this );
644
645                         this->close = NULL;
646                         consumer_close( this );
647                 }
648                 else
649                 {
650
651                         // Make sure it only gets called once
652                         this->parent.close = NULL;
653
654                         // Destroy the push mutex and condition
655                         pthread_cond_broadcast( &this->put_cond );
656                         pthread_mutex_destroy( &this->put_mutex );
657                         pthread_cond_destroy( &this->put_cond );
658
659                         mlt_service_close( &this->parent );
660                 }
661         }
662 }