uint32_t i_string_length;                    // Turn any multiple-whitespaces into single spaces                    char *s = strpbrk( psz_node, "\t\r\n " );                    while( s )                    {                        int i_whitespace = strspn( s, "\t\r\n " );                        if( i_whitespace > 1 )                            memmove( &s[1],                                     &s[i_whitespace],                                     strlen( s ) - i_whitespace + 1 );                        *s++ = ' ';                        s = strpbrk( s, "\t\r\n " );                    }                    ConvertToUTF16( psz_node, &i_string_length, &psz_text );                    psz_text += i_string_length;                    (*pi_runs)++;                    if( *ppp_styles )                        *ppp_styles = (ATSUStyle *) realloc( *ppp_styles, *pi_runs * sizeof( ATSUStyle ) );                    else                        *ppp_styles = (ATSUStyle *) malloc( *pi_runs * sizeof( ATSUStyle ) );                    (*ppp_styles)[ *pi_runs - 1 ] = GetStyleFromFontStack( p_sys, &p_fonts, b_bold, b_italic, b_uline );                    if( *ppi_run_lengths )                        *ppi_run_lengths = (uint32_t *) realloc( *ppi_run_lengths, *pi_runs * sizeof( uint32_t ) );                    else                        *ppi_run_lengths = (uint32_t *) malloc( *pi_runs * sizeof( uint32_t ) );                    (*ppi_run_lengths)[ *pi_runs - 1 ] = i_string_length;                    free( psz_node );                }                break;        }    }    *pi_len = psz_text - psz_text_orig;    while( VLC_SUCCESS == PopFont( &p_fonts ) );    return rv;}static int RenderHtml( filter_t *p_filter, subpicture_region_t *p_region_out,                       subpicture_region_t *p_region_in ){    int          rv = VLC_SUCCESS;    stream_t     *p_sub = NULL;    xml_t        *p_xml = NULL;    xml_reader_t *p_xml_reader = NULL;    if( !p_region_in || !p_region_in->psz_html )        return VLC_EGENERIC;    /* Reset the default fontsize in case screen metrics have changed */    p_filter->p_sys->i_font_size = GetFontSize( p_filter );    p_sub = stream_MemoryNew( VLC_OBJECT(p_filter),                              (uint8_t *) p_region_in->psz_html,                              strlen( p_region_in->psz_html ),                              true );    if( p_sub )    {        p_xml = xml_Create( p_filter );        if( p_xml )        {            bool b_karaoke = false;            p_xml_reader = xml_ReaderCreate( p_xml, p_sub );            if( p_xml_reader )            {                /* Look for Root Node */                if( xml_ReaderRead( p_xml_reader ) == 1 )                {                    char *psz_node = xml_ReaderName( p_xml_reader );                    if( !strcasecmp( "karaoke", psz_node ) )                    {                        /* We're going to have to render the text a number                         * of times to show the progress marker on the text.                         */                        var_SetBool( p_filter, "text-rerender", true );                        b_karaoke = true;                    }                    else if( !strcasecmp( "text", psz_node ) )                    {                        b_karaoke = false;                    }                    else                    {                        /* Only text and karaoke tags are supported */                        xml_ReaderDelete( p_xml, p_xml_reader );                        p_xml_reader = NULL;                        rv = VLC_EGENERIC;                    }                    free( psz_node );                }            }            if( p_xml_reader )            {                UniChar    *psz_text;                int         i_len = 0;                uint32_t    i_runs = 0;                uint32_t   *pi_run_lengths = NULL;                ATSUStyle  *pp_styles = NULL;                psz_text = (UniChar *) malloc( strlen( p_region_in->psz_html ) *                                                sizeof( UniChar ) );                if( psz_text )                {                    uint32_t k;                    rv = ProcessNodes( p_filter, p_xml_reader,                                  p_region_in->p_style, psz_text, &i_len,                                  &i_runs, &pi_run_lengths, &pp_styles );                    p_region_out->i_x = p_region_in->i_x;                    p_region_out->i_y = p_region_in->i_y;                    if(( rv == VLC_SUCCESS ) && ( i_len > 0 ))                    {                        RenderYUVA( p_filter, p_region_out, psz_text, i_len, i_runs,                             pi_run_lengths, pp_styles);                    }                    for( k=0; k<i_runs; k++)                        ATSUDisposeStyle( pp_styles[k] );                    free( pp_styles );                    free( pi_run_lengths );                    free( psz_text );                }                xml_ReaderDelete( p_xml, p_xml_reader );            }            xml_Delete( p_xml );        }        stream_Delete( p_sub );    }    return rv;}static CGContextRef CreateOffScreenContext( int i_width, int i_height,                         offscreen_bitmap_t **pp_memory, CGColorSpaceRef *pp_colorSpace ){    offscreen_bitmap_t *p_bitmap;    CGContextRef        p_context = NULL;    p_bitmap = (offscreen_bitmap_t *) malloc( sizeof( offscreen_bitmap_t ));    if( p_bitmap )    {        p_bitmap->i_bitsPerChannel = 8;        p_bitmap->i_bitsPerPixel   = 4 * p_bitmap->i_bitsPerChannel; // A,R,G,B        p_bitmap->i_bytesPerPixel  = p_bitmap->i_bitsPerPixel / 8;        p_bitmap->i_bytesPerRow    = i_width * p_bitmap->i_bytesPerPixel;        p_bitmap->p_data = calloc( i_height, p_bitmap->i_bytesPerRow );#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4        *pp_colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB );#else        *pp_colorSpace = CreateGenericRGBColorSpace();#endif        if( p_bitmap->p_data && *pp_colorSpace )        {            p_context = CGBitmapContextCreate( p_bitmap->p_data, i_width, i_height,                                p_bitmap->i_bitsPerChannel, p_bitmap->i_bytesPerRow,                                *pp_colorSpace, kCGImageAlphaPremultipliedFirst);        }        if( p_context )        {#if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_1            // OS X 10.1 doesn't support weak linking of this call which is only available            // int 10.4 and later            if( CGContextSetAllowsAntialiasing != NULL )            {                CGContextSetAllowsAntialiasing( p_context, true );            }#endif        }        *pp_memory = p_bitmap;    }    return p_context;}static offscreen_bitmap_t *Compose( int i_text_align, UniChar *psz_utf16_str, uint32_t i_text_len,                                    uint32_t i_runs, uint32_t *pi_run_lengths, ATSUStyle *pp_styles,                                    int i_width, int i_height, int *pi_textblock_height ){    offscreen_bitmap_t  *p_offScreen  = NULL;    CGColorSpaceRef      p_colorSpace = NULL;    CGContextRef         p_context = NULL;    p_context = CreateOffScreenContext( i_width, i_height, &p_offScreen, &p_colorSpace );    if( p_context )    {        ATSUTextLayout p_textLayout;        OSStatus status = noErr;        status = ATSUCreateTextLayoutWithTextPtr( psz_utf16_str, 0, i_text_len, i_text_len,                                                  i_runs,                                                  (const UniCharCount *) pi_run_lengths,                                                  pp_styles,                                                  &p_textLayout );        if( status == noErr )        {            // Attach our offscreen Image Graphics Context to the text style            // and setup the line alignment (have to specify the line width            // also in order for our chosen alignment to work)            Fract   alignment  = kATSUStartAlignment;            Fixed   line_width = Long2Fix( i_width - HORIZONTAL_MARGIN * 2 );            ATSUAttributeTag tags[]        = { kATSUCGContextTag, kATSULineFlushFactorTag, kATSULineWidthTag };            ByteCount sizes[]              = { sizeof( CGContextRef ), sizeof( Fract ), sizeof( Fixed ) };            ATSUAttributeValuePtr values[] = { &p_context, &alignment, &line_width };            int i_tag_cnt = sizeof( tags ) / sizeof( ATSUAttributeTag );            if( i_text_align == SUBPICTURE_ALIGN_RIGHT )            {                alignment = kATSUEndAlignment;            }            else if( i_text_align != SUBPICTURE_ALIGN_LEFT )            {                alignment = kATSUCenterAlignment;            }            ATSUSetLayoutControls( p_textLayout, i_tag_cnt, tags, sizes, values );            // let ATSUI deal with characters not-in-our-specified-font            ATSUSetTransientFontMatching( p_textLayout, true );            Fixed x = Long2Fix( HORIZONTAL_MARGIN );            Fixed y = Long2Fix( i_height );            // Set the line-breaks and draw individual lines            uint32_t i_start = 0;            uint32_t i_end = i_text_len;            // Set up black outlining of the text --            CGContextSetRGBStrokeColor( p_context, 0, 0, 0, 0.5 );            CGContextSetTextDrawingMode( p_context, kCGTextFillStroke );            do            {                // ATSUBreakLine will automatically pick up any manual '\n's also                status = ATSUBreakLine( p_textLayout, i_start, line_width, true, (UniCharArrayOffset *) &i_end );                if( ( status == noErr ) || ( status == kATSULineBreakInWord ) )                {                    Fixed     ascent;                    Fixed     descent;                    uint32_t  i_actualSize;                    // Come down far enough to fit the height of this line --                    ATSUGetLineControl( p_textLayout, i_start, kATSULineAscentTag,                                    sizeof( Fixed ), &ascent, (ByteCount *) &i_actualSize );                    // Quartz uses an upside-down co-ordinate space -> y values decrease as                    // you move down the page                    y -= ascent;                    // Set the outlining for this line to be dependent on the size of the line -                    // make it about 5% of the ascent, with a minimum at 1.0                    float f_thickness = FixedToFloat( ascent ) * 0.05;                    CGContextSetLineWidth( p_context, (( f_thickness > 1.0 ) ? 1.0 : f_thickness ));                    ATSUDrawText( p_textLayout, i_start, i_end - i_start, x, y );                    // and now prepare for the next line by coming down far enough for our                    // descent                    ATSUGetLineControl( p_textLayout, i_start, kATSULineDescentTag,                                    sizeof( Fixed ), &descent, (ByteCount *) &i_actualSize );                    y -= descent;                    i_start = i_end;                }                else                    break;            }            while( i_end < i_text_len );            *pi_textblock_height = i_height - Fix2Long( y );            CGContextFlush( p_context );            ATSUDisposeTextLayout( p_textLayout );        }        CGContextRelease( p_context );    }    if( p_colorSpace ) CGColorSpaceRelease( p_colorSpace );    return p_offScreen;}static int GetFontSize( filter_t *p_filter ){    return p_filter->fmt_out.video.i_height / __MAX(1, var_CreateGetInteger( p_filter, "quartztext-rel-fontsize" ));}static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region, UniChar *psz_utf16_str,                       uint32_t i_text_len, uint32_t i_runs, uint32_t *pi_run_lengths, ATSUStyle *pp_styles ){    offscreen_bitmap_t *p_offScreen = NULL;    int      i_textblock_height = 0;    int i_width = p_filter->fmt_out.video.i_visible_width;    int i_height = p_filter->fmt_out.video.i_visible_height;    int i_text_align = p_region->i_align & 0x3;    if( !psz_utf16_str )    {        msg_Err( p_filter, "Invalid argument to RenderYUVA" );        return VLC_EGENERIC;    }    p_offScreen = Compose( i_text_align, psz_utf16_str, i_text_len,                           i_runs, pi_run_lengths, pp_styles,                           i_width, i_height, &i_textblock_height );    if( !p_offScreen )    {        msg_Err( p_filter, "No offscreen buffer" );        return VLC_EGENERIC;    }    uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;    video_format_t fmt;    int x, y, i_offset, i_pitch;    uint8_t i_y, i_u, i_v; // YUV values, derived from incoming RGB    subpicture_region_t *p_region_tmp;    // Create a new subpicture region    memset( &fmt, 0, sizeof(video_format_t) );    fmt.i_chroma = VLC_FOURCC('Y','U','V','A');    fmt.i_aspect = 0;    fmt.i_width = fmt.i_visible_width = i_width;    fmt.i_height = fmt.i_visible_height = i_textblock_height + VERTICAL_MARGIN * 2;    fmt.i_x_offset = fmt.i_y_offset = 0;    p_region_tmp = spu_CreateRegion( p_filter, &fmt );    if( !p_region_tmp )    {        msg_Err( p_filter, "cannot allocate SPU region" );        return VLC_EGENERIC;    }    p_region->fmt = p_region_tmp->fmt;    p_region->picture = p_region_tmp->picture;    free( p_region_tmp );    p_dst_y = p_region->picture.Y_PIXELS;    p_dst_u = p_region->picture.U_PIXELS;    p_dst_v = p_region->picture.V_PIXELS;    p_dst_a = p_region->picture.A_PIXELS;    i_pitch = p_region->picture.A_PITCH;    i_offset = VERTICAL_MARGIN *i_pitch;    for( y=0; y<i_textblock_height; y++)    {        for( x=0; x<i_width; x++)        {            int i_alpha = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel     ];            int i_red   = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 1 ];            int i_green = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 2 ];            int i_blue  = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 3 ];            i_y = (uint8_t)__MIN(abs( 2104 * i_red  + 4130 * i_green +                              802 * i_blue + 4096 + 131072 ) >> 13, 235);            i_u = (uint8_t)__MIN(abs( -1214 * i_red  + -2384 * i_green +                             3598 * i_blue + 4096 + 1048576) >> 13, 240);            i_v = (uint8_t)__MIN(abs( 3598 * i_red + -3013 * i_green +                              -585 * i_blue + 4096 + 1048576) >> 13, 240);            p_dst_y[ i_offset + x ] = i_y;            p_dst_u[ i_offset + x ] = i_u;            p_dst_v[ i_offset + x ] = i_v;            p_dst_a[ i_offset + x ] = i_alpha;        }        i_offset += i_pitch;    }    free( p_offScreen->p_data );    free( p_offScreen );    return VLC_SUCCESS;}