2 * consumer_libdv.c -- a DV encoder based on libdv
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library 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 GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <framework/mlt_consumer.h>
23 #include <framework/mlt_frame.h>
25 // System header files
34 #define FRAME_SIZE_525_60 10 * 150 * 80
35 #define FRAME_SIZE_625_50 12 * 150 * 80
37 // Forward references.
38 static int consumer_start( mlt_consumer this );
39 static int consumer_stop( mlt_consumer this );
40 static int consumer_is_stopped( mlt_consumer this );
41 static int consumer_encode_video( mlt_consumer this, uint8_t *dv_frame, mlt_frame frame );
42 static void consumer_encode_audio( mlt_consumer this, uint8_t *dv_frame, mlt_frame frame );
43 static void consumer_output( mlt_consumer this, uint8_t *dv_frame, int size, mlt_frame frame );
44 static void *consumer_thread( void *arg );
45 static void consumer_close( mlt_consumer this );
47 /** Initialise the dv consumer.
50 mlt_consumer consumer_libdv_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
52 // Allocate the consumer
53 mlt_consumer this = calloc( 1, sizeof( struct mlt_consumer_s ) );
55 // If memory allocated and initialises without error
56 if ( this != NULL && mlt_consumer_init( this, NULL, profile ) == 0 )
58 // Get properties from the consumer
59 mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
61 // Assign close callback
62 this->close = consumer_close;
64 // Interpret the argument
66 mlt_properties_set( properties, "target", arg );
68 // Set the encode and output handling method
69 mlt_properties_set_data( properties, "video", consumer_encode_video, 0, NULL, NULL );
70 mlt_properties_set_data( properties, "audio", consumer_encode_audio, 0, NULL, NULL );
71 mlt_properties_set_data( properties, "output", consumer_output, 0, NULL, NULL );
73 // Terminate at end of the stream by default
74 mlt_properties_set_int( properties, "terminate_on_pause", 1 );
76 // Set up start/stop/terminated callbacks
77 this->start = consumer_start;
78 this->stop = consumer_stop;
79 this->is_stopped = consumer_is_stopped;
83 // Clean up in case of init failure
92 /** Start the consumer.
95 static int consumer_start( mlt_consumer this )
98 mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
100 // Check that we're not already running
101 if ( !mlt_properties_get_int( properties, "running" ) )
104 pthread_t *thread = calloc( 1, sizeof( pthread_t ) );
106 // Assign the thread to properties
107 mlt_properties_set_data( properties, "thread", thread, sizeof( pthread_t ), free, NULL );
109 // Set the running state
110 mlt_properties_set_int( properties, "running", 1 );
113 pthread_create( thread, NULL, consumer_thread, this );
118 /** Stop the consumer.
121 static int consumer_stop( mlt_consumer this )
123 // Get the properties
124 mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
126 // Check that we're running
127 if ( mlt_properties_get_int( properties, "running" ) )
130 pthread_t *thread = mlt_properties_get_data( properties, "thread", NULL );
133 mlt_properties_set_int( properties, "running", 0 );
135 // Wait for termination
136 pthread_join( *thread, NULL );
138 // Close the output file :-) - this is obtuse - doesn't matter if output file
139 // exists or not - the destructor will kick in if it does
140 mlt_properties_set_data( properties, "output_file", NULL, 0, NULL, NULL );
146 /** Determine if the consumer is stopped.
149 static int consumer_is_stopped( mlt_consumer this )
151 // Get the properties
152 mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
153 return !mlt_properties_get_int( properties, "running" );
156 /** Get or create a new libdv encoder.
159 static dv_encoder_t *libdv_get_encoder( mlt_consumer this, mlt_frame frame )
161 // Get the properties of the consumer
162 mlt_properties this_properties = MLT_CONSUMER_PROPERTIES( this );
164 // Obtain the dv_encoder
165 dv_encoder_t *encoder = mlt_properties_get_data( this_properties, "dv_encoder", NULL );
167 // Construct one if we don't have one
168 if ( encoder == NULL )
170 // Get the fps of the consumer (for now - should be from frame)
171 double fps = mlt_properties_get_double( this_properties, "fps" );
173 // Create the encoder
174 encoder = dv_encoder_new( 0, 0, 0 );
177 encoder->isPAL = fps == 25;
179 encoder->vlc_encode_passes = 1;
180 encoder->static_qno = 0;
181 encoder->force_dct = DV_DCT_AUTO;
183 // Store the encoder on the properties
184 mlt_properties_set_data( this_properties, "dv_encoder", encoder, 0, ( mlt_destructor )dv_encoder_free, NULL );
187 // Return the encoder
192 /** The libdv encode video method.
195 static int consumer_encode_video( mlt_consumer this, uint8_t *dv_frame, mlt_frame frame )
197 // Obtain the dv_encoder
198 dv_encoder_t *encoder = libdv_get_encoder( this, frame );
200 // Get the properties of the consumer
201 mlt_properties this_properties = MLT_CONSUMER_PROPERTIES( this );
203 // This will hold the size of the dv frame
206 // Is the image rendered
207 int rendered = mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame ), "rendered" );
209 // Get width and height
210 int width = mlt_properties_get_int( this_properties, "width" );
211 int height = mlt_properties_get_int( this_properties, "height" );
213 // If we get an encoder, then encode the image
214 if ( rendered && encoder != NULL )
216 // Specify desired image properties
217 mlt_image_format fmt = mlt_image_yuv422;
218 uint8_t *image = NULL;
221 mlt_events_fire( this_properties, "consumer-frame-show", frame, NULL );
222 mlt_frame_get_image( frame, &image, &fmt, &width, &height, 0 );
224 // Check that we get what we expected
225 if ( fmt != mlt_image_yuv422 ||
226 width != mlt_properties_get_int( this_properties, "width" ) ||
227 height != mlt_properties_get_int( this_properties, "height" ) ||
230 // We should try to recover here
231 fprintf( stderr, "We have a problem houston...\n" );
235 // Calculate the size of the dv frame
236 size = height == 576 ? FRAME_SIZE_625_50 : FRAME_SIZE_525_60;
243 dv_encode_full_frame( encoder, &image, e_dv_color_yuv, dv_frame );
246 else if ( encoder != NULL )
248 // Calculate the size of the dv frame (duplicate of previous)
249 size = height == 576 ? FRAME_SIZE_625_50 : FRAME_SIZE_525_60;
255 /** The libdv encode audio method.
258 static void consumer_encode_audio( mlt_consumer this, uint8_t *dv_frame, mlt_frame frame )
260 // Get the properties of the consumer
261 mlt_properties this_properties = MLT_CONSUMER_PROPERTIES( this );
263 // Get the properties of the frame
264 mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
266 // Obtain the dv_encoder
267 dv_encoder_t *encoder = libdv_get_encoder( this, frame );
269 // Only continue if we have an encoder
270 if ( encoder != NULL )
272 // Get the frame count
273 int count = mlt_properties_get_int( this_properties, "count" );
275 // Default audio args
276 mlt_audio_format fmt = mlt_audio_pcm;
278 int frequency = mlt_properties_get_int( this_properties, "frequency" );
279 int samples = mlt_sample_calculator( mlt_properties_get_double( this_properties, "fps" ), frequency, count );
282 // Get the frame number
283 time_t start = time( NULL );
284 int height = mlt_properties_get_int( this_properties, "height" );
285 int is_pal = height == 576;
286 int is_wide = mlt_properties_get_int( this_properties, "display_aspect_num" ) == 16;
288 // Temporary - audio buffer allocation
289 int16_t *audio_buffers[ 4 ];
292 for ( i = 0 ; i < 4; i ++ )
293 audio_buffers[ i ] = mlt_pool_alloc( 2 * DV_AUDIO_MAX_SAMPLES );
296 mlt_frame_get_audio( frame, &pcm, &fmt, &frequency, &channels, &samples );
298 // Inform the encoder of the number of audio samples
299 encoder->samples_this_frame = samples;
301 // Fill the audio buffers correctly
302 if ( mlt_properties_get_double( frame_properties, "_speed" ) == 1.0 )
304 for ( i = 0; i < samples; i ++ )
305 for ( j = 0; j < channels; j++ )
306 audio_buffers[ j ][ i ] = *pcm ++;
310 for ( j = 0; j < channels; j++ )
311 memset( audio_buffers[ j ], 0, 2 * DV_AUDIO_MAX_SAMPLES );
314 // Encode audio on frame
315 dv_encode_full_audio( encoder, audio_buffers, channels, frequency, dv_frame );
317 // Specify meta data on the frame
318 dv_encode_metadata( dv_frame, is_pal, is_wide, &start, count );
319 dv_encode_timecode( dv_frame, is_pal, count );
322 mlt_properties_set_int( this_properties, "count", ++ count );
324 // Temporary - free audio buffers
325 for ( i = 0 ; i < 4; i ++ )
326 mlt_pool_release( audio_buffers[ i ] );
330 /** The libdv output method.
333 static void consumer_output( mlt_consumer this, uint8_t *dv_frame, int size, mlt_frame frame )
335 // Get the properties
336 mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
338 FILE *output = stdout;
339 char *target = mlt_properties_get( properties, "target" );
341 if ( target != NULL )
343 output = mlt_properties_get_data( properties, "output_file", NULL );
344 if ( output == NULL )
346 output = fopen( target, "w" );
347 if ( output != NULL )
348 mlt_properties_set_data( properties, "output_file", output, 0, ( mlt_destructor )fclose, 0 );
352 if ( output != NULL )
354 fwrite( dv_frame, size, 1, output );
359 fprintf( stderr, "Unable to open %s\n", target );
363 /** The main thread - the argument is simply the consumer.
366 static void *consumer_thread( void *arg )
368 // Map the argument to the object
369 mlt_consumer this = arg;
371 // Get the properties
372 mlt_properties properties = MLT_CONSUMER_PROPERTIES( this );
374 // Get the terminate_on_pause property
375 int top = mlt_properties_get_int( properties, "terminate_on_pause" );
377 // Get the handling methods
378 int ( *video )( mlt_consumer, uint8_t *, mlt_frame ) = mlt_properties_get_data( properties, "video", NULL );
379 int ( *audio )( mlt_consumer, uint8_t *, mlt_frame ) = mlt_properties_get_data( properties, "audio", NULL );
380 int ( *output )( mlt_consumer, uint8_t *, int, mlt_frame ) = mlt_properties_get_data( properties, "output", NULL );
382 // Allocate a single PAL frame for encoding
383 uint8_t *dv_frame = mlt_pool_alloc( FRAME_SIZE_625_50 );
386 mlt_frame frame = NULL;
389 // Loop while running
390 while( mlt_properties_get_int( properties, "running" ) )
393 frame = mlt_consumer_rt_frame( this );
395 // Check that we have a frame to work with
398 // Terminate on pause
399 if ( top && mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" ) == 0 )
401 mlt_frame_close( frame );
405 // Obtain the dv_encoder
406 if ( libdv_get_encoder( this, frame ) != NULL )
409 size = video( this, dv_frame, frame );
413 audio( this, dv_frame, frame );
416 output( this, dv_frame, size, frame );
419 mlt_frame_close( frame );
423 fprintf( stderr, "Unable to obtain dv encoder.\n" );
429 mlt_pool_release( dv_frame );
431 mlt_consumer_stopped( this );
436 /** Close the consumer.
439 static void consumer_close( mlt_consumer this )
442 mlt_consumer_stop( this );
445 mlt_consumer_close( this );