2 * producer_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 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.
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.
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.
22 #include "consumer_libdv.h"
25 #include <framework/mlt_frame.h>
27 // System header files
36 // Forward references.
37 static int consumer_start( mlt_consumer
this );
38 static int consumer_stop( mlt_consumer
this );
39 static int consumer_is_stopped( mlt_consumer
this );
40 static int consumer_encode_video( mlt_consumer
this, uint8_t *dv_frame
, mlt_frame frame
);
41 static void consumer_encode_audio( mlt_consumer
this, uint8_t *dv_frame
, mlt_frame frame
);
42 static void consumer_output( mlt_consumer
this, uint8_t *dv_frame
, int size
, mlt_frame frame
);
43 static void *consumer_thread( void *arg
);
44 static void consumer_close( mlt_consumer
this );
46 /** Initialise the dv consumer.
49 mlt_consumer
consumer_libdv_init( char *arg
)
51 // Allocate the consumer
52 mlt_consumer
this = calloc( 1, sizeof( struct mlt_consumer_s
) );
54 // If memory allocated and initialises without error
55 if ( this != NULL
&& mlt_consumer_init( this, NULL
) == 0 )
57 // Get properties from the consumer
58 mlt_properties properties
= mlt_consumer_properties( this );
60 // Assign close callback
61 this->close
= consumer_close
;
63 // Interpret the constructor argument
64 if ( arg
== NULL
|| !strcmp( arg
, "PAL" ) )
65 mlt_properties_set_double( properties
, "fps", 25 );
67 mlt_properties_set_double( properties
, "fps", 29.97 );
69 // Set the encode and output handling method
70 mlt_properties_set_data( properties
, "video", consumer_encode_video
, 0, NULL
, NULL
);
71 mlt_properties_set_data( properties
, "audio", consumer_encode_audio
, 0, NULL
, NULL
);
72 mlt_properties_set_data( properties
, "output", consumer_output
, 0, NULL
, NULL
);
74 // Set up start/stop/terminated callbacks
75 this->start
= consumer_start
;
76 this->stop
= consumer_stop
;
77 this->is_stopped
= consumer_is_stopped
;
81 // Clean up in case of init failure
90 /** Start the consumer.
93 static int consumer_start( mlt_consumer
this )
96 mlt_properties properties
= mlt_consumer_properties( this );
98 // Check that we're not already running
99 if ( !mlt_properties_get_int( properties
, "running" ) )
102 pthread_t
*thread
= calloc( 1, sizeof( pthread_t
) );
104 // Assign the thread to properties
105 mlt_properties_set_data( properties
, "thread", thread
, sizeof( pthread_t
), free
, NULL
);
107 // Set the running state
108 mlt_properties_set_int( properties
, "running", 1 );
111 pthread_create( thread
, NULL
, consumer_thread
, this );
116 /** Stop the consumer.
119 static int consumer_stop( mlt_consumer
this )
121 // Get the properties
122 mlt_properties properties
= mlt_consumer_properties( this );
124 // Check that we're running
125 if ( mlt_properties_get_int( properties
, "running" ) )
128 pthread_t
*thread
= mlt_properties_get_data( properties
, "thread", NULL
);
131 mlt_properties_set_int( properties
, "running", 0 );
133 // Wait for termination
134 pthread_join( *thread
, NULL
);
140 /** Determine if the consumer is stopped.
143 static int consumer_is_stopped( mlt_consumer
this )
145 // Get the properties
146 mlt_properties properties
= mlt_consumer_properties( this );
147 return !mlt_properties_get_int( properties
, "running" );
150 /** Get or create a new libdv encoder.
153 static dv_encoder_t
*libdv_get_encoder( mlt_consumer
this, mlt_frame frame
)
155 // Get the properties of the consumer
156 mlt_properties this_properties
= mlt_consumer_properties( this );
158 // Obtain the dv_encoder
159 dv_encoder_t
*encoder
= mlt_properties_get_data( this_properties
, "dv_encoder", NULL
);
161 // Construct one if we don't have one
162 if ( encoder
== NULL
)
164 // Get the fps of the consumer (for now - should be from frame)
165 double fps
= mlt_properties_get_double( this_properties
, "fps" );
167 // Create the encoder
168 encoder
= dv_encoder_new( 0, 0, 0 );
171 encoder
->isPAL
= fps
== 25;
173 encoder
->vlc_encode_passes
= 1;
174 encoder
->static_qno
= 0;
175 encoder
->force_dct
= DV_DCT_AUTO
;
177 // Store the encoder on the properties
178 mlt_properties_set_data( this_properties
, "dv_encoder", encoder
, 0, ( mlt_destructor
)dv_encoder_free
, NULL
);
180 // Convenience for image dimensions
181 mlt_properties_set_int( this_properties
, "width", 720 );
182 mlt_properties_set_int( this_properties
, "height", fps
== 25 ?
576 : 480 );
185 // Return the encoder
190 /** The libdv encode video method.
193 static int consumer_encode_video( mlt_consumer
this, uint8_t *dv_frame
, mlt_frame frame
)
195 // Obtain the dv_encoder
196 dv_encoder_t
*encoder
= libdv_get_encoder( this, frame
);
198 // Get the properties of the consumer
199 mlt_properties this_properties
= mlt_consumer_properties( this );
201 // This will hold the size of the dv frame
204 // determine if this a test card
205 int is_test
= mlt_frame_is_test_card( frame
);
207 // If we get an encoder, then encode the image
208 if ( encoder
!= NULL
)
210 // Specify desired image properties
211 mlt_image_format fmt
= mlt_image_yuv422
;
212 int width
= mlt_properties_get_int( this_properties
, "width" );
213 int height
= mlt_properties_get_int( this_properties
, "height" );
214 uint8_t *image
= NULL
;
217 mlt_frame_get_image( frame
, &image
, &fmt
, &width
, &height
, 0 );
219 // Check that we get what we expected
220 if ( fmt
!= mlt_image_yuv422
||
221 width
!= mlt_properties_get_int( this_properties
, "width" ) ||
222 height
!= mlt_properties_get_int( this_properties
, "height" ) ||
225 // We should try to recover here
226 fprintf( stderr
, "We have a problem houston...\n" );
230 // Calculate the size of the dv frame
231 size
= height
== 576 ? frame_size_625_50
: frame_size_525_60
;
235 if ( size
!= 0 && !( mlt_properties_get_int( this_properties
, "was_test_card" ) && is_test
) )
238 dv_encode_full_frame( encoder
, &image
, e_dv_color_yuv
, dv_frame
);
240 // Note test card status
241 mlt_properties_set_int( this_properties
, "was_test_card", is_test
);
248 /** The libdv encode audio method.
251 static void consumer_encode_audio( mlt_consumer
this, uint8_t *dv_frame
, mlt_frame frame
)
253 // Get the properties of the consumer
254 mlt_properties this_properties
= mlt_consumer_properties( this );
256 // Obtain the dv_encoder
257 dv_encoder_t
*encoder
= libdv_get_encoder( this, frame
);
259 // Only continue if we have an encoder
260 if ( encoder
!= NULL
)
262 // Get the frame count
263 int count
= mlt_properties_get_int( this_properties
, "count" );
265 // Default audio args
266 mlt_audio_format fmt
= mlt_audio_pcm
;
268 int frequency
= 48000;
269 int samples
= mlt_sample_calculator( mlt_properties_get_double( this_properties
, "fps" ), frequency
, count
);
272 // Get the frame number
273 time_t start
= time( NULL
);
274 int height
= mlt_properties_get_int( this_properties
, "height" );
275 int is_pal
= height
== 576;
278 // Temporary - audio buffer allocation
279 int16_t *audio_buffers
[ 4 ];
282 for ( i
= 0 ; i
< 4; i
++ )
283 audio_buffers
[ i
] = malloc( 2 * DV_AUDIO_MAX_SAMPLES
);
286 mlt_frame_get_audio( frame
, &pcm
, &fmt
, &frequency
, &channels
, &samples
);
288 // Inform the encoder of the number of audio samples
289 encoder
->samples_this_frame
= samples
;
291 // Fill the audio buffers correctly
292 for ( i
= 0; i
< samples
; i
++ )
293 for ( j
= 0; j
< channels
; j
++ )
294 audio_buffers
[ j
][ i
] = *pcm
++;
296 // Encode audio on frame
297 dv_encode_full_audio( encoder
, audio_buffers
, channels
, frequency
, dv_frame
);
299 // Specify meta data on the frame
300 dv_encode_metadata( dv_frame
, is_pal
, is_wide
, &start
, count
);
301 dv_encode_timecode( dv_frame
, is_pal
, count
);
304 mlt_properties_set_int( this_properties
, "count", ++ count
);
306 // Temporary - free audio buffers
307 for ( i
= 0 ; i
< 4; i
++ )
308 free( audio_buffers
[ i
] );
312 /** The libdv output method.
315 static void consumer_output( mlt_consumer
this, uint8_t *dv_frame
, int size
, mlt_frame frame
)
317 fwrite( dv_frame
, size
, 1, stdout
);
321 /** The main thread - the argument is simply the consumer.
324 static void *consumer_thread( void *arg
)
326 // Map the argument to the object
327 mlt_consumer
this = arg
;
329 // Get the properties
330 mlt_properties properties
= mlt_consumer_properties( this );
332 // Get the handling methods
333 int ( *video
)( mlt_consumer
, uint8_t *, mlt_frame
) = mlt_properties_get_data( properties
, "video", NULL
);
334 int ( *audio
)( mlt_consumer
, uint8_t *, mlt_frame
) = mlt_properties_get_data( properties
, "audio", NULL
);
335 int ( *output
)( mlt_consumer
, uint8_t *, int, mlt_frame
) = mlt_properties_get_data( properties
, "output", NULL
);
337 // Allocate a single PAL frame for encoding
338 uint8_t *dv_frame
= malloc( frame_size_625_50
);
340 // Get the service associated to the consumer
341 mlt_service service
= mlt_consumer_service( this );
343 // Define a frame pointer
346 // Loop while running
347 while( mlt_properties_get_int( properties
, "running" ) )
350 if ( mlt_service_get_frame( service
, &frame
, 0 ) == 0 )
352 // Obtain the dv_encoder
353 if ( libdv_get_encoder( this, frame
) != NULL
)
356 int size
= video( this, dv_frame
, frame
);
360 audio( this, dv_frame
, frame
);
363 output( this, dv_frame
, size
, frame
);
366 mlt_frame_close( frame
);
370 fprintf( stderr
, "Unable to obtain dv encoder.\n" );
381 /** Close the consumer.
384 static void consumer_close( mlt_consumer
this )
387 mlt_consumer_stop( this );
390 mlt_consumer_close( this );