]> git.sesse.net Git - mlt/blob - src/framework/mlt_frame.c
+ Sigh - big endian issues on ppc based macs
[mlt] / src / framework / mlt_frame.c
1 /*
2  * mlt_frame.c -- interface for all frame classes
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_frame.h"
23 #include "mlt_producer.h"
24 #include "mlt_factory.h"
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <math.h>
29
30 /** Constructor for a frame.
31 */
32
33 mlt_frame mlt_frame_init( )
34 {
35         // Allocate a frame
36         mlt_frame this = calloc( sizeof( struct mlt_frame_s ), 1 );
37
38         if ( this != NULL )
39         {
40                 // Get the normalisation
41                 char *normalisation = mlt_environment( "MLT_NORMALISATION" );
42
43                 // Initialise the properties
44                 mlt_properties properties = &this->parent;
45                 mlt_properties_init( properties, this );
46
47                 // Set default properties on the frame
48                 mlt_properties_set_position( properties, "_position", 0.0 );
49                 mlt_properties_set_data( properties, "image", NULL, 0, NULL, NULL );
50
51                 if ( normalisation == NULL || strcmp( normalisation, "NTSC" ) )
52                 {
53                         mlt_properties_set_int( properties, "width", 720 );
54                         mlt_properties_set_int( properties, "height", 576 );
55                         mlt_properties_set_int( properties, "normalised_width", 720 );
56                         mlt_properties_set_int( properties, "normalised_height", 576 );
57                         mlt_properties_set_double( properties, "aspect_ratio", 59.0/54.0 );
58                 }
59                 else
60                 {
61                         mlt_properties_set_int( properties, "width", 720 );
62                         mlt_properties_set_int( properties, "height", 480 );
63                         mlt_properties_set_int( properties, "normalised_width", 720 );
64                         mlt_properties_set_int( properties, "normalised_height", 480 );
65                         mlt_properties_set_double( properties, "aspect_ratio", 10.0/11.0 );
66                 }
67
68                 mlt_properties_set_data( properties, "audio", NULL, 0, NULL, NULL );
69                 mlt_properties_set_data( properties, "alpha", NULL, 0, NULL, NULL );
70
71                 // Construct stacks for frames and methods
72                 this->stack_image = mlt_deque_init( );
73                 this->stack_audio = mlt_deque_init( );
74                 this->stack_service = mlt_deque_init( );
75         }
76
77         return this;
78 }
79
80 /** Fetch the frames properties.
81 */
82
83 mlt_properties mlt_frame_properties( mlt_frame this )
84 {
85         return this != NULL ? &this->parent : NULL;
86 }
87
88 /** Check if we have a way to derive something other than a test card.
89 */
90
91 int mlt_frame_is_test_card( mlt_frame this )
92 {
93         return mlt_deque_count( this->stack_image ) == 0 || mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "test_image" );
94 }
95
96 /** Check if we have a way to derive something other than test audio.
97 */
98
99 int mlt_frame_is_test_audio( mlt_frame this )
100 {
101         return mlt_deque_count( this->stack_audio ) == 0 || mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "test_audio" );
102 }
103
104 /** Get the aspect ratio of the frame.
105 */
106
107 double mlt_frame_get_aspect_ratio( mlt_frame this )
108 {
109         return mlt_properties_get_double( MLT_FRAME_PROPERTIES( this ), "aspect_ratio" );
110 }
111
112 /** Set the aspect ratio of the frame.
113 */
114
115 int mlt_frame_set_aspect_ratio( mlt_frame this, double value )
116 {
117         return mlt_properties_set_double( MLT_FRAME_PROPERTIES( this ), "aspect_ratio", value );
118 }
119
120 /** Get the position of this frame.
121 */
122
123 mlt_position mlt_frame_get_position( mlt_frame this )
124 {
125         int pos = mlt_properties_get_position( MLT_FRAME_PROPERTIES( this ), "_position" );
126         return pos < 0 ? 0 : pos;
127 }
128
129 /** Set the position of this frame.
130 */
131
132 int mlt_frame_set_position( mlt_frame this, mlt_position value )
133 {
134         return mlt_properties_set_position( MLT_FRAME_PROPERTIES( this ), "_position", value );
135 }
136
137 /** Stack a get_image callback.
138 */
139
140 int mlt_frame_push_get_image( mlt_frame this, mlt_get_image get_image )
141 {
142         return mlt_deque_push_back( this->stack_image, get_image );
143 }
144
145 /** Pop a get_image callback.
146 */
147
148 mlt_get_image mlt_frame_pop_get_image( mlt_frame this )
149 {
150         return mlt_deque_pop_back( this->stack_image );
151 }
152
153 /** Push a frame.
154 */
155
156 int mlt_frame_push_frame( mlt_frame this, mlt_frame that )
157 {
158         return mlt_deque_push_back( this->stack_image, that );
159 }
160
161 /** Pop a frame.
162 */
163
164 mlt_frame mlt_frame_pop_frame( mlt_frame this )
165 {
166         return mlt_deque_pop_back( this->stack_image );
167 }
168
169 /** Push a service.
170 */
171
172 int mlt_frame_push_service( mlt_frame this, void *that )
173 {
174         return mlt_deque_push_back( this->stack_image, that );
175 }
176
177 /** Pop a service.
178 */
179
180 void *mlt_frame_pop_service( mlt_frame this )
181 {
182         return mlt_deque_pop_back( this->stack_image );
183 }
184
185 /** Push a service.
186 */
187
188 int mlt_frame_push_service_int( mlt_frame this, int that )
189 {
190         return mlt_deque_push_back_int( this->stack_image, that );
191 }
192
193 /** Pop a service.
194 */
195
196 int mlt_frame_pop_service_int( mlt_frame this )
197 {
198         return mlt_deque_pop_back_int( this->stack_image );
199 }
200
201 /** Push an audio item on the stack.
202 */
203
204 int mlt_frame_push_audio( mlt_frame this, void *that )
205 {
206         return mlt_deque_push_back( this->stack_audio, that );
207 }
208
209 /** Pop an audio item from the stack
210 */
211
212 void *mlt_frame_pop_audio( mlt_frame this )
213 {
214         return mlt_deque_pop_back( this->stack_audio );
215 }
216
217 /** Return the service stack
218 */
219
220 mlt_deque mlt_frame_service_stack( mlt_frame this )
221 {
222         return this->stack_service;
223 }
224
225 /** Replace image stack with the information provided.
226
227         This might prove to be unreliable and restrictive - the idea is that a transition
228         which normally uses two images may decide to only use the b frame (ie: in the case
229         of a composite where the b frame completely obscures the a frame).
230
231         The image must be writable and the destructor for the image itself must be taken
232         care of on another frame and that frame cannot have a replace applied to it... 
233         Further it assumes that no alpha mask is in use.
234
235         For these reasons, it can only be used in a specific situation - when you have 
236         multiple tracks each with their own transition and these transitions are applied
237         in a strictly reversed order (ie: highest numbered [lowest track] is processed 
238         first).
239
240         More reliable approach - the cases should be detected during the process phase
241         and the upper tracks should simply not be invited to stack...
242 */
243
244 void mlt_frame_replace_image( mlt_frame this, uint8_t *image, mlt_image_format format, int width, int height )
245 {
246         // Remove all items from the stack
247         while( mlt_deque_pop_back( this->stack_image ) ) ;
248
249         // Update the information 
250         mlt_properties_set_data( MLT_FRAME_PROPERTIES( this ), "image", image, 0, NULL, NULL );
251         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "width", width );
252         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "height", height );
253         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "format", format );
254         this->get_alpha_mask = NULL;
255 }
256
257 /** Get the image associated to the frame.
258 */
259
260 int mlt_frame_get_image( mlt_frame this, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
261 {
262         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
263         mlt_get_image get_image = mlt_frame_pop_get_image( this );
264         mlt_producer producer = mlt_properties_get_data( properties, "test_card_producer", NULL );
265         int error = 0;
266
267         if ( get_image != NULL )
268         {
269                 mlt_properties_set_int( properties, "image_count", mlt_properties_get_int( properties, "image_count" ) - 1 );
270                 mlt_position position = mlt_frame_get_position( this );
271                 error = get_image( this, buffer, format, width, height, writable );
272                 mlt_properties_set_int( properties, "width", *width );
273                 mlt_properties_set_int( properties, "height", *height );
274                 mlt_properties_set_int( properties, "format", *format );
275                 mlt_frame_set_position( this, position );
276         }
277         else if ( mlt_properties_get_data( properties, "image", NULL ) != NULL )
278         {
279                 *format = mlt_properties_get_int( properties, "format" );
280                 *buffer = mlt_properties_get_data( properties, "image", NULL );
281                 *width = mlt_properties_get_int( properties, "width" );
282                 *height = mlt_properties_get_int( properties, "height" );
283         }
284         else if ( producer != NULL )
285         {
286                 mlt_frame test_frame = NULL;
287                 mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &test_frame, 0 );
288                 if ( test_frame != NULL )
289                 {
290                         mlt_properties test_properties = MLT_FRAME_PROPERTIES( test_frame );
291                         mlt_properties_set_double( test_properties, "consumer_aspect_ratio", mlt_properties_get_double( properties, "consumer_aspect_ratio" ) );
292                         mlt_properties_set( test_properties, "rescale.interp", mlt_properties_get( properties, "rescale.interp" ) );
293                         mlt_frame_get_image( test_frame, buffer, format, width, height, writable );
294                         mlt_properties_set_data( properties, "test_card_frame", test_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
295                         mlt_properties_set_data( properties, "image", *buffer, *width * *height * 2, NULL, NULL );
296                         mlt_properties_set_int( properties, "width", *width );
297                         mlt_properties_set_int( properties, "height", *height );
298                         mlt_properties_set_int( properties, "format", *format );
299                         mlt_properties_set_double( properties, "aspect_ratio", mlt_frame_get_aspect_ratio( test_frame ) );
300                 }
301                 else
302                 {
303                         mlt_properties_set_data( properties, "test_card_producer", NULL, 0, NULL, NULL );
304                         mlt_frame_get_image( this, buffer, format, width, height, writable );
305                 }
306         }
307         else
308         {
309                 register uint8_t *p;
310                 register uint8_t *q;
311                 int size = 0;
312
313                 *width = *width == 0 ? 720 : *width;
314                 *height = *height == 0 ? 576 : *height;
315                 size = *width * *height;
316
317                 mlt_properties_set_int( properties, "format", *format );
318                 mlt_properties_set_int( properties, "width", *width );
319                 mlt_properties_set_int( properties, "height", *height );
320                 mlt_properties_set_int( properties, "aspect_ratio", 0 );
321
322                 switch( *format )
323                 {
324                         case mlt_image_none:
325                                 size = 0;
326                                 *buffer = NULL;
327                                 break;
328                         case mlt_image_rgb24:
329                                 size *= 3;
330                                 size += *width * 3;
331                                 *buffer = mlt_pool_alloc( size );
332                                 if ( *buffer )
333                                         memset( *buffer, 255, size );
334                                 break;
335                         case mlt_image_rgb24a:
336                         case mlt_image_opengl:
337                                 size *= 4;
338                                 size += *width * 4;
339                                 *buffer = mlt_pool_alloc( size );
340                                 if ( *buffer )
341                                         memset( *buffer, 255, size );
342                                 break;
343                         case mlt_image_yuv422:
344                                 size *= 2;
345                                 size += *width * 2;
346                                 *buffer = mlt_pool_alloc( size );
347                                 p = *buffer;
348                                 q = p + size;
349                                 while ( p != NULL && p != q )
350                                 {
351                                         *p ++ = 235;
352                                         *p ++ = 128;
353                                 }
354                                 break;
355                         case mlt_image_yuv420p:
356                                 size = size * 3 / 2;
357                                 *buffer = mlt_pool_alloc( size );
358                                 if ( *buffer )
359                                         memset( *buffer, 255, size );
360                                 break;
361                 }
362
363                 mlt_properties_set_data( properties, "image", *buffer, size, ( mlt_destructor )mlt_pool_release, NULL );
364                 mlt_properties_set_int( properties, "test_image", 1 );
365         }
366
367         mlt_properties_set_int( properties, "scaled_width", *width );
368         mlt_properties_set_int( properties, "scaled_height", *height );
369
370         return error;
371 }
372
373 uint8_t *mlt_frame_get_alpha_mask( mlt_frame this )
374 {
375         uint8_t *alpha = NULL;
376         if ( this != NULL )
377         {
378                 if ( this->get_alpha_mask != NULL )
379                         alpha = this->get_alpha_mask( this );
380                 if ( alpha == NULL )
381                         alpha = mlt_properties_get_data( &this->parent, "alpha", NULL );
382                 if ( alpha == NULL )
383                 {
384                         int size = mlt_properties_get_int( &this->parent, "scaled_width" ) * mlt_properties_get_int( &this->parent, "scaled_height" );
385                         alpha = mlt_pool_alloc( size );
386                         memset( alpha, 255, size );
387                         mlt_properties_set_data( &this->parent, "alpha", alpha, size, mlt_pool_release, NULL );
388                 }
389         }
390         return alpha;
391 }
392
393 int mlt_frame_get_audio( mlt_frame this, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
394 {
395         mlt_get_audio get_audio = mlt_frame_pop_audio( this );
396         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
397         int hide = mlt_properties_get_int( properties, "test_audio" );
398
399         if ( hide == 0 && get_audio != NULL )
400         {
401                 mlt_position position = mlt_frame_get_position( this );
402                 get_audio( this, buffer, format, frequency, channels, samples );
403                 mlt_frame_set_position( this, position );
404         }
405         else if ( mlt_properties_get_data( properties, "audio", NULL ) )
406         {
407                 *buffer = mlt_properties_get_data( properties, "audio", NULL );
408                 *frequency = mlt_properties_get_int( properties, "audio_frequency" );
409                 *channels = mlt_properties_get_int( properties, "audio_channels" );
410                 *samples = mlt_properties_get_int( properties, "audio_samples" );
411         }
412         else
413         {
414                 int size = 0;
415                 *samples = *samples <= 0 ? 1920 : *samples;
416                 *channels = *channels <= 0 ? 2 : *channels;
417                 *frequency = *frequency <= 0 ? 48000 : *frequency;
418                 size = *samples * *channels * sizeof( int16_t );
419                 *buffer = mlt_pool_alloc( size );
420                 if ( *buffer != NULL )
421                         memset( *buffer, 0, size );
422                 mlt_properties_set_data( properties, "audio", *buffer, size, ( mlt_destructor )mlt_pool_release, NULL );
423                 mlt_properties_set_int( properties, "test_audio", 1 );
424         }
425
426         mlt_properties_set_int( properties, "audio_frequency", *frequency );
427         mlt_properties_set_int( properties, "audio_channels", *channels );
428         mlt_properties_set_int( properties, "audio_samples", *samples );
429
430         if ( mlt_properties_get( properties, "meta.volume" ) )
431         {
432                 double value = mlt_properties_get_double( properties, "meta.volume" );
433
434                 if ( value == 0.0 )
435                 {
436                         memset( *buffer, 0, *samples * *channels * 2 );
437                 }
438                 else if ( value != 1.0 )
439                 {
440                         int total = *samples * *channels;
441                         int16_t *p = *buffer;
442                         while ( total -- )
443                         {
444                                 *p = *p * value;
445                                 p ++;
446                         }
447                 }
448
449                 mlt_properties_set( properties, "meta.volume", NULL );
450         }
451
452         return 0;
453 }
454
455 unsigned char *mlt_frame_get_waveform( mlt_frame this, int w, int h )
456 {
457         int16_t *pcm = NULL;
458         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
459         mlt_audio_format format = mlt_audio_pcm;
460         int frequency = 32000; // lower frequency available?
461         int channels = 2;
462         double fps = mlt_properties_get_double( properties, "fps" );
463         int samples = mlt_sample_calculator( fps, frequency, mlt_frame_get_position( this ) );
464         
465         // Get the pcm data
466         mlt_frame_get_audio( this, &pcm, &format, &frequency, &channels, &samples );
467         
468         // Make an 8-bit buffer large enough to hold rendering
469         int size = w * h;
470         unsigned char *bitmap = ( unsigned char* )mlt_pool_alloc( size );
471         if ( bitmap != NULL )
472                 memset( bitmap, 0, size );
473         mlt_properties_set_data( properties, "waveform", bitmap, size, ( mlt_destructor )mlt_pool_release, NULL );
474         
475         // Render vertical lines
476         int16_t *ubound = pcm + samples * channels;
477         int skip = samples / w - 1;
478         int i, j, k;
479         
480         // Iterate sample stream and along x coordinate
481         for ( i = 0; i < w && pcm < ubound; i++ )
482         {
483                 // pcm data has channels interleaved
484                 for ( j = 0; j < channels; j++ )
485                 {
486                         // Determine sample's magnitude from 2s complement;
487                         int pcm_magnitude = *pcm < 0 ? ~(*pcm) + 1 : *pcm;
488                         // The height of a line is the ratio of the magnitude multiplied by 
489                         // half the vertical resolution
490                         int height = ( int )( ( double )( pcm_magnitude ) / 32768 * h / 2 );
491                         // Determine the starting y coordinate - left channel above center,
492                         // right channel below - currently assumes 2 channels
493                         int displacement = ( h / 2 ) - ( 1 - j ) * height;
494                         // Position buffer pointer using y coordinate, stride, and x coordinate
495                         unsigned char *p = &bitmap[ i + displacement * w ];
496                         
497                         // Draw vertical line
498                         for ( k = 0; k < height; k++ )
499                                 p[ w * k ] = 0xFF;
500                         
501                         pcm++;
502                 }
503                 pcm += skip * channels;
504         }
505
506         return bitmap;
507 }
508
509 mlt_producer mlt_frame_get_original_producer( mlt_frame this )
510 {
511         if ( this != NULL )
512                 return mlt_properties_get_data( MLT_FRAME_PROPERTIES( this ), "_producer", NULL );
513         return NULL;
514 }
515
516 void mlt_frame_close( mlt_frame this )
517 {
518         if ( this != NULL && mlt_properties_dec_ref( MLT_FRAME_PROPERTIES( this ) ) <= 0 )
519         {
520                 mlt_deque_close( this->stack_image );
521                 mlt_deque_close( this->stack_audio );
522                 while( mlt_deque_peek_back( this->stack_service ) )
523                         mlt_service_close( mlt_deque_pop_back( this->stack_service ) );
524                 mlt_deque_close( this->stack_service );
525                 mlt_properties_close( &this->parent );
526                 free( this );
527         }
528 }
529
530 /***** convenience functions *****/
531
532 int mlt_convert_rgb24a_to_yuv422( uint8_t *rgba, int width, int height, int stride, uint8_t *yuv, uint8_t *alpha )
533 {
534         int ret = 0;
535         register int y0, y1, u0, u1, v0, v1;
536         register int r, g, b;
537         register uint8_t *d = yuv;
538         register int i, j;
539
540         for ( i = 0; i < height; i++ )
541         {
542                 register uint8_t *s = rgba + ( stride * i );
543                 for ( j = 0; j < ( width / 2 ); j++ )
544                 {
545                         r = *s++;
546                         g = *s++;
547                         b = *s++;
548                         *alpha++ = *s++;
549                         RGB2YUV (r, g, b, y0, u0 , v0);
550                         r = *s++;
551                         g = *s++;
552                         b = *s++;
553                         *alpha++ = *s++;
554                         RGB2YUV (r, g, b, y1, u1 , v1);
555                         *d++ = y0;
556                         *d++ = (u0+u1) >> 1;
557                         *d++ = y1;
558                         *d++ = (v0+v1) >> 1;
559                 }
560                 if ( width % 2 )
561                 {
562                         r = *s++;
563                         g = *s++;
564                         b = *s++;
565                         *alpha++ = *s++;
566                         RGB2YUV (r, g, b, y0, u0 , v0);
567                         *d++ = y0;
568                         *d++ = u0;
569                 }
570         }
571         return ret;
572 }
573
574 int mlt_convert_rgb24_to_yuv422( uint8_t *rgb, int width, int height, int stride, uint8_t *yuv )
575 {
576         int ret = 0;
577         register int y0, y1, u0, u1, v0, v1;
578         register int r, g, b;
579         register uint8_t *d = yuv;
580         register int i, j;
581
582         for ( i = 0; i < height; i++ )
583         {
584                 register uint8_t *s = rgb + ( stride * i );
585                 for ( j = 0; j < ( width / 2 ); j++ )
586                 {
587                         r = *s++;
588                         g = *s++;
589                         b = *s++;
590                         RGB2YUV (r, g, b, y0, u0 , v0);
591                         r = *s++;
592                         g = *s++;
593                         b = *s++;
594                         RGB2YUV (r, g, b, y1, u1 , v1);
595                         *d++ = y0;
596                         *d++ = (u0+u1) >> 1;
597                         *d++ = y1;
598                         *d++ = (v0+v1) >> 1;
599                 }
600                 if ( width % 2 )
601                 {
602                         r = *s++;
603                         g = *s++;
604                         b = *s++;
605                         RGB2YUV (r, g, b, y0, u0 , v0);
606                         *d++ = y0;
607                         *d++ = u0;
608                 }
609         }
610         return ret;
611 }
612
613 int mlt_convert_bgr24a_to_yuv422( uint8_t *rgba, int width, int height, int stride, uint8_t *yuv, uint8_t *alpha )
614 {
615         int ret = 0;
616         register int y0, y1, u0, u1, v0, v1;
617         register int r, g, b;
618         register uint8_t *d = yuv;
619         register int i, j;
620
621         for ( i = 0; i < height; i++ )
622         {
623                 register uint8_t *s = rgba + ( stride * i );
624                 for ( j = 0; j < ( width / 2 ); j++ )
625                 {
626                         b = *s++;
627                         g = *s++;
628                         r = *s++;
629                         *alpha++ = *s++;
630                         RGB2YUV (r, g, b, y0, u0 , v0);
631                         b = *s++;
632                         g = *s++;
633                         r = *s++;
634                         *alpha++ = *s++;
635                         RGB2YUV (r, g, b, y1, u1 , v1);
636                         *d++ = y0;
637                         *d++ = (u0+u1) >> 1;
638                         *d++ = y1;
639                         *d++ = (v0+v1) >> 1;
640                 }
641                 if ( width % 2 )
642                 {
643                         b = *s++;
644                         g = *s++;
645                         r = *s++;
646                         *alpha++ = *s++;
647                         RGB2YUV (r, g, b, y0, u0 , v0);
648                         *d++ = y0;
649                         *d++ = u0;
650                 }
651         }
652         return ret;
653 }
654
655 int mlt_convert_bgr24_to_yuv422( uint8_t *rgb, int width, int height, int stride, uint8_t *yuv )
656 {
657         int ret = 0;
658         register int y0, y1, u0, u1, v0, v1;
659         register int r, g, b;
660         register uint8_t *d = yuv;
661         register int i, j;
662
663         for ( i = 0; i < height; i++ )
664         {
665                 register uint8_t *s = rgb + ( stride * i );
666                 for ( j = 0; j < ( width / 2 ); j++ )
667                 {
668                         b = *s++;
669                         g = *s++;
670                         r = *s++;
671                         RGB2YUV (r, g, b, y0, u0 , v0);
672                         b = *s++;
673                         g = *s++;
674                         r = *s++;
675                         RGB2YUV (r, g, b, y1, u1 , v1);
676                         *d++ = y0;
677                         *d++ = (u0+u1) >> 1;
678                         *d++ = y1;
679                         *d++ = (v0+v1) >> 1;
680                 }
681                 if ( width % 2 )
682                 {
683                         b = *s++;
684                         g = *s++;
685                         r = *s++;
686                         RGB2YUV (r, g, b, y0, u0 , v0);
687                         *d++ = y0;
688                         *d++ = u0;
689                 }
690         }
691         return ret;
692 }
693
694 int mlt_convert_argb_to_yuv422( uint8_t *rgba, int width, int height, int stride, uint8_t *yuv, uint8_t *alpha )
695 {
696         int ret = 0;
697         register int y0, y1, u0, u1, v0, v1;
698         register int r, g, b;
699         register uint8_t *d = yuv;
700         register int i, j;
701
702         for ( i = 0; i < height; i++ )
703         {
704                 register uint8_t *s = rgba + ( stride * i );
705                 for ( j = 0; j < ( width / 2 ); j++ )
706                 {
707                         *alpha++ = *s++;
708                         r = *s++;
709                         g = *s++;
710                         b = *s++;
711                         RGB2YUV (r, g, b, y0, u0 , v0);
712                         *alpha++ = *s++;
713                         r = *s++;
714                         g = *s++;
715                         b = *s++;
716                         RGB2YUV (r, g, b, y1, u1 , v1);
717                         *d++ = y0;
718                         *d++ = (u0+u1) >> 1;
719                         *d++ = y1;
720                         *d++ = (v0+v1) >> 1;
721                 }
722                 if ( width % 2 )
723                 {
724                         *alpha++ = *s++;
725                         r = *s++;
726                         g = *s++;
727                         b = *s++;
728                         RGB2YUV (r, g, b, y0, u0 , v0);
729                         *d++ = y0;
730                         *d++ = u0;
731                 }
732         }
733         return ret;
734 }
735
736 int mlt_convert_yuv420p_to_yuv422( uint8_t *yuv420p, int width, int height, int stride, uint8_t *yuv )
737 {
738         int ret = 0;
739         register int i, j;
740
741         int half = width >> 1;
742
743         uint8_t *Y = yuv420p;
744         uint8_t *U = Y + width * height;
745         uint8_t *V = U + width * height / 4;
746
747         register uint8_t *d = yuv;
748
749         for ( i = 0; i < height; i++ )
750         {
751                 register uint8_t *u = U + ( i / 2 ) * ( half );
752                 register uint8_t *v = V + ( i / 2 ) * ( half );
753
754                 for ( j = 0; j < half; j++ )
755                 {
756                         *d ++ = *Y ++;
757                         *d ++ = *u ++;
758                         *d ++ = *Y ++;
759                         *d ++ = *v ++;
760                 }
761         }
762         return ret;
763 }
764
765 uint8_t *mlt_resize_alpha( uint8_t *input, int owidth, int oheight, int iwidth, int iheight, uint8_t alpha_value )
766 {
767         uint8_t *output = NULL;
768
769         if ( input != NULL && ( iwidth != owidth || iheight != oheight ) && ( owidth > 6 && oheight > 6 ) )
770         {
771                 uint8_t *out_line;
772                 int offset_x = ( owidth - iwidth ) / 2;
773                 int offset_y = ( oheight - iheight ) / 2;
774                 int iused = iwidth;
775
776                 output = mlt_pool_alloc( owidth * oheight );
777                 memset( output, alpha_value, owidth * oheight );
778
779                 offset_x -= offset_x % 2;
780
781                 out_line = output + offset_y * owidth;
782                 out_line += offset_x;
783
784                 // Loop for the entirety of our output height.
785                 while ( iheight -- )
786                 {
787                         // We're in the input range for this row.
788                         memcpy( out_line, input, iused );
789
790                         // Move to next input line
791                         input += iwidth;
792
793                 // Move to next output line
794                 out_line += owidth;
795                 }
796         }
797
798         return output;
799 }
800
801 void mlt_resize_yuv422( uint8_t *output, int owidth, int oheight, uint8_t *input, int iwidth, int iheight )
802 {
803         // Calculate strides
804         int istride = iwidth * 2;
805         int ostride = owidth * 2;
806         int offset_x = ( owidth - iwidth );
807         int offset_y = ( oheight - iheight ) / 2;
808         uint8_t *in_line = input;
809         uint8_t *out_line;
810         int size = owidth * oheight;
811         uint8_t *p = output;
812
813         // Optimisation point
814         if ( output == NULL || input == NULL || ( owidth <= 6 || oheight <= 6 || iwidth <= 6 || oheight <= 6 ) )
815         {
816                 return;
817         }
818         else if ( iwidth == owidth && iheight == oheight )
819         {
820                 memcpy( output, input, iheight * istride );
821                 return;
822         }
823
824         while( size -- )
825         {
826                 *p ++ = 16;
827                 *p ++ = 128;
828         }
829
830         offset_x -= offset_x % 4;
831
832         out_line = output + offset_y * ostride;
833         out_line += offset_x;
834
835         // Loop for the entirety of our output height.
836         while ( iheight -- )
837         {
838                 // We're in the input range for this row.
839                 memcpy( out_line, in_line, iwidth * 2 );
840
841                 // Move to next input line
842                 in_line += istride;
843
844                 // Move to next output line
845                 out_line += ostride;
846         }
847 }
848
849 /** A resizing function for yuv422 frames - this does not rescale, but simply
850         resizes. It assumes yuv422 images available on the frame so use with care.
851 */
852
853 uint8_t *mlt_frame_resize_yuv422( mlt_frame this, int owidth, int oheight )
854 {
855         // Get properties
856         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
857
858         // Get the input image, width and height
859         uint8_t *input = mlt_properties_get_data( properties, "image", NULL );
860         uint8_t *alpha = mlt_frame_get_alpha_mask( this );
861
862         int iwidth = mlt_properties_get_int( properties, "width" );
863         int iheight = mlt_properties_get_int( properties, "height" );
864
865         // If width and height are correct, don't do anything
866         if ( iwidth != owidth || iheight != oheight )
867         {
868                 uint8_t alpha_value = mlt_properties_get_int( properties, "resize_alpha" );
869
870                 // Create the output image
871                 uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * 2 );
872
873                 // Call the generic resize
874                 mlt_resize_yuv422( output, owidth, oheight, input, iwidth, iheight );
875
876                 // Now update the frame
877                 mlt_properties_set_data( properties, "image", output, owidth * ( oheight + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
878                 mlt_properties_set_int( properties, "width", owidth );
879                 mlt_properties_set_int( properties, "height", oheight );
880
881                 // We should resize the alpha too
882                 alpha = mlt_resize_alpha( alpha, owidth, oheight, iwidth, iheight, alpha_value );
883                 if ( alpha != NULL )
884                 {
885                         mlt_properties_set_data( properties, "alpha", alpha, owidth * oheight, ( mlt_destructor )mlt_pool_release, NULL );
886                         this->get_alpha_mask = NULL;
887                 }
888
889                 // Return the output
890                 return output;
891         }
892         // No change, return input
893         return input;
894 }
895
896 /** A rescaling function for yuv422 frames - low quality, and provided for testing
897         only. It assumes yuv422 images available on the frame so use with care.
898 */
899
900 uint8_t *mlt_frame_rescale_yuv422( mlt_frame this, int owidth, int oheight )
901 {
902         // Get properties
903         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
904
905         // Get the input image, width and height
906         uint8_t *input = mlt_properties_get_data( properties, "image", NULL );
907         int iwidth = mlt_properties_get_int( properties, "width" );
908         int iheight = mlt_properties_get_int( properties, "height" );
909
910         // If width and height are correct, don't do anything
911         if ( iwidth != owidth || iheight != oheight )
912         {
913                 // Create the output image
914                 uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * 2 );
915
916                 // Calculate strides
917                 int istride = iwidth * 2;
918                 int ostride = owidth * 2;
919
920                 iwidth = iwidth - ( iwidth % 4 );
921
922                 // Derived coordinates
923                 int dy, dx;
924
925         // Calculate ranges
926         int out_x_range = owidth / 2;
927         int out_y_range = oheight / 2;
928         int in_x_range = iwidth / 2;
929         int in_y_range = iheight / 2;
930
931         // Output pointers
932         register uint8_t *out_line = output;
933         register uint8_t *out_ptr;
934
935         // Calculate a middle pointer
936         uint8_t *in_middle = input + istride * in_y_range + in_x_range * 2;
937         uint8_t *in_line;
938
939                 // Generate the affine transform scaling values
940                 register int scale_width = ( iwidth << 16 ) / owidth;
941                 register int scale_height = ( iheight << 16 ) / oheight;
942                 register int base = 0;
943
944                 int outer = out_x_range * scale_width;
945                 int bottom = out_y_range * scale_height;
946
947         // Loop for the entirety of our output height.
948         for ( dy = - bottom; dy < bottom; dy += scale_height )
949         {
950                 // Start at the beginning of the line
951                 out_ptr = out_line;
952         
953                 // Pointer to the middle of the input line
954                 in_line = in_middle + ( dy >> 16 ) * istride;
955
956                 // Loop for the entirety of our output row.
957                 for ( dx = - outer; dx < outer; dx += scale_width )
958                 {
959                                 base = dx >> 15;
960                                 base &= 0xfffffffe;
961                                 *out_ptr ++ = *( in_line + base );
962                                 base &= 0xfffffffc;
963                                 *out_ptr ++ = *( in_line + base + 1 );
964                                 dx += scale_width;
965                                 base = dx >> 15;
966                                 base &= 0xfffffffe;
967                                 *out_ptr ++ = *( in_line + base );
968                                 base &= 0xfffffffc;
969                                 *out_ptr ++ = *( in_line + base + 3 );
970                 }
971
972                 // Move to next output line
973                 out_line += ostride;
974         }
975
976                 // Now update the frame
977                 mlt_properties_set_data( properties, "image", output, owidth * ( oheight + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
978                 mlt_properties_set_int( properties, "width", owidth );
979                 mlt_properties_set_int( properties, "height", oheight );
980
981                 // Return the output
982                 return output;
983         }
984
985         // No change, return input
986         return input;
987 }
988
989 int mlt_frame_mix_audio( mlt_frame this, mlt_frame that, float weight_start, float weight_end, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
990 {
991         int ret = 0;
992         int16_t *src, *dest;
993         int frequency_src = *frequency, frequency_dest = *frequency;
994         int channels_src = *channels, channels_dest = *channels;
995         int samples_src = *samples, samples_dest = *samples;
996         int i, j;
997         double d = 0, s = 0;
998
999         mlt_frame_get_audio( that, &src, format, &frequency_src, &channels_src, &samples_src );
1000         mlt_frame_get_audio( this, &dest, format, &frequency_dest, &channels_dest, &samples_dest );
1001
1002         int silent = mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "silent_audio" );
1003         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "silent_audio", 0 );
1004         if ( silent )
1005                 memset( dest, 0, samples_dest * channels_dest * sizeof( int16_t ) );
1006
1007         silent = mlt_properties_get_int( MLT_FRAME_PROPERTIES( that ), "silent_audio" );
1008         mlt_properties_set_int( MLT_FRAME_PROPERTIES( that ), "silent_audio", 0 );
1009         if ( silent )
1010                 memset( src, 0, samples_src * channels_src * sizeof( int16_t ) );
1011
1012         if ( channels_src > 6 )
1013                 channels_src = 0;
1014         if ( channels_dest > 6 )
1015                 channels_dest = 0;
1016         if ( samples_src > 4000 )
1017                 samples_src = 0;
1018         if ( samples_dest > 4000 )
1019                 samples_dest = 0;
1020
1021         // determine number of samples to process
1022         *samples = samples_src < samples_dest ? samples_src : samples_dest;
1023         *channels = channels_src < channels_dest ? channels_src : channels_dest;
1024         *buffer = dest;
1025         *frequency = frequency_dest;
1026
1027         // Compute a smooth ramp over start to end
1028         float weight = weight_start;
1029         float weight_step = ( weight_end - weight_start ) / *samples;
1030
1031         if ( src == dest )
1032         {
1033                 *samples = samples_src;
1034                 *channels = channels_src;
1035                 *buffer = src;
1036                 *frequency = frequency_src;
1037                 return ret;
1038         }
1039
1040         // Mixdown
1041         for ( i = 0; i < *samples; i++ )
1042         {
1043                 for ( j = 0; j < *channels; j++ )
1044                 {
1045                         if ( j < channels_dest )
1046                                 d = (double) dest[ i * channels_dest + j ];
1047                         if ( j < channels_src )
1048                                 s = (double) src[ i * channels_src + j ];
1049                         dest[ i * channels_dest + j ] = s * weight + d * ( 1.0 - weight );
1050                 }
1051                 weight += weight_step;
1052         }
1053
1054         return ret;
1055 }
1056
1057 // Replacement for broken mlt_frame_audio_mix - this filter uses an inline low pass filter
1058 // to allow mixing without volume hacking
1059 int mlt_frame_combine_audio( mlt_frame this, mlt_frame that, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
1060 {
1061         int ret = 0;
1062         int16_t *src, *dest;
1063         int frequency_src = *frequency, frequency_dest = *frequency;
1064         int channels_src = *channels, channels_dest = *channels;
1065         int samples_src = *samples, samples_dest = *samples;
1066         int i, j;
1067         double vp[ 6 ];
1068         double b_weight = 1.0;
1069
1070         if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "meta.mixdown" ) )
1071                 b_weight = 1.0 - mlt_properties_get_double( MLT_FRAME_PROPERTIES( this ), "meta.volume" );
1072
1073         mlt_frame_get_audio( that, &src, format, &frequency_src, &channels_src, &samples_src );
1074         mlt_frame_get_audio( this, &dest, format, &frequency_dest, &channels_dest, &samples_dest );
1075
1076         int silent = mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "silent_audio" );
1077         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "silent_audio", 0 );
1078         if ( silent )
1079                 memset( dest, 0, samples_dest * channels_dest * sizeof( int16_t ) );
1080
1081         silent = mlt_properties_get_int( MLT_FRAME_PROPERTIES( that ), "silent_audio" );
1082         mlt_properties_set_int( MLT_FRAME_PROPERTIES( that ), "silent_audio", 0 );
1083         if ( silent )
1084                 memset( src, 0, samples_src * channels_src * sizeof( int16_t ) );
1085
1086         if ( src == dest )
1087         {
1088                 *samples = samples_src;
1089                 *channels = channels_src;
1090                 *buffer = src;
1091                 *frequency = frequency_src;
1092                 return ret;
1093         }
1094
1095         // determine number of samples to process
1096         *samples = samples_src < samples_dest ? samples_src : samples_dest;
1097         *channels = channels_src < channels_dest ? channels_src : channels_dest;
1098         *buffer = dest;
1099         *frequency = frequency_dest;
1100
1101         for ( j = 0; j < *channels; j++ )
1102                 vp[ j ] = ( double )dest[ j ];
1103
1104         double Fc = 0.5;
1105         double B = exp(-2.0 * M_PI * Fc);
1106         double A = 1.0 - B;
1107         double v;
1108         
1109         for ( i = 0; i < *samples; i++ )
1110         {
1111                 for ( j = 0; j < *channels; j++ )
1112                 {
1113                         v = ( double )( b_weight * dest[ i * channels_dest + j ] + src[ i * channels_src + j ] );
1114                         v = v < -32767 ? -32767 : v > 32768 ? 32768 : v;
1115                         vp[ j ] = dest[ i * channels_dest + j ] = ( int16_t )( v * A + vp[ j ] * B );
1116                 }
1117         }
1118
1119         return ret;
1120 }
1121
1122 /* Will this break when mlt_position is converted to double? -Zach */
1123 int mlt_sample_calculator( float fps, int frequency, int64_t position )
1124 {
1125         int samples = 0;
1126
1127         if ( ( int )( fps * 100 ) == 2997 )
1128         {
1129                 samples = frequency / 30;
1130
1131                 switch ( frequency )
1132                 {
1133                         case 48000:
1134                                 if ( position % 5 != 0 )
1135                                         samples += 2;
1136                                 break;
1137                         case 44100:
1138                                 if ( position % 300 == 0 )
1139                                         samples = 1471;
1140                                 else if ( position % 30 == 0 )
1141                                         samples = 1470;
1142                                 else if ( position % 2 == 0 )
1143                                         samples = 1472;
1144                                 else
1145                                         samples = 1471;
1146                                 break;
1147                         case 32000:
1148                                 if ( position % 30 == 0 )
1149                                         samples = 1068;
1150                                 else if ( position % 29 == 0 )
1151                                         samples = 1067;
1152                                 else if ( position % 4 == 2 )
1153                                         samples = 1067;
1154                                 else
1155                                         samples = 1068;
1156                                 break;
1157                         default:
1158                                 samples = 0;
1159                 }
1160         }
1161         else if ( fps != 0 )
1162         {
1163                 samples = frequency / fps;
1164         }
1165
1166         return samples;
1167 }
1168
1169 int64_t mlt_sample_calculator_to_now( float fps, int frequency, int64_t frame )
1170 {
1171         int64_t samples = 0;
1172
1173         // TODO: Correct rules for NTSC and drop the * 100 hack
1174         if ( ( int )( fps * 100 ) == 2997 )
1175         {
1176                 samples = ( ( double )( frame * frequency ) / 30 );
1177                 switch( frequency )
1178                 {
1179                         case 48000:
1180                                 samples += 2 * ( frame / 5 );
1181                                 break;
1182                         case 44100:
1183                                 samples += frame + ( frame / 2 ) - ( frame / 30 ) + ( frame / 300 );
1184                                 break;
1185                         case 32000:
1186                                 samples += ( 2 * frame ) - ( frame / 4 ) - ( frame / 29 );
1187                                 break;
1188                 }
1189         }
1190         else if ( fps != 0 )
1191         {
1192                 samples = ( ( frame * frequency ) / ( int )fps );
1193         }
1194
1195         return samples;
1196 }