]> git.sesse.net Git - mlt/blob - src/modules/gtk2/producer_pango.c
5b6c38044f22d957d8a7b09ef0349445b990b337
[mlt] / src / modules / gtk2 / producer_pango.c
1 /*
2  * producer_pango.c -- a pango-based titler
3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4  * Author: Dan Dennedy <dan@dennedy.org>
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include <framework/mlt_producer.h>
22 #include <framework/mlt_frame.h>
23 #include <framework/mlt_geometry.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <gdk-pixbuf/gdk-pixbuf.h>
27 #include <pango/pangoft2.h>
28 #include <freetype/freetype.h>
29 #include <iconv.h>
30 #include <pthread.h>
31 #include <ctype.h>
32
33 typedef struct producer_pango_s *producer_pango;
34
35 typedef enum
36 {
37         pango_align_left = 0,
38         pango_align_center,
39         pango_align_right
40 } pango_align;
41
42 static pthread_mutex_t pango_mutex = PTHREAD_MUTEX_INITIALIZER;
43
44 struct producer_pango_s
45 {
46         struct mlt_producer_s parent;
47         int   width;
48         int   height;
49         GdkPixbuf *pixbuf;
50         char *fgcolor;
51         char *bgcolor;
52         int   align;
53         int   pad;
54         char *markup;
55         char *text;
56         char *font;
57         int   weight;
58 };
59
60 // special color type used by internal pango routines
61 typedef struct
62 {
63         uint8_t r, g, b, a;
64 } rgba_color;
65
66 // Forward declarations
67 static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int index );
68 static void producer_close( mlt_producer parent );
69 static void pango_draw_background( GdkPixbuf *pixbuf, rgba_color bg );
70 static GdkPixbuf *pango_get_pixbuf( const char *markup, const char *text, const char *font,
71         rgba_color fg, rgba_color bg, int pad, int align, int weight, int size );
72
73 /** Return nonzero if the two strings are equal, ignoring case, up to
74     the first n characters.
75 */
76 int strncaseeq(const char *s1, const char *s2, size_t n)
77 {
78         for ( ; n > 0; n--)
79         {
80                 if (tolower(*s1++) != tolower(*s2++))
81                         return 0;
82         }
83         return 1;
84 }
85
86 /** Parse the alignment property.
87 */
88
89 static int alignment_parse( char* align )
90 {
91         int ret = pango_align_left;
92
93         if ( align == NULL );
94         else if ( isdigit( align[ 0 ] ) )
95                 ret = atoi( align );
96         else if ( align[ 0 ] == 'c' || align[ 0 ] == 'm' )
97                 ret = pango_align_center;
98         else if ( align[ 0 ] == 'r' )
99                 ret = pango_align_right;
100
101         return ret;
102 }
103
104 static PangoFT2FontMap *fontmap = NULL;
105
106 mlt_producer producer_pango_init( const char *filename )
107 {
108         producer_pango this = calloc( sizeof( struct producer_pango_s ), 1 );
109         if ( this != NULL && mlt_producer_init( &this->parent, this ) == 0 )
110         {
111                 mlt_producer producer = &this->parent;
112
113                 pthread_mutex_lock( &pango_mutex );
114                 if ( fontmap == NULL )
115                         fontmap = (PangoFT2FontMap*) pango_ft2_font_map_new();
116                 g_type_init();
117                 pthread_mutex_unlock( &pango_mutex );
118
119                 producer->get_frame = producer_get_frame;
120                 producer->close = ( mlt_destructor )producer_close;
121
122                 // Get the properties interface
123                 mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent );
124
125                 // Set the default properties
126                 mlt_properties_set( properties, "fgcolour", "0xffffffff" );
127                 mlt_properties_set( properties, "bgcolour", "0x00000000" );
128                 mlt_properties_set_int( properties, "align", pango_align_left );
129                 mlt_properties_set_int( properties, "pad", 0 );
130                 mlt_properties_set( properties, "text", "" );
131                 mlt_properties_set( properties, "font", "Sans 48" );
132                 mlt_properties_set( properties, "encoding", "UTF-8" );
133                 mlt_properties_set_int( properties, "weight", PANGO_WEIGHT_NORMAL );
134
135                 if ( filename == NULL || ( filename && ( !strcmp( filename, "" )
136                         // workaround for old kdenlive countdown generator
137                         || strstr( filename, "&lt;producer&gt;" ) ) ) )
138                 {
139                         mlt_properties_set( properties, "markup", "" );
140                 }
141                 else if ( filename[ 0 ] == '+' || strstr( filename, "/+" ) )
142                 {
143                         char *copy = strdup( filename + 1 );
144                         char *markup = copy;
145                         if ( strstr( markup, "/+" ) )
146                                 markup = strstr( markup, "/+" ) + 2;
147                         ( *strrchr( markup, '.' ) ) = '\0';
148                         while ( strchr( markup, '~' ) )
149                                 ( *strchr( markup, '~' ) ) = '\n';
150                         mlt_properties_set( properties, "resource", filename );
151                         mlt_properties_set( properties, "markup", markup );
152                         free( copy );
153                 }
154                 else if ( strstr( filename, ".mpl" ) ) 
155                 {
156                         int i = 0;
157                         mlt_properties contents = mlt_properties_load( filename );
158                         mlt_geometry key_frames = mlt_geometry_init( );
159                         struct mlt_geometry_item_s item;
160                         mlt_properties_set( properties, "resource", filename );
161                         mlt_properties_set_data( properties, "contents", contents, 0, ( mlt_destructor )mlt_properties_close, NULL );
162                         mlt_properties_set_data( properties, "key_frames", key_frames, 0, ( mlt_destructor )mlt_geometry_close, NULL );
163
164                         // Make sure we have at least one entry
165                         if ( mlt_properties_get( contents, "0" ) == NULL )
166                                 mlt_properties_set( contents, "0", "" );
167
168                         for ( i = 0; i < mlt_properties_count( contents ); i ++ )
169                         {
170                                 char *name = mlt_properties_get_name( contents, i );
171                                 char *value = mlt_properties_get_value( contents, i );
172                                 while ( value != NULL && strchr( value, '~' ) )
173                                         ( *strchr( value, '~' ) ) = '\n';
174                                 item.frame = atoi( name );
175                                 mlt_geometry_insert( key_frames, &item );
176                         }
177                 }
178                 else
179                 {
180                         FILE *f = fopen( filename, "r" );
181                         if ( f != NULL )
182                         {
183                                 char line[81];
184                                 char *markup = NULL;
185                                 size_t size = 0;
186                                 line[80] = '\0';
187                                 
188                                 while ( fgets( line, 80, f ) )
189                                 {
190                                         size += strlen( line ) + 1;
191                                         if ( markup )
192                                         {
193                                                 markup = realloc( markup, size );
194                                                 strcat( markup, line );
195                                         }
196                                         else
197                                         {
198                                                 markup = strdup( line );
199                                         }
200                                 }
201                                 fclose( f );
202
203                                 if ( markup[ strlen( markup ) - 1 ] == '\n' ) 
204                                         markup[ strlen( markup ) - 1 ] = '\0';
205
206                                 mlt_properties_set( properties, "resource", filename );
207                                 mlt_properties_set( properties, "markup", ( markup == NULL ? "" : markup ) );
208                                 free( markup );
209                         }
210                         else
211                         {
212                                 producer->close = NULL;
213                                 mlt_producer_close( producer );
214                                 producer = NULL;
215                                 free( this );
216                         }
217                 }
218
219                 return producer;
220         }
221         free( this );
222         return NULL;
223 }
224
225 static void set_string( char **string, const char *value, const char *fallback )
226 {
227         if ( value != NULL )
228         {
229                 free( *string );
230                 *string = strdup( value );
231         }
232         else if ( *string == NULL && fallback != NULL )
233         {
234                 *string = strdup( fallback );
235         }
236         else if ( *string != NULL && fallback == NULL )
237         {
238                 free( *string );
239                 *string = NULL;
240         }
241 }
242
243 rgba_color parse_color( char *color )
244 {
245         rgba_color result = { 0xff, 0xff, 0xff, 0xff };
246
247         if ( !strncmp( color, "0x", 2 ) )
248         {
249                 unsigned int temp = 0;
250                 sscanf( color + 2, "%x", &temp );
251                 result.r = ( temp >> 24 ) & 0xff;
252                 result.g = ( temp >> 16 ) & 0xff;
253                 result.b = ( temp >> 8 ) & 0xff;
254                 result.a = ( temp ) & 0xff;
255         }
256         else if ( !strcmp( color, "red" ) )
257         {
258                 result.r = 0xff;
259                 result.g = 0x00;
260                 result.b = 0x00;
261         }
262         else if ( !strcmp( color, "green" ) )
263         {
264                 result.r = 0x00;
265                 result.g = 0xff;
266                 result.b = 0x00;
267         }
268         else if ( !strcmp( color, "blue" ) )
269         {
270                 result.r = 0x00;
271                 result.g = 0x00;
272                 result.b = 0xff;
273         }
274         else
275         {
276                 unsigned int temp = 0;
277                 sscanf( color, "%d", &temp );
278                 result.r = ( temp >> 24 ) & 0xff;
279                 result.g = ( temp >> 16 ) & 0xff;
280                 result.b = ( temp >> 8 ) & 0xff;
281                 result.a = ( temp ) & 0xff;
282         }
283
284         return result;
285 }
286
287 /** Convert a string property to UTF-8
288 */
289 static int iconv_utf8( mlt_properties properties, const char *prop_name, const char* encoding )
290 {
291         char *text = mlt_properties_get( properties, prop_name );
292         int result = -1;
293         
294         iconv_t cd = iconv_open( "UTF-8", encoding );
295         if ( cd != ( iconv_t )-1 )
296         {
297                 char *inbuf_p = text;
298                 size_t inbuf_n = strlen( text );
299                 size_t outbuf_n = inbuf_n * 6;
300                 char *outbuf = mlt_pool_alloc( outbuf_n );
301                 char *outbuf_p = outbuf;
302                 
303                 memset( outbuf, 0, outbuf_n );
304
305                 if ( text != NULL && strcmp( text, "" ) && iconv( cd, &inbuf_p, &inbuf_n, &outbuf_p, &outbuf_n ) != -1 )
306                         mlt_properties_set( properties, prop_name, outbuf );
307                 else
308                         mlt_properties_set( properties, prop_name, "" );
309
310                 mlt_pool_release( outbuf );
311                 iconv_close( cd );
312                 result = 0;
313         }
314         return result;
315 }
316
317 static void refresh_image( mlt_frame frame, int width, int height )
318 {
319         // Pixbuf
320         GdkPixbuf *pixbuf = mlt_properties_get_data( MLT_FRAME_PROPERTIES( frame ), "pixbuf", NULL );
321
322         // Obtain properties of frame
323         mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
324
325         // Obtain the producer pango for this frame
326         producer_pango this = mlt_properties_get_data( properties, "producer_pango", NULL );
327
328         // Obtain the producer 
329         mlt_producer producer = &this->parent;
330
331         // Obtain the producer properties
332         mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
333
334         // Get producer properties
335         char *fg = mlt_properties_get( producer_props, "fgcolour" );
336         char *bg = mlt_properties_get( producer_props, "bgcolour" );
337         int align = alignment_parse( mlt_properties_get( producer_props, "align" ) );
338         int pad = mlt_properties_get_int( producer_props, "pad" );
339         char *markup = mlt_properties_get( producer_props, "markup" );
340         char *text = mlt_properties_get( producer_props, "text" );
341         char *font = mlt_properties_get( producer_props, "font" );
342         char *encoding = mlt_properties_get( producer_props, "encoding" );
343         int weight = mlt_properties_get_int( producer_props, "weight" );
344         int size = mlt_properties_get_int( producer_props, "size" );
345         int property_changed = 0;
346
347         if ( pixbuf == NULL )
348         {
349                 // Check for file support
350                 int position = mlt_properties_get_position( properties, "pango_position" );
351                 mlt_properties contents = mlt_properties_get_data( producer_props, "contents", NULL );
352                 mlt_geometry key_frames = mlt_properties_get_data( producer_props, "key_frames", NULL );
353                 struct mlt_geometry_item_s item;
354                 if ( contents != NULL )
355                 {
356                         char temp[ 20 ];
357                         mlt_geometry_prev_key( key_frames, &item, position );
358                         sprintf( temp, "%d", item.frame );
359                         markup = mlt_properties_get( contents, temp );
360                 }
361         
362                 // See if any properties changed
363                 property_changed = ( align != this->align );
364                 property_changed = property_changed || ( this->fgcolor == NULL || ( fg && strcmp( fg, this->fgcolor ) ) );
365                 property_changed = property_changed || ( this->bgcolor == NULL || ( bg && strcmp( bg, this->bgcolor ) ) );
366                 property_changed = property_changed || ( pad != this->pad );
367                 property_changed = property_changed || ( markup && this->markup && strcmp( markup, this->markup ) );
368                 property_changed = property_changed || ( text && this->text && strcmp( text, this->text ) );
369                 property_changed = property_changed || ( font && this->font && strcmp( font, this->font ) );
370                 property_changed = property_changed || ( weight != this->weight );
371
372                 // Save the properties for next comparison
373                 this->align = align;
374                 this->pad = pad;
375                 set_string( &this->fgcolor, fg, "0xffffffff" );
376                 set_string( &this->bgcolor, bg, "0x00000000" );
377                 set_string( &this->markup, markup, NULL );
378                 set_string( &this->text, text, NULL );
379                 set_string( &this->font, font, "Sans 48" );
380                 this->weight = weight;
381         }
382
383         if ( pixbuf == NULL && property_changed )
384         {
385                 rgba_color fgcolor = parse_color( this->fgcolor );
386                 rgba_color bgcolor = parse_color( this->bgcolor );
387
388                 if ( this->pixbuf )
389                         g_object_unref( this->pixbuf );
390                 this->pixbuf = NULL;
391
392                 // Convert from specified encoding to UTF-8
393                 if ( encoding != NULL && !strncaseeq( encoding, "utf-8", 5 ) && !strncaseeq( encoding, "utf8", 4 ) )
394                 {
395                         if ( markup != NULL && iconv_utf8( producer_props, "markup", encoding ) != -1 )
396                         {
397                                 markup = mlt_properties_get( producer_props, "markup" );
398                                 set_string( &this->markup, markup, NULL );
399                         }
400                         if ( text != NULL && iconv_utf8( producer_props, "text", encoding ) != -1 )
401                         {
402                                 text = mlt_properties_get( producer_props, "text" );
403                                 set_string( &this->text, text, NULL );
404                         }
405                 }
406                 
407                 // Render the title
408                 pixbuf = pango_get_pixbuf( markup, text, font, fgcolor, bgcolor, pad, align, weight, size );
409
410                 if ( pixbuf != NULL )
411                 {
412                         // Register this pixbuf for destruction and reuse
413                         mlt_properties_set_data( producer_props, "pixbuf", pixbuf, 0, ( mlt_destructor )g_object_unref, NULL );
414                         g_object_ref( pixbuf );
415                         mlt_properties_set_data( MLT_FRAME_PROPERTIES( frame ), "pixbuf", pixbuf, 0, ( mlt_destructor )g_object_unref, NULL );
416
417                         mlt_properties_set_int( producer_props, "real_width", gdk_pixbuf_get_width( pixbuf ) );
418                         mlt_properties_set_int( producer_props, "real_height", gdk_pixbuf_get_height( pixbuf ) );
419
420                         // Store the width/height of the pixbuf temporarily
421                         this->width = gdk_pixbuf_get_width( pixbuf );
422                         this->height = gdk_pixbuf_get_height( pixbuf );
423                 }
424         }
425         else if ( pixbuf == NULL && width > 0 && ( this->pixbuf == NULL || width != this->width || height != this->height ) )
426         {
427                 if ( this->pixbuf )
428                         g_object_unref( this->pixbuf );
429                 this->pixbuf = NULL;
430                 pixbuf = mlt_properties_get_data( producer_props, "pixbuf", NULL );
431         }
432
433         // If we have a pixbuf and a valid width
434         if ( pixbuf && width > 0 )
435         {
436                 char *interps = mlt_properties_get( properties, "rescale.interp" );
437                 int interp = GDK_INTERP_BILINEAR;
438
439                 if ( strcmp( interps, "nearest" ) == 0 )
440                         interp = GDK_INTERP_NEAREST;
441                 else if ( strcmp( interps, "tiles" ) == 0 )
442                         interp = GDK_INTERP_TILES;
443                 else if ( strcmp( interps, "hyper" ) == 0 || strcmp( interps, "bicubic" ) == 0 )
444                         interp = GDK_INTERP_HYPER;
445
446 // fprintf(stderr,"%s: scaling from %dx%d to %dx%d\n", __FILE__, this->width, this->height, width, height);
447
448                 // Note - the original pixbuf is already safe and ready for destruction
449                 this->pixbuf = gdk_pixbuf_scale_simple( pixbuf, width, height, interp );
450
451                 // Store width and height
452                 this->width = width;
453                 this->height = height;
454         }
455
456         // Set width/height
457         mlt_properties_set_int( properties, "width", this->width );
458         mlt_properties_set_int( properties, "height", this->height );
459         mlt_properties_set_int( properties, "real_width", mlt_properties_get_int( producer_props, "real_width" ) );
460         mlt_properties_set_int( properties, "real_height", mlt_properties_get_int( producer_props, "real_height" ) );
461 }
462
463 static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
464 {
465         int error = 0;
466         producer_pango this = ( producer_pango ) mlt_frame_pop_service( frame );
467
468         // Obtain properties of frame
469         mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
470
471         *width = mlt_properties_get_int( properties, "rescale_width" );
472         *height = mlt_properties_get_int( properties, "rescale_height" );
473
474         mlt_service_lock( MLT_PRODUCER_SERVICE( &this->parent ) );
475
476         // Refresh the image
477         pthread_mutex_lock( &pango_mutex );
478         refresh_image( frame, *width, *height );
479
480         // Get width and height
481         *width = this->width;
482         *height = this->height;
483
484         // Always clone here to allow 'animated' text
485         if ( this->pixbuf )
486         {
487                 // Clone the image
488                 int image_size = this->width * this->height * 4;
489                 *buffer = mlt_pool_alloc( image_size );
490                 memcpy( *buffer, gdk_pixbuf_get_pixels( this->pixbuf ), image_size );
491
492                 // Now update properties so we free the copy after
493                 mlt_frame_set_image( frame, *buffer, image_size, mlt_pool_release );
494                 *format = mlt_image_rgb24a;
495         }
496         else
497         {
498                 error = 1;
499         }
500
501         pthread_mutex_unlock( &pango_mutex );
502         mlt_service_unlock( MLT_PRODUCER_SERVICE( &this->parent ) );
503
504         return error;
505 }
506
507 static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
508 {
509         producer_pango this = producer->child;
510
511         // Generate a frame
512         *frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
513
514         // Obtain properties of frame and producer
515         mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
516
517         // Set the producer on the frame properties
518         mlt_properties_set_data( properties, "producer_pango", this, 0, NULL, NULL );
519
520         // Update timecode on the frame we're creating
521         mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
522         mlt_properties_set_position( properties, "pango_position", mlt_producer_frame( producer ) );
523
524         // Refresh the pango image
525         pthread_mutex_lock( &pango_mutex );
526         refresh_image( *frame, 0, 0 );
527         pthread_mutex_unlock( &pango_mutex );
528
529         // Set producer-specific frame properties
530         mlt_properties_set_int( properties, "progressive", 1 );
531         mlt_properties_set_double( properties, "aspect_ratio", 1 );
532
533         // Stack the get image callback
534         mlt_frame_push_service( *frame, this );
535         mlt_frame_push_get_image( *frame, producer_get_image );
536
537         // Calculate the next timecode
538         mlt_producer_prepare_next( producer );
539
540         return 0;
541 }
542
543 static void producer_close( mlt_producer parent )
544 {
545         producer_pango this = parent->child;
546         if ( this->pixbuf )
547                 g_object_unref( this->pixbuf );
548         free( this->fgcolor );
549         free( this->bgcolor );
550         free( this->markup );
551         free( this->text );
552         free( this->font );
553         parent->close = NULL;
554         mlt_producer_close( parent );
555         free( this );
556 }
557
558 static void pango_draw_background( GdkPixbuf *pixbuf, rgba_color bg )
559 {
560         int ww = gdk_pixbuf_get_width( pixbuf );
561         int hh = gdk_pixbuf_get_height( pixbuf );
562         uint8_t *p = gdk_pixbuf_get_pixels( pixbuf );
563         int i, j;
564
565         for ( j = 0; j < hh; j++ )
566         {
567                 for ( i = 0; i < ww; i++ )
568                 {
569                         *p++ = bg.r;
570                         *p++ = bg.g;
571                         *p++ = bg.b;
572                         *p++ = bg.a;
573                 }
574         }
575 }
576
577 static GdkPixbuf *pango_get_pixbuf( const char *markup, const char *text, const char *font, rgba_color fg, rgba_color bg, int pad, int align, int weight, int size )
578 {
579         PangoContext *context = pango_ft2_font_map_create_context( fontmap );
580         PangoLayout *layout = pango_layout_new( context );
581         int w, h, x;
582         int i, j;
583         GdkPixbuf *pixbuf = NULL;
584         FT_Bitmap bitmap;
585         uint8_t *src = NULL;
586         uint8_t* dest = NULL;
587         uint8_t *d, *s, a;
588         int stride;
589         PangoFontDescription *desc = pango_font_description_from_string( font );
590
591         pango_ft2_font_map_set_resolution( fontmap, 72, 72 );
592         pango_layout_set_width( layout, -1 ); // set wrapping constraints
593         pango_font_description_set_weight( desc, ( PangoWeight ) weight  );
594         if ( size != 0 )
595                 pango_font_description_set_absolute_size( desc, PANGO_SCALE * size );
596         pango_layout_set_font_description( layout, desc );
597 //      pango_layout_set_spacing( layout, space );
598         pango_layout_set_alignment( layout, ( PangoAlignment ) align  );
599         if ( markup != NULL && strcmp( markup, "" ) != 0 )
600         {
601                 pango_layout_set_markup( layout, markup, strlen( markup ) );
602         }
603         else if ( text != NULL && strcmp( text, "" ) != 0 )
604         {
605                 // Replace all ~'s with a line feed (silly convention, but handy)
606                 char *copy = strdup( text );
607                 while ( strchr( copy, '~' ) )
608                         ( *strchr( copy, '~' ) ) = '\n';
609                 pango_layout_set_text( layout, copy, strlen( copy ) );
610                 free( copy );
611         }
612         else
613         {
614                 // Pango doesn't like empty strings
615                 pango_layout_set_text( layout, "  ", 2 );
616         }
617         pango_layout_get_pixel_size( layout, &w, &h );
618
619         // Interpret size property as an absolute pixel height and compensate for
620         // freetype's "interpretation" of our absolute size request. This gives
621         // precise control over compositing and better quality by reducing scaling
622         // artifacts with composite geometries that constrain the dimensions.
623         // If you do not want this, then put the size in the font property or in
624         // the pango markup.
625         if ( size != 0 )
626         {
627                 pango_font_description_set_absolute_size( desc, PANGO_SCALE * size * size/h );
628                 pango_layout_set_font_description( layout, desc );
629                 pango_layout_get_pixel_size( layout, &w, &h );
630         }
631
632         if ( pad == 0 )
633             pad = 1;
634
635         pixbuf = gdk_pixbuf_new( GDK_COLORSPACE_RGB, TRUE /* has alpha */, 8, w + 2 * pad, h + 2 * pad );
636         pango_draw_background( pixbuf, bg );
637
638         stride = gdk_pixbuf_get_rowstride( pixbuf );
639
640         bitmap.width     = w;
641         bitmap.pitch     = 32 * ( ( w + 31 ) / 31 );
642         bitmap.rows      = h;
643         bitmap.buffer    = mlt_pool_alloc( h * bitmap.pitch );
644         bitmap.num_grays = 256;
645         bitmap.pixel_mode = ft_pixel_mode_grays;
646
647         memset( bitmap.buffer, 0, h * bitmap.pitch );
648
649         pango_ft2_render_layout( &bitmap, layout, 0, 0 );
650
651         src = bitmap.buffer;
652         x = ( gdk_pixbuf_get_width( pixbuf ) - w - 2 * pad ) * align / 2 + pad;
653         dest = gdk_pixbuf_get_pixels( pixbuf ) + 4 * x + pad * stride;
654         j = h;
655
656         while( j -- )
657         {
658                 d = dest;
659                 s = src;
660                 i = w;
661                 while( i -- )
662                 {
663                         a = *s ++;
664                         *d++ = ( a * fg.r + ( 255 - a ) * bg.r ) >> 8;
665                         *d++ = ( a * fg.g + ( 255 - a ) * bg.g ) >> 8;
666                         *d++ = ( a * fg.b + ( 255 - a ) * bg.b ) >> 8;
667                         *d++ = ( a * fg.a + ( 255 - a ) * bg.a ) >> 8;
668                 }
669                 dest += stride;
670                 src += bitmap.pitch;
671         }
672         mlt_pool_release( bitmap.buffer );
673         pango_font_description_free( desc );
674         g_object_unref( layout );
675         g_object_unref( context );
676
677         return pixbuf;
678 }