开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
quartztext.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：33k
源码类别：

midi

开发平台：

Unix_Linux

quartztext.c：源码内容
  1. /*****************************************************************************
  2.  * quartztext.c : Put text on the video, using Mac OS X Quartz Engine
  3.  *****************************************************************************
  4.  * Copyright (C) 2007, 2009 the VideoLAN team
  5.  * $Id: 9f731382ac40010541e73de19c3892af8ae070d5 $
  6.  *
  7.  * Authors: Bernie Purcell <bitmap@videolan.org>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. #ifdef __x86_64__
  26. #warning "No text renderer build! Quartztext isn't 64bit compatible!"
  27. #warning "RE-WRITE ME!"
  29. #else
  31. //////////////////////////////////////////////////////////////////////////////
  32. // Preamble
  33. //////////////////////////////////////////////////////////////////////////////
  35. #ifdef HAVE_CONFIG_H
  36. # include "config.h"
  37. #endif
  39. #include <vlc_common.h>
  40. #include <vlc_plugin.h>
  41. #include <vlc_vout.h>
  42. #include <vlc_osd.h>
  43. #include <vlc_block.h>
  44. #include <vlc_filter.h>
  45. #include <vlc_stream.h>
  46. #include <vlc_xml.h>
  47. #include <vlc_input.h>
  48. #include <vlc_strings.h>
  50. #include <math.h>
  52. #include <Carbon/Carbon.h>
  54. #define DEFAULT_FONT           "Arial Black"
  55. #define DEFAULT_FONT_COLOR     0xffffff
  56. #define DEFAULT_REL_FONT_SIZE  16
  58. #define VERTICAL_MARGIN 3
  59. #define HORIZONTAL_MARGIN 10
  61. //////////////////////////////////////////////////////////////////////////////
  62. // Local prototypes
  63. //////////////////////////////////////////////////////////////////////////////
  64. static int  Create ( vlc_object_t * );
  65. static void Destroy( vlc_object_t * );
  67. static int LoadFontsFromAttachments( filter_t *p_filter );
  69. static int RenderText( filter_t *, subpicture_region_t *,
  70.                        subpicture_region_t * );
  71. static int RenderHtml( filter_t *, subpicture_region_t *,
  72.                        subpicture_region_t * );
  74. static int GetFontSize( filter_t *p_filter );
  75. static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
  76.                        UniChar *psz_utfString, uint32_t i_text_len,
  77.                        uint32_t i_runs, uint32_t *pi_run_lengths,
  78.                        ATSUStyle *pp_styles );
  79. static ATSUStyle CreateStyle( char *psz_fontname, int i_font_size,
  80.                               uint32_t i_font_color,
  81.                               bool b_bold, bool b_italic,
  82.                               bool b_uline );
  83. //////////////////////////////////////////////////////////////////////////////
  84. // Module descriptor
  85. //////////////////////////////////////////////////////////////////////////////
  87. // The preferred way to set font style information is for it to come from the
  88. // subtitle file, and for it to be rendered with RenderHtml instead of
  89. // RenderText. This module, unlike Freetype, doesn't provide any options to
  90. // override the fallback font selection used when this style information is
  91. // absent.
  92. #define FONT_TEXT N_("Font")
  93. #define FONT_LONGTEXT N_("Name for the font you want to use")
  94. #define FONTSIZER_TEXT N_("Relative font size")
  95. #define FONTSIZER_LONGTEXT N_("This is the relative default size of the " 
  96.     "fonts that will be rendered on the video. If absolute font size is set, "
  97.     "relative size will be overriden." )
  98. #define COLOR_TEXT N_("Text default color")
  99. #define COLOR_LONGTEXT N_("The color of the text that will be rendered on "
  100.     "the video. This must be an hexadecimal (like HTML colors). The first two "
  101.     "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"
  102.     " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
  104. static const int pi_color_values[] = {
  105.   0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
  106.   0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
  107.   0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
  109. static const char *const ppsz_color_descriptions[] = {
  110.   N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
  111.   N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
  112.   N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
  114. static const int pi_sizes[] = { 20, 18, 16, 12, 6 };
  115. static const char *const ppsz_sizes_text[] = {
  116.     N_("Smaller"), N_("Small"), N_("Normal"), N_("Large"), N_("Larger") };
  118. vlc_module_begin ()
  119.     set_shortname( N_("Mac Text renderer"))
  120.     set_description( N_("Quartz font renderer") )
  121.     set_category( CAT_VIDEO )
  122.     set_subcategory( SUBCAT_VIDEO_SUBPIC )
  124.     add_string( "quartztext-font", DEFAULT_FONT, NULL, FONT_TEXT, FONT_LONGTEXT,
  125.               false )
  126.     add_integer( "quartztext-rel-fontsize", DEFAULT_REL_FONT_SIZE, NULL, FONTSIZER_TEXT,
  127.                  FONTSIZER_LONGTEXT, false )
  128.         change_integer_list( pi_sizes, ppsz_sizes_text, NULL );
  129.     add_integer( "quartztext-color", 0x00FFFFFF, NULL, COLOR_TEXT,
  130.                  COLOR_LONGTEXT, false )
  131.         change_integer_list( pi_color_values, ppsz_color_descriptions, NULL );
  132.     set_capability( "text renderer", 150 )
  133.     add_shortcut( "text" )
  134.     set_callbacks( Create, Destroy )
  135. vlc_module_end ()
  137. typedef struct offscreen_bitmap_t offscreen_bitmap_t;
  138. struct offscreen_bitmap_t
  139. {
  140.     uint8_t       *p_data;
  141.     int            i_bitsPerChannel;
  142.     int            i_bitsPerPixel;
  143.     int            i_bytesPerPixel;
  144.     int            i_bytesPerRow;
  145. };
  147. //////////////////////////////////////////////////////////////////////////////
  148. // filter_sys_t: quartztext local data
  149. //////////////////////////////////////////////////////////////////////////////
  150. // This structure is part of the video output thread descriptor.
  151. // It describes the freetype specific properties of an output thread.
  152. //////////////////////////////////////////////////////////////////////////////
  153. struct filter_sys_t
  154. {
  155.     char          *psz_font_name;
  156.     uint8_t        i_font_opacity;
  157.     int            i_font_color;
  158.     int            i_font_size;
  160.     ATSFontContainerRef    *p_fonts;
  161.     int                     i_fonts;
  162. };
  164. #define UCHAR UniChar
  165. #define TR_DEFAULT_FONT p_sys->psz_font_name
  166. #define TR_FONT_STYLE_PTR ATSUStyle
  168. #include "text_renderer.h"
  170. //////////////////////////////////////////////////////////////////////////////
  171. // Create: allocates osd-text video thread output method
  172. //////////////////////////////////////////////////////////////////////////////
  173. // This function allocates and initializes a Clone vout method.
  174. //////////////////////////////////////////////////////////////////////////////
  175. static int Create( vlc_object_t *p_this )
  176. {
  177.     filter_t *p_filter = (filter_t *)p_this;
  178.     filter_sys_t *p_sys;
  180.     // Allocate structure
  181.     p_filter->p_sys = p_sys = malloc( sizeof( filter_sys_t ) );
  182.     if( !p_sys )
  183.         return VLC_ENOMEM;
  184.     p_sys->psz_font_name  = var_CreateGetString( p_this, "quartztext-font" );
  185.     p_sys->i_font_opacity = 255;
  186.     p_sys->i_font_color = __MAX( __MIN( var_CreateGetInteger( p_this, "quartztext-color" ) , 0xFFFFFF ), 0 );
  187.     p_sys->i_font_size    = GetFontSize( p_filter );
  189.     p_filter->pf_render_text = RenderText;
  190.     p_filter->pf_render_html = RenderHtml;
  192.     p_sys->p_fonts = NULL;
  193.     p_sys->i_fonts = 0;
  195.     LoadFontsFromAttachments( p_filter );
  197.     return VLC_SUCCESS;
  198. }
  200. //////////////////////////////////////////////////////////////////////////////
  201. // Destroy: destroy Clone video thread output method
  202. //////////////////////////////////////////////////////////////////////////////
  203. // Clean up all data and library connections
  204. //////////////////////////////////////////////////////////////////////////////
  205. static void Destroy( vlc_object_t *p_this )
  206. {
  207.     filter_t *p_filter = (filter_t *)p_this;
  208.     filter_sys_t *p_sys = p_filter->p_sys;
  210.     if( p_sys->p_fonts )
  211.     {
  212.         int   k;
  214.         for( k = 0; k < p_sys->i_fonts; k++ )
  215.         {
  216.             ATSFontDeactivate( p_sys->p_fonts[k], NULL, kATSOptionFlagsDefault );
  217.         }
  219.         free( p_sys->p_fonts );
  220.     }
  222.     free( p_sys->psz_font_name );
  223.     free( p_sys );
  224. }
  226. //////////////////////////////////////////////////////////////////////////////
  227. // Make any TTF/OTF fonts present in the attachments of the media file
  228. // available to the Quartz engine for text rendering
  229. //////////////////////////////////////////////////////////////////////////////
  230. static int LoadFontsFromAttachments( filter_t *p_filter )
  231. {
  232.     filter_sys_t         *p_sys = p_filter->p_sys;
  233.     input_thread_t       *p_input;
  234.     input_attachment_t  **pp_attachments;
  235.     int                   i_attachments_cnt;
  236.     int                   k;
  237.     int                   rv = VLC_SUCCESS;
  239.     p_input = (input_thread_t *)vlc_object_find( p_filter, VLC_OBJECT_INPUT, FIND_PARENT );
  240.     if( ! p_input )
  241.         return VLC_EGENERIC;
  243.     if( VLC_SUCCESS != input_Control( p_input, INPUT_GET_ATTACHMENTS, &pp_attachments, &i_attachments_cnt ))
  244.     {
  245.         vlc_object_release(p_input);
  246.         return VLC_EGENERIC;
  247.     }
  249.     p_sys->i_fonts = 0;
  250.     p_sys->p_fonts = malloc( i_attachments_cnt * sizeof( ATSFontContainerRef ) );
  251.     if(! p_sys->p_fonts )
  252.         rv = VLC_ENOMEM;
  254.     for( k = 0; k < i_attachments_cnt; k++ )
  255.     {
  256.         input_attachment_t *p_attach = pp_attachments[k];
  258.         if( p_sys->p_fonts )
  259.         {
  260.             if(( !strcmp( p_attach->psz_mime, "application/x-truetype-font" ) || // TTF
  261.                  !strcmp( p_attach->psz_mime, "application/x-font-otf" ) ) &&    // OTF
  262.                ( p_attach->i_data > 0 ) &&
  263.                ( p_attach->p_data != NULL ) )
  264.             {
  265.                 ATSFontContainerRef  container;
  267.                 if( noErr == ATSFontActivateFromMemory( p_attach->p_data,
  268.                                                         p_attach->i_data,
  269.                                                         kATSFontContextLocal,
  270.                                                         kATSFontFormatUnspecified,
  271.                                                         NULL,
  272.                                                         kATSOptionFlagsDefault,
  273.                                                         &container ))
  274.                 {
  275.                     p_sys->p_fonts[ p_sys->i_fonts++ ] = container;
  276.                 }
  277.             }
  278.         }
  279.         vlc_input_attachment_Delete( p_attach );
  280.     }
  281.     free( pp_attachments );
  283.     vlc_object_release(p_input);
  285.     return rv;
  286. }
  288. #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_4
  289. // Original version of these functions available on:
  290. // http://developer.apple.com/documentation/Carbon/Conceptual/QuickDrawToQuartz2D/tq_color/chapter_4_section_3.html
  292. #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
  294. static CMProfileRef OpenGenericProfile( void )
  295. {
  296.     static CMProfileRef cached_rgb_prof = NULL;
  298.     // Create the profile reference only once
  299.     if( cached_rgb_prof == NULL )
  300.     {
  301.         OSStatus            err;
  302.         CMProfileLocation   loc;
  304.         loc.locType = cmPathBasedProfile;
  305.         strcpy( loc.u.pathLoc.path, kGenericRGBProfilePathStr );
  307.         err = CMOpenProfile( &cached_rgb_prof, &loc );
  309.         if( err != noErr )
  310.         {
  311.             cached_rgb_prof = NULL;
  312.         }
  313.     }
  315.     if( cached_rgb_prof )
  316.     {
  317.         // Clone the profile reference so that the caller has
  318.         // their own reference, not our cached one.
  319.         CMCloneProfileRef( cached_rgb_prof );
  320.     }
  322.     return cached_rgb_prof;
  323. }
  325. static CGColorSpaceRef CreateGenericRGBColorSpace( void )
  326. {
  327.     static CGColorSpaceRef p_generic_rgb_cs = NULL;
  329.     if( p_generic_rgb_cs == NULL )
  330.     {
  331.         CMProfileRef generic_rgb_prof = OpenGenericProfile();
  333.         if( generic_rgb_prof )
  334.         {
  335.             p_generic_rgb_cs = CGColorSpaceCreateWithPlatformColorSpace( generic_rgb_prof );
  337.             CMCloseProfile( generic_rgb_prof );
  338.         }
  339.     }
  341.     return p_generic_rgb_cs;
  342. }
  343. #endif
  345. static char *EliminateCRLF( char *psz_string )
  346. {
  347.     char *p;
  348.     char *q;
  350.     for( p = psz_string; p && *p; p++ )
  351.     {
  352.         if( ( *p == 'r' ) && ( *(p+1) == 'n' ) )
  353.         {
  354.             for( q = p + 1; *q; q++ )
  355.                 *( q - 1 ) = *q;
  357.             *( q - 1 ) = '';
  358.         }
  359.     }
  360.     return psz_string;
  361. }
  363. // Convert UTF-8 string to UTF-16 character array -- internal Mac Endian-ness ;
  364. // we don't need to worry about bidirectional text conversion as ATSUI should
  365. // handle that for us automatically
  366. static void ConvertToUTF16( const char *psz_utf8_str, uint32_t *pi_strlen, UniChar **ppsz_utf16_str )
  367. {
  368.     CFStringRef   p_cfString;
  369.     int           i_string_length;
  371.     p_cfString = CFStringCreateWithCString( NULL, psz_utf8_str, kCFStringEncodingUTF8 );
  372.     if( !p_cfString )
  373.         return;
  375.     i_string_length = CFStringGetLength( p_cfString );
  377.     if( pi_strlen )
  378.         *pi_strlen = i_string_length;
  380.     if( !*ppsz_utf16_str )
  381.         *ppsz_utf16_str = (UniChar *) calloc( i_string_length, sizeof( UniChar ) );
  383.     CFStringGetCharacters( p_cfString, CFRangeMake( 0, i_string_length ), *ppsz_utf16_str );
  385.     CFRelease( p_cfString );
  386. }
  388. // Renders a text subpicture region into another one.
  389. // It is used as pf_add_string callback in the vout method by this module
  390. static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
  391.                        subpicture_region_t *p_region_in )
  392. {
  393.     filter_sys_t *p_sys = p_filter->p_sys;
  394.     UniChar      *psz_utf16_str = NULL;
  395.     uint32_t      i_string_length;
  396.     char         *psz_string;
  397.     int           i_font_color, i_font_alpha, i_font_size;
  398.     vlc_value_t val;
  399.     int i_scale = 1000;
  401.     p_sys->i_font_size    = GetFontSize( p_filter );
  403.     // Sanity check
  404.     if( !p_region_in || !p_region_out ) return VLC_EGENERIC;
  405.     psz_string = p_region_in->psz_text;
  406.     if( !psz_string || !*psz_string ) return VLC_EGENERIC;
  408.     if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
  409.         i_scale = val.i_int;
  411.     if( p_region_in->p_style )
  412.     {
  413.         i_font_color = __MAX( __MIN( p_region_in->p_style->i_font_color, 0xFFFFFF ), 0 );
  414.         i_font_alpha = __MAX( __MIN( p_region_in->p_style->i_font_alpha, 255 ), 0 );
  415.         i_font_size  = __MAX( __MIN( p_region_in->p_style->i_font_size, 255 ), 0 ) * i_scale / 1000;
  416.     }
  417.     else
  418.     {
  419.         i_font_color = p_sys->i_font_color;
  420.         i_font_alpha = 255 - p_sys->i_font_opacity;
  421.         i_font_size  = p_sys->i_font_size;
  422.     }
  424.     if( !i_font_alpha ) i_font_alpha = 255 - p_sys->i_font_opacity;
  426.     if( i_font_size <= 0 )
  427.     {
  428.         msg_Warn( p_filter, "invalid fontsize, using 12" );
  429.         if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
  430.             i_font_size = 12 * val.i_int / 1000;
  431.         else
  432.             i_font_size = 12;
  433.     }
  435.     ConvertToUTF16( EliminateCRLF( psz_string ), &i_string_length, &psz_utf16_str );
  437.     p_region_out->i_x = p_region_in->i_x;
  438.     p_region_out->i_y = p_region_in->i_y;
  440.     if( psz_utf16_str != NULL )
  441.     {
  442.         ATSUStyle p_style = CreateStyle( p_sys->psz_font_name, i_font_size,
  443.                                          (i_font_color & 0xffffff) |
  444.                                          ((i_font_alpha & 0xff) << 24),
  445.                                          false, false, false );
  446.         if( p_style )
  447.         {
  448.             RenderYUVA( p_filter, p_region_out, psz_utf16_str, i_string_length,
  449.                         1, &i_string_length, &p_style );
  450.         }
  452.         ATSUDisposeStyle( p_style );
  453.         free( psz_utf16_str );
  454.     }
  456.     return VLC_SUCCESS;
  457. }
  460. static ATSUStyle CreateStyle( char *psz_fontname, int i_font_size, uint32_t i_font_color,
  461.                               bool b_bold, bool b_italic, bool b_uline )
  462. {
  463.     ATSUStyle   p_style;
  464.     OSStatus    status;
  465.     uint32_t    i_tag_cnt;
  467.     float f_red   = (float)(( i_font_color & 0x00FF0000 ) >> 16) / 255.0;
  468.     float f_green = (float)(( i_font_color & 0x0000FF00 ) >>  8) / 255.0;
  469.     float f_blue  = (float)(  i_font_color & 0x000000FF        ) / 255.0;
  470.     float f_alpha = ( 255.0 - (float)(( i_font_color & 0xFF000000 ) >> 24)) / 255.0;
  472.     ATSUFontID           font;
  473.     Fixed                font_size  = IntToFixed( i_font_size );
  474.     ATSURGBAlphaColor    font_color = { f_red, f_green, f_blue, f_alpha };
  475.     Boolean              bold       = b_bold;
  476.     Boolean              italic     = b_italic;
  477.     Boolean              uline      = b_uline;
  479.     ATSUAttributeTag tags[]        = { kATSUSizeTag, kATSURGBAlphaColorTag, kATSUQDItalicTag,
  480.                                        kATSUQDBoldfaceTag, kATSUQDUnderlineTag, kATSUFontTag };
  481.     ByteCount sizes[]              = { sizeof( Fixed ), sizeof( ATSURGBAlphaColor ), sizeof( Boolean ),
  482.                                        sizeof( Boolean ), sizeof( Boolean ), sizeof( ATSUFontID )};
  483.     ATSUAttributeValuePtr values[] = { &font_size, &font_color, &italic, &bold, &uline, &font };
  485.     i_tag_cnt = sizeof( tags ) / sizeof( ATSUAttributeTag );
  487.     status = ATSUFindFontFromName( psz_fontname,
  488.                                    strlen( psz_fontname ),
  489.                                    kFontFullName,
  490.                                    kFontNoPlatform,
  491.                                    kFontNoScript,
  492.                                    kFontNoLanguageCode,
  493.                                    &font );
  495.     if( status != noErr )
  496.     {
  497.         // If we can't find a suitable font, just do everything else
  498.         i_tag_cnt--;
  499.     }
  501.     if( noErr == ATSUCreateStyle( &p_style ) )
  502.     {
  503.         if( noErr == ATSUSetAttributes( p_style, i_tag_cnt, tags, sizes, values ) )
  504.         {
  505.             return p_style;
  506.         }
  507.         ATSUDisposeStyle( p_style );
  508.     }
  509.     return NULL;
  510. }
  512. static ATSUStyle GetStyleFromFontStack( filter_sys_t *p_sys,
  513.         font_stack_t **p_fonts, bool b_bold, bool b_italic,
  514.         bool b_uline )
  515. {
  516.     ATSUStyle   p_style = NULL;
  518.     char     *psz_fontname = NULL;
  519.     uint32_t  i_font_color = p_sys->i_font_color;
  520.     uint32_t  i_karaoke_bg_color = i_font_color; /* Use it */
  521.     int       i_font_size  = p_sys->i_font_size;
  523.     if( VLC_SUCCESS == PeekFont( p_fonts, &psz_fontname, &i_font_size,
  524.                                  &i_font_color, &i_karaoke_bg_color ))
  525.     {
  526.         p_style = CreateStyle( psz_fontname, i_font_size, i_font_color,
  527.                                b_bold, b_italic, b_uline );
  528.     }
  529.     return p_style;
  530. }
  532. static void SetupLine( filter_t *p_filter, const char *psz_text_in,
  533.                        UniChar **psz_text_out, uint32_t *pi_runs,
  534.                        uint32_t **ppi_run_lengths, ATSUStyle **ppp_styles,
  535.                        ATSUStyle p_style )
  536. {
  537.     uint32_t i_string_length = 0;
  539.     ConvertToUTF16( psz_text_in, &i_string_length, psz_text_out );
  540.     *psz_text_out += i_string_length;
  542.     if( ppp_styles && ppi_run_lengths )
  543.     {
  544.         (*pi_runs)++;
  546.         if( *ppp_styles )
  547.             *ppp_styles = (ATSUStyle *) realloc( *ppp_styles, *pi_runs * sizeof( ATSUStyle ) );
  548.         else
  549.             *ppp_styles = (ATSUStyle *) malloc( *pi_runs * sizeof( ATSUStyle ) );
  551.         (*ppp_styles)[ *pi_runs - 1 ] = p_style;
  553.         if( *ppi_run_lengths )
  554.             *ppi_run_lengths = (uint32_t *) realloc( *ppi_run_lengths, *pi_runs * sizeof( uint32_t ) );
  555.         else
  556.             *ppi_run_lengths = (uint32_t *) malloc( *pi_runs * sizeof( uint32_t ) );
  558.         (*ppi_run_lengths)[ *pi_runs - 1 ] = i_string_length;
  559.     }
  560. }
  562. static int RenderHtml( filter_t *p_filter, subpicture_region_t *p_region_out,
  563.                        subpicture_region_t *p_region_in )
  564. {
  565.     int          rv = VLC_SUCCESS;
  566.     stream_t     *p_sub = NULL;
  567.     xml_t        *p_xml = NULL;
  568.     xml_reader_t *p_xml_reader = NULL;
  570.     if( !p_region_in || !p_region_in->psz_html )
  571.         return VLC_EGENERIC;
  573.     /* Reset the default fontsize in case screen metrics have changed */
  574.     p_filter->p_sys->i_font_size = GetFontSize( p_filter );
  576.     p_sub = stream_MemoryNew( VLC_OBJECT(p_filter),
  577.                               (uint8_t *) p_region_in->psz_html,
  578.                               strlen( p_region_in->psz_html ),
  579.                               true );
  580.     if( p_sub )
  581.     {
  582.         p_xml = xml_Create( p_filter );
  583.         if( p_xml )
  584.         {
  585.             bool b_karaoke = false;
  587.             p_xml_reader = xml_ReaderCreate( p_xml, p_sub );
  588.             if( p_xml_reader )
  589.             {
  590.                 /* Look for Root Node */
  591.                 if( xml_ReaderRead( p_xml_reader ) == 1 )
  592.                 {
  593.                     char *psz_node = xml_ReaderName( p_xml_reader );
  595.                     if( !strcasecmp( "karaoke", psz_node ) )
  596.                     {
  597.                         /* We're going to have to render the text a number
  598.                          * of times to show the progress marker on the text.
  599.                          */
  600.                         var_SetBool( p_filter, "text-rerender", true );
  601.                         b_karaoke = true;
  602.                     }
  603.                     else if( !strcasecmp( "text", psz_node ) )
  604.                     {
  605.                         b_karaoke = false;
  606.                     }
  607.                     else
  608.                     {
  609.                         /* Only text and karaoke tags are supported */
  610.                         xml_ReaderDelete( p_xml, p_xml_reader );
  611.                         p_xml_reader = NULL;
  612.                         rv = VLC_EGENERIC;
  613.                     }
  615.                     free( psz_node );
  616.                 }
  617.             }
  619.             if( p_xml_reader )
  620.             {
  621.                 UniChar    *psz_text;
  622.                 int         i_len = 0;
  623.                 uint32_t    i_runs = 0;
  624.                 uint32_t    i_k_runs = 0;
  625.                 uint32_t   *pi_run_lengths = NULL;
  626.                 uint32_t   *pi_k_run_lengths = NULL;
  627.                 uint32_t   *pi_k_durations = NULL;
  628.                 ATSUStyle  *pp_styles = NULL;
  630.                 psz_text = (UniChar *) malloc( strlen( p_region_in->psz_html ) *
  631.                                                 sizeof( UniChar ) );
  632.                 if( psz_text )
  633.                 {
  634.                     uint32_t k;
  636.                     rv = ProcessNodes( p_filter, p_xml_reader,
  637.                                   p_region_in->p_style, psz_text, &i_len,
  638.                                   &i_runs, &pi_run_lengths, &pp_styles,
  639.                                   /* No karaoke support */
  640.                                   false, &i_k_runs, &pi_k_run_lengths, &pi_k_durations );
  642.                     assert( pi_k_run_lengths == NULL && pi_k_durations == NULL );
  644.                     p_region_out->i_x = p_region_in->i_x;
  645.                     p_region_out->i_y = p_region_in->i_y;
  647.                     if(( rv == VLC_SUCCESS ) && ( i_len > 0 ))
  648.                     {
  649.                         RenderYUVA( p_filter, p_region_out, psz_text, i_len, i_runs,
  650.                              pi_run_lengths, pp_styles);
  651.                     }
  653.                     for( k=0; k<i_runs; k++)
  654.                         ATSUDisposeStyle( pp_styles[k] );
  655.                     free( pp_styles );
  656.                     free( pi_run_lengths );
  657.                     free( psz_text );
  658.                 }
  660.                 xml_ReaderDelete( p_xml, p_xml_reader );
  661.             }
  662.             xml_Delete( p_xml );
  663.         }
  664.         stream_Delete( p_sub );
  665.     }
  667.     return rv;
  668. }
  670. static CGContextRef CreateOffScreenContext( int i_width, int i_height,
  671.                          offscreen_bitmap_t **pp_memory, CGColorSpaceRef *pp_colorSpace )
  672. {
  673.     offscreen_bitmap_t *p_bitmap;
  674.     CGContextRef        p_context = NULL;
  676.     p_bitmap = (offscreen_bitmap_t *) malloc( sizeof( offscreen_bitmap_t ));
  677.     if( p_bitmap )
  678.     {
  679.         p_bitmap->i_bitsPerChannel = 8;
  680.         p_bitmap->i_bitsPerPixel   = 4 * p_bitmap->i_bitsPerChannel; // A,R,G,B
  681.         p_bitmap->i_bytesPerPixel  = p_bitmap->i_bitsPerPixel / 8;
  682.         p_bitmap->i_bytesPerRow    = i_width * p_bitmap->i_bytesPerPixel;
  684.         p_bitmap->p_data = calloc( i_height, p_bitmap->i_bytesPerRow );
  686.         *pp_colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB );
  688.         if( p_bitmap->p_data && *pp_colorSpace )
  689.         {
  690.             p_context = CGBitmapContextCreate( p_bitmap->p_data, i_width, i_height,
  691.                                 p_bitmap->i_bitsPerChannel, p_bitmap->i_bytesPerRow,
  692.                                 *pp_colorSpace, kCGImageAlphaPremultipliedFirst);
  693.         }
  694.         if( p_context )
  695.         {
  696.             if( CGContextSetAllowsAntialiasing != NULL )
  697.             {
  698.                 CGContextSetAllowsAntialiasing( p_context, true );
  699.             }
  700.         }
  701.         *pp_memory = p_bitmap;
  702.     }
  704.     return p_context;
  705. }
  707. static offscreen_bitmap_t *Compose( int i_text_align, UniChar *psz_utf16_str, uint32_t i_text_len,
  708.                                     uint32_t i_runs, uint32_t *pi_run_lengths, ATSUStyle *pp_styles,
  709.                                     int i_width, int i_height, int *pi_textblock_height )
  710. {
  711.     offscreen_bitmap_t  *p_offScreen  = NULL;
  712.     CGColorSpaceRef      p_colorSpace = NULL;
  713.     CGContextRef         p_context = NULL;
  715.     p_context = CreateOffScreenContext( i_width, i_height, &p_offScreen, &p_colorSpace );
  717.     if( p_context )
  718.     {
  719.         ATSUTextLayout p_textLayout;
  720.         OSStatus status = noErr;
  722.         status = ATSUCreateTextLayoutWithTextPtr( psz_utf16_str, 0, i_text_len, i_text_len,
  723.                                                   i_runs,
  724.                                                   (const UniCharCount *) pi_run_lengths,
  725.                                                   pp_styles,
  726.                                                   &p_textLayout );
  727.         if( status == noErr )
  728.         {
  729.             // Attach our offscreen Image Graphics Context to the text style
  730.             // and setup the line alignment (have to specify the line width
  731.             // also in order for our chosen alignment to work)
  733.             Fract   alignment  = kATSUStartAlignment;
  734.             Fixed   line_width = Long2Fix( i_width - HORIZONTAL_MARGIN * 2 );
  736.             ATSUAttributeTag tags[]        = { kATSUCGContextTag, kATSULineFlushFactorTag, kATSULineWidthTag };
  737.             ByteCount sizes[]              = { sizeof( CGContextRef ), sizeof( Fract ), sizeof( Fixed ) };
  738.             ATSUAttributeValuePtr values[] = { &p_context, &alignment, &line_width };
  740.             int i_tag_cnt = sizeof( tags ) / sizeof( ATSUAttributeTag );
  742.             if( i_text_align == SUBPICTURE_ALIGN_RIGHT )
  743.             {
  744.                 alignment = kATSUEndAlignment;
  745.             }
  746.             else if( i_text_align != SUBPICTURE_ALIGN_LEFT )
  747.             {
  748.                 alignment = kATSUCenterAlignment;
  749.             }
  751.             ATSUSetLayoutControls( p_textLayout, i_tag_cnt, tags, sizes, values );
  753.             // let ATSUI deal with characters not-in-our-specified-font
  754.             ATSUSetTransientFontMatching( p_textLayout, true );
  756.             Fixed x = Long2Fix( HORIZONTAL_MARGIN );
  757.             Fixed y = Long2Fix( i_height );
  759.             // Set the line-breaks and draw individual lines
  760.             uint32_t i_start = 0;
  761.             uint32_t i_end = i_text_len;
  763.             // Set up black outlining of the text --
  764.             CGContextSetRGBStrokeColor( p_context, 0, 0, 0, 0.5 );
  765.             CGContextSetTextDrawingMode( p_context, kCGTextFillStroke );
  766.             CGContextSetShadow( p_context, CGSizeMake( 0, 0 ), 5 );
  767.             float black_components[4] = {0, 0, 0, 1};
  768.             CGColorRef outlinecolor = CGColorCreate( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB ), black_components );
  769.             CGContextSetShadowWithColor (p_context, CGSizeMake( 0, 0 ), 5, outlinecolor);
  770.             CGColorRelease( outlinecolor );
  771.             do
  772.             {
  773.                 // ATSUBreakLine will automatically pick up any manual 'n's also
  774.                 status = ATSUBreakLine( p_textLayout, i_start, line_width, true, (UniCharArrayOffset *) &i_end );
  775.                 if( ( status == noErr ) || ( status == kATSULineBreakInWord ) )
  776.                 {
  777.                     Fixed     ascent;
  778.                     Fixed     descent;
  779.                     uint32_t  i_actualSize;
  781.                     // Come down far enough to fit the height of this line --
  782.                     ATSUGetLineControl( p_textLayout, i_start, kATSULineAscentTag,
  783.                                     sizeof( Fixed ), &ascent, (ByteCount *) &i_actualSize );
  785.                     // Quartz uses an upside-down co-ordinate space -> y values decrease as
  786.                     // you move down the page
  787.                     y -= ascent;
  789.                     // Set the outlining for this line to be dependent on the size of the line -
  790.                     // make it about 5% of the ascent, with a minimum at 1.0
  791.                     float f_thickness = FixedToFloat( ascent ) * 0.05;
  792.                     CGContextSetLineWidth( p_context, (( f_thickness < 1.0 ) ? 1.0 : f_thickness ));
  793.                     ATSUDrawText( p_textLayout, i_start, i_end - i_start, x, y );
  795.                     // and now prepare for the next line by coming down far enough for our
  796.                     // descent
  797.                     ATSUGetLineControl( p_textLayout, i_start, kATSULineDescentTag,
  798.                                     sizeof( Fixed ), &descent, (ByteCount *) &i_actualSize );
  799.                     y -= descent;
  801.                     i_start = i_end;
  802.                 }
  803.                 else
  804.                     break;
  805.             }
  806.             while( i_end < i_text_len );
  808.             *pi_textblock_height = i_height - Fix2Long( y );
  809.             CGContextFlush( p_context );
  811.             ATSUDisposeTextLayout( p_textLayout );
  812.         }
  814.         CGContextRelease( p_context );
  815.     }
  816.     if( p_colorSpace ) CGColorSpaceRelease( p_colorSpace );
  818.     return p_offScreen;
  819. }
  821. static int GetFontSize( filter_t *p_filter )
  822. {
  823.     return p_filter->fmt_out.video.i_height / __MAX(1, var_CreateGetInteger( p_filter, "quartztext-rel-fontsize" ));
  824. }
  826. static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region, UniChar *psz_utf16_str,
  827.                        uint32_t i_text_len, uint32_t i_runs, uint32_t *pi_run_lengths, ATSUStyle *pp_styles )
  828. {
  829.     offscreen_bitmap_t *p_offScreen = NULL;
  830.     int      i_textblock_height = 0;
  832.     int i_width = p_filter->fmt_out.video.i_visible_width;
  833.     int i_height = p_filter->fmt_out.video.i_visible_height;
  834.     int i_text_align = p_region->i_align & 0x3;
  836.     if( !psz_utf16_str )
  837.     {
  838.         msg_Err( p_filter, "Invalid argument to RenderYUVA" );
  839.         return VLC_EGENERIC;
  840.     }
  842.     p_offScreen = Compose( i_text_align, psz_utf16_str, i_text_len,
  843.                            i_runs, pi_run_lengths, pp_styles,
  844.                            i_width, i_height, &i_textblock_height );
  846.     if( !p_offScreen )
  847.     {
  848.         msg_Err( p_filter, "No offscreen buffer" );
  849.         return VLC_EGENERIC;
  850.     }
  852.     uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;
  853.     video_format_t fmt;
  854.     int x, y, i_offset, i_pitch;
  855.     uint8_t i_y, i_u, i_v; // YUV values, derived from incoming RGB
  857.     // Create a new subpicture region
  858.     memset( &fmt, 0, sizeof(video_format_t) );
  859.     fmt.i_chroma = VLC_FOURCC('Y','U','V','A');
  860.     fmt.i_aspect = 0;
  861.     fmt.i_width = fmt.i_visible_width = i_width;
  862.     fmt.i_height = fmt.i_visible_height = __MIN( i_height, i_textblock_height + VERTICAL_MARGIN * 2);
  863.     fmt.i_x_offset = fmt.i_y_offset = 0;
  865.     p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
  866.     if( !p_region->p_picture )
  867.         return VLC_EGENERIC;
  868.     p_region->fmt = fmt;
  870.     p_dst_y = p_region->p_picture->Y_PIXELS;
  871.     p_dst_u = p_region->p_picture->U_PIXELS;
  872.     p_dst_v = p_region->p_picture->V_PIXELS;
  873.     p_dst_a = p_region->p_picture->A_PIXELS;
  874.     i_pitch = p_region->p_picture->A_PITCH;
  876.     i_offset = (i_height+VERTICAL_MARGIN < fmt.i_height) ? VERTICAL_MARGIN *i_pitch : 0 ;
  877.     for( y=0; y<fmt.i_height; y++)
  878.     {
  879.         for( x=0; x<fmt.i_width; x++)
  880.         {
  881.             int i_alpha = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel     ];
  882.             int i_red   = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 1 ];
  883.             int i_green = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 2 ];
  884.             int i_blue  = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 3 ];
  886.             i_y = (uint8_t)__MIN(abs( 2104 * i_red  + 4130 * i_green +
  887.                               802 * i_blue + 4096 + 131072 ) >> 13, 235);
  888.             i_u = (uint8_t)__MIN(abs( -1214 * i_red  + -2384 * i_green +
  889.                              3598 * i_blue + 4096 + 1048576) >> 13, 240);
  890.             i_v = (uint8_t)__MIN(abs( 3598 * i_red + -3013 * i_green +
  891.                               -585 * i_blue + 4096 + 1048576) >> 13, 240);
  893.             p_dst_y[ i_offset + x ] = i_y;
  894.             p_dst_u[ i_offset + x ] = i_u;
  895.             p_dst_v[ i_offset + x ] = i_v;
  896.             p_dst_a[ i_offset + x ] = i_alpha;
  897.         }
  898.         i_offset += i_pitch;
  899.     }
  901.     free( p_offScreen->p_data );
  902.     free( p_offScreen );
  904.     return VLC_SUCCESS;
  905. }
  907. #endif