root/branches/perian-1.1/Subtitles/SubATSUIRenderer.m

//
//  SubATSUIRenderer.m
//  SSARender2
//
//  Created by Alexander Strange on 7/30/07.
//  Copyright 2007 __MyCompanyName__. All rights reserved.
//

#import "SubATSUIRenderer.h"
#import "SubImport.h"
#import "SubParsing.h"
#import "SubUtilities.h"
#import "Codecprintf.h"

static float GetWinFontSizeScale(ATSFontRef font);
static void FindAllPossibleLineBreaks(TextBreakLocatorRef breakLocator, unichar *uline, UniCharArrayOffset lineLen, unsigned char *breakOpportunities);

#define declare_bitfield(name, bits) unsigned char name[bits / 8 + 1]; bzero(name, sizeof(name));
#define bitfield_set(name, bit) name[(bit) / 8] |= 1 << ((bit) % 8);
#define bitfield_test(name, bit) ((name[(bit) / 8] & (1 << ((bit) % 8))) != 0)

@interface SubATSUISpanEx : NSObject {
        @public;
        ATSUStyle style;
        CGColorRef primaryColor, outlineColor, shadowColor;
        Float32 outlineRadius, shadowDist, scaleX, scaleY, primaryAlpha, outlineAlpha, angle;
        BOOL blurEdges;
}
-(SubATSUISpanEx*)initWithStyle:(ATSUStyle)style_ subStyle:(SubStyle*)sstyle colorSpace:(CGColorSpaceRef)cs;
-(SubATSUISpanEx*)clone;
@end

@implementation SubATSUISpanEx
-(void)dealloc
{
        ATSUDisposeStyle(style);
        CGColorRelease(primaryColor);
        CGColorRelease(outlineColor);
        CGColorRelease(shadowColor);
        [super dealloc];
}

-(void)finalize
{
        ATSUDisposeStyle(style);
        CGColorRelease(primaryColor);
        CGColorRelease(outlineColor);
        CGColorRelease(shadowColor);
        [super finalize];
}

static CGColorRef MakeCGColorFromRGBA(SubRGBAColor c, CGColorSpaceRef cspace)
{
        const float components[] = {c.red, c.green, c.blue, c.alpha};
        
        return CGColorCreate(cspace, components);
}

static CGColorRef MakeCGColorFromRGBOpaque(SubRGBAColor c, CGColorSpaceRef cspace)
{
        SubRGBAColor c2 = c;
        c2.alpha = 1;
        return MakeCGColorFromRGBA(c2, cspace);
}

static CGColorRef CloneCGColorWithAlpha(CGColorRef c, float alpha)
{
        CGColorRef new = CGColorCreateCopyWithAlpha(c, alpha);
        CGColorRelease(c);
        return new;
}

-(SubATSUISpanEx*)initWithStyle:(ATSUStyle)style_ subStyle:(SubStyle*)sstyle colorSpace:(CGColorSpaceRef)cs
{
        if (self = [super init]) {
                ATSUCreateAndCopyStyle(style_, &style);
                
                primaryColor = MakeCGColorFromRGBOpaque(sstyle->primaryColor, cs);
                primaryAlpha = sstyle->primaryColor.alpha;
                outlineColor = MakeCGColorFromRGBOpaque(sstyle->outlineColor, cs);
                outlineAlpha = sstyle->outlineColor.alpha;
                shadowColor  = MakeCGColorFromRGBA(sstyle->shadowColor,  cs);
                outlineRadius = sstyle->outlineRadius;
                shadowDist = sstyle->shadowDist;
                scaleX = sstyle->scaleX / 100.;
                scaleY = sstyle->scaleY / 100.;
                angle = sstyle->angle;
        }
        
        return self;
}

-(SubATSUISpanEx*)clone
{
        SubATSUISpanEx *ret = [[SubATSUISpanEx alloc] init];
        
        ATSUCreateAndCopyStyle(style, &ret->style);
        ret->primaryColor = CGColorRetain(primaryColor);
        ret->primaryAlpha = primaryAlpha;
        ret->outlineColor = CGColorRetain(outlineColor);
        ret->outlineAlpha = outlineAlpha;
        ret->shadowColor = CGColorRetain(shadowColor);
        ret->outlineRadius = outlineRadius;
        ret->shadowDist = shadowDist;
        ret->scaleX = scaleX;
        ret->scaleY = scaleY;
        ret->angle = angle;
        
        return [ret autorelease];
}
@end

#define span_ex(span) ((SubATSUISpanEx*)span->ex)

static void SetATSUStyleFlag(ATSUStyle style, ATSUAttributeTag t, Boolean v)
{
        const ATSUAttributeTag tags[] = {t};
        const ByteCount          sizes[] = {sizeof(v)};
        const ATSUAttributeValuePtr vals[] = {&v};
        
        ATSUSetAttributes(style,1,tags,sizes,vals);
}

static void SetATSUStyleOther(ATSUStyle style, ATSUAttributeTag t, ByteCount s, const ATSUAttributeValuePtr v)
{
        const ATSUAttributeTag tags[] = {t};
        const ByteCount          sizes[] = {s};
        const ATSUAttributeValuePtr vals[] = {v};
        
        ATSUSetAttributes(style,1,tags,sizes,vals);
}

static void SetATSULayoutOther(ATSUTextLayout l, ATSUAttributeTag t, ByteCount s, const ATSUAttributeValuePtr v)
{
        const ATSUAttributeTag tags[] = {t};
        const ByteCount          sizes[] = {s};
        const ATSUAttributeValuePtr vals[] = {v};
        
        ATSUSetLayoutControls(l,1,tags,sizes,vals);
}

@implementation SubATSUIRenderer

// from Apple Q&A 1396
static CGColorSpaceRef CreateICCColorSpaceFromPathToProfile (const char * iccProfilePath) {
        CMProfileRef    iccProfile = NULL;
        CGColorSpaceRef iccColorSpace = NULL;
        CMProfileLocation loc;
        
        // Specify that the location of the profile will be a POSIX path to the profile.
        loc.locType = cmPathBasedProfile;
        
        // Make sure the path is not larger then the buffer
        if(strlen(iccProfilePath) > sizeof(loc.u.pathLoc.path))
                return NULL;
        
        // Copy the path the profile into the CMProfileLocation structure
        strcpy (loc.u.pathLoc.path, iccProfilePath);
        
        // Open the profile
        if (CMOpenProfile(&iccProfile, &loc) != noErr)
        {
                iccProfile = (CMProfileRef) 0;
                return NULL;
        }
        
        // Create the ColorSpace with the open profile.
        iccColorSpace = CGColorSpaceCreateWithPlatformColorSpace( iccProfile );
        
        // Close the profile now that we have what we need from it.
        CMCloseProfile(iccProfile);
        
        return iccColorSpace;
}

static CGColorSpaceRef CreateColorSpaceFromSystemICCProfileName(CFStringRef profileName) {
        FSRef pathToProfilesFolder;
    FSRef pathToProfile;
        
        // Find the Systems Color Sync Profiles folder
        if(FSFindFolder(kOnSystemDisk, kColorSyncProfilesFolderType,
                                        kDontCreateFolder, &pathToProfilesFolder) == noErr) {
                
                // Make a UniChar string of the profile name
                UniChar uniBuffer[sizeof(CMPathLocation)];
                CFStringGetCharacters (profileName,CFRangeMake(0,CFStringGetLength(profileName)),uniBuffer);
                
                // Create a FSRef to the profile in the Systems Color Sync Profile folder
                if(FSMakeFSRefUnicode (&pathToProfilesFolder,CFStringGetLength(profileName),uniBuffer,
                                                           kUnicodeUTF8Format,&pathToProfile) == noErr) {
                        unsigned char path[sizeof(CMPathLocation)];
                        
                        // Write the posix path to the profile into our path buffer from the FSRef
                        if(FSRefMakePath (&pathToProfile,path,sizeof(CMPathLocation)) == noErr)
                                return CreateICCColorSpaceFromPathToProfile((char*)path);
                }
        }
        
        return NULL;
}

static CGColorSpaceRef CreateICCsRGBColorSpace() {
        return CreateColorSpaceFromSystemICCProfileName(CFSTR("sRGB Profile.icc"));
}

static CGColorSpaceRef GetSRGBColorSpace() {
        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
        CGColorSpaceRef cs = CreateICCsRGBColorSpace();
        [pool release];
        return cs;
}

-(SubATSUIRenderer*)initWithVideoWidth:(float)width videoHeight:(float)height;
{
        if (self = [super init]) {
                ATSUCreateTextLayout(&layout);
                ubuffer = malloc(sizeof(unichar) * 128);
                srgbCSpace = GetSRGBColorSpace();
                
                videoWidth = width;
                videoHeight = height;
                
                UCCreateTextBreakLocator(NULL, 0, kUCTextBreakLineMask, &breakLocator);
                [[SubContext alloc] initWithNonSSAType:kSubTypeSRT delegate:self];
        }
        
        return self;
}

-(SubATSUIRenderer*)initWithSSAHeader:(NSString*)header videoWidth:(float)width videoHeight:(float)height;
{
        if (self = [super init]) {
                unsigned hlength = [header length];
                unichar *uheader = malloc(sizeof(unichar) * hlength);
                
                header = STStandardizeStringNewlines(header);
                [header getCharacters:uheader];
                
                NSDictionary *headers;
                NSArray *styles;
                SubParseSSAFile(uheader, hlength, &headers, &styles, NULL);
                free(uheader);
                
                ubuffer = malloc(sizeof(unichar) * 128);
                
                videoWidth = width;
                videoHeight = height;
                
                ATSUCreateTextLayout(&layout);
                srgbCSpace = GetSRGBColorSpace();
                
                UCCreateTextBreakLocator(NULL, 0, kUCTextBreakLineMask, &breakLocator);
                [[SubContext alloc] initWithHeaders:headers styles:styles extraData:header delegate:self];
        }
        
        return self;
}

-(void)dealloc
{
        [context release];
        free(ubuffer);
        CGColorSpaceRelease(srgbCSpace);
        UCDisposeTextBreakLocator(&breakLocator);
        ATSUDisposeTextLayout(layout);
        [super dealloc];
}

-(void)finalize
{
        free(ubuffer);
        UCDisposeTextBreakLocator(&breakLocator);
        ATSUDisposeTextLayout(layout);
        [super finalize];
}

-(void)completedHeaderParsing:(SubContext*)sc
{
        context = sc;
        screenScaleX = videoWidth / context->resX;
        screenScaleY = videoHeight / context->resY;
}

-(float)aspectRatio
{
        return videoWidth / videoHeight;
}

static NSMutableDictionary *fontIDCache = nil;
static ATSUFontID fontCount=-1, *fontIDs = NULL;

static void CleanupFontIDCache() __attribute__((destructor));
static void CleanupFontIDCache()
{
        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
        if (fontIDCache) [fontIDCache release];
        if (fontIDs) free(fontIDs);
        fontIDCache = nil;
        fontIDs = NULL;
        [pool release];
}

// XXX: Assumes ATSUFontID = ATSFontRef. This is true.
static ATSUFontID GetFontIDForSSAName(NSString *name)
{
        ByteCount nlen = [name length];
        unichar *uname = (unichar*)[name cStringUsingEncoding:NSUnicodeStringEncoding];
        
        if (!fontIDCache) fontIDCache = [[NSMutableDictionary alloc] init];
        
        NSNumber *idN = [fontIDCache objectForKey:[name lowercaseString]];
                
        if (idN) return [idN intValue];
        
        ATSUFontID font;
        
        ATSUFindFontFromName(uname, nlen * sizeof(unichar), kFontFamilyName, kFontNoPlatformCode, kFontNoScript, kFontNoLanguage, &font);
        
        if (font == kATSUInvalidFontID) font = ATSFontFindFromName((CFStringRef)name, kATSOptionFlagsDefault); // for bugs in ATS under 10.4
        if (font == kATSUInvalidFontID) { // try a case-insensitive search
                if (fontCount == -1) {
                        ATSUFontCount(&fontCount);
                        fontIDs = malloc(sizeof(ATSUFontID[fontCount]));
                        ATSUGetFontIDs(fontIDs, fontCount, &fontCount);
                }
                                
                ByteCount len;
                ItemCount x, index;
                const ByteCount kBufLength = 1024/sizeof(unichar);
                unichar buf[kBufLength];
          
                for (x = 0; x < fontCount; x++) {
                        ATSUFindFontName(fontIDs[x], kFontFamilyName, kFontMicrosoftPlatform, kFontNoScript, kFontNoLanguage, kBufLength, (Ptr)buf, &len, &index);
                        NSString *fname = [NSString stringWithCharacters:buf length:len/sizeof(unichar)];
                        
                        if ([name caseInsensitiveCompare:fname] == NSOrderedSame) {
                                font = fontIDs[x];
                                break;
                        }
                }
                
                if (font == kATSUInvalidFontID) font = ATSFontFindFromName((CFStringRef)@"Helvetica",kATSOptionFlagsDefault); // final fallback
        }
        
        [fontIDCache setValue:[NSNumber numberWithInt:font] forKey:[name lowercaseString]];
         
        return font;
}

-(void*)completedStyleParsing:(SubStyle*)s
{
        const ATSUAttributeTag tags[] = {kATSUStyleRenderingOptionsTag, kATSUSizeTag, kATSUQDBoldfaceTag, kATSUQDItalicTag, kATSUQDUnderlineTag, kATSUStyleStrikeThroughTag, kATSUFontTag, kATSUVerticalCharacterTag};
        const ByteCount          sizes[] = {sizeof(ATSStyleRenderingOptions), sizeof(Fixed), sizeof(Boolean), sizeof(Boolean), sizeof(Boolean), sizeof(Boolean), sizeof(ATSUFontID), sizeof(ATSUVerticalCharacterType)};
        
        NSString *fn = s->fontname;
        ATSUVerticalCharacterType vertical = ParseFontVerticality(&fn) ? kATSUStronglyVertical : kATSUStronglyHorizontal;
        ATSUFontID font = GetFontIDForSSAName(fn);
        ATSFontRef fontRef = font;
        ATSStyleRenderingOptions opt = kATSStyleApplyAntiAliasing;
        Fixed size;
        Boolean b = s->bold, i = s->italic, u = s->underline, st = s->strikeout;
        ATSUStyle style;
                
        const ATSUAttributeValuePtr vals[] = {&opt, &size, &b, &i, &u, &st, &font, &vertical};
        
        if (!s->platformSizeScale) s->platformSizeScale = GetWinFontSizeScale(fontRef);
        size = FloatToFixed(s->size * s->platformSizeScale * screenScaleY);
        
        ATSUCreateStyle(&style);
        ATSUSetAttributes(style, sizeof(tags) / sizeof(ATSUAttributeTag), tags, sizes, vals);
        
        if (s->tracking > 0) { // bug in VSFilter: negative tracking in style lines is ignored
                Fixed tracking = FloatToFixed(s->tracking);
                
                SetATSUStyleOther(style, kATSUAfterWithStreamShiftTag, sizeof(Fixed), &tracking);
        }
        
        if (s->scaleX != 100. || s->scaleY != 100.) {
                CGAffineTransform mat = CGAffineTransformMakeScale(s->scaleX / 100., s->scaleY / 100.);
                
                SetATSUStyleOther(style, kATSUFontMatrixTag, sizeof(CGAffineTransform), &mat);
        }
        
        const ATSUFontFeatureType ftypes[] = {kLigaturesType, kTypographicExtrasType, kTypographicExtrasType, kTypographicExtrasType};
        const ATSUFontFeatureSelector fsels[] = {kCommonLigaturesOnSelector, kSmartQuotesOnSelector, kPeriodsToEllipsisOnSelector, kHyphenToEnDashOnSelector};
        
        ATSUSetFontFeatures(style, sizeof(ftypes) / sizeof(ATSUFontFeatureType), ftypes, fsels);
        
        return style;
}

-(void)releaseStyleExtra:(void*)ex
{
        ATSUDisposeStyle(ex);
}

-(void*)spanExtraFromRenderDiv:(SubRenderDiv*)div
{
        return [[[SubATSUISpanEx alloc] initWithStyle:(ATSUStyle)div->styleLine->ex subStyle:div->styleLine colorSpace:srgbCSpace] autorelease];
}

-(void*)cloneSpanExtra:(SubRenderSpan*)span
{
        return [(SubATSUISpanEx*)span->ex clone];
}

-(void)disposeSpanExtra:(void*)ex
{
        SubATSUISpanEx *spanEx = ex;
        [spanEx release];
}

enum {renderMultipleParts = 1, // call ATSUDrawText more than once, needed for color/border changes in the middle of lines
          renderManualShadows = 2, // CG shadows can't change inside a line... probably
          renderComplexTransforms = 4}; // can't draw text at all, have to transform each vertex. needed for 3D perspective, or \frz in the middle of a line

-(void)spanChangedTag:(SSATagType)tag span:(SubRenderSpan*)span div:(SubRenderDiv*)div param:(void*)p
{
        SubATSUISpanEx *spanEx = span->ex;
        BOOL isFirstSpan = [div->spans count] == 0;
        Boolean bval;
        int ival;
        float fval;
        NSString *sval;
        Fixed fixval;
        CGColorRef color;
        CGAffineTransform mat;
        
#define bv() bval = *(int*)p;
#define iv() ival = *(int*)p;
#define fv() fval = *(float*)p;
#define sv() sval = *(NSString**)p;
#define fixv() fv(); fixval = FloatToFixed(fval);
#define colorv() color = MakeCGColorFromRGBA(ParseSSAColor(*(int*)p), srgbCSpace);
        
        switch (tag) {
                case tag_b:
                        bv();
                        SetATSUStyleFlag(spanEx->style, kATSUQDBoldfaceTag, bval != 0);
                        break; 
                case tag_i:
                        bv();
                        SetATSUStyleFlag(spanEx->style, kATSUQDItalicTag, bval);
                        break; 
                case tag_u:
                        bv();
                        SetATSUStyleFlag(spanEx->style, kATSUQDUnderlineTag, bval);
                        break; 
                case tag_s:
                        bv();
                        SetATSUStyleFlag(spanEx->style, kATSUStyleStrikeThroughTag, bval);
                        break; 
                case tag_bord:
                        fv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts;
                        spanEx->outlineRadius = fval;
                        break;
                case tag_shad:
                        fv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts | renderManualShadows;
                        spanEx->shadowDist = fval;
                        break;
                case tag_fn:
                        sv();
                        {
                                ATSUVerticalCharacterType vertical = ParseFontVerticality(&sval) ? kATSUStronglyVertical : kATSUStronglyHorizontal;
                                ATSUFontID font = GetFontIDForSSAName(sval);
                                
                                if (font) {
                                        SetATSUStyleFlag(spanEx->style, kATSUVerticalCharacterTag, vertical);
                                        SetATSUStyleOther(spanEx->style, kATSUFontTag, sizeof(ATSUFontID), &font);
                                }
                        }
                        break;
                case tag_fs:
                        fv();
                        fixval = FloatToFixed(fval * div->styleLine->platformSizeScale);
                        SetATSUStyleOther(spanEx->style, kATSUSizeTag, sizeof(Fixed), &fixval);
                        break;
                case tag_1c:
                        CGColorRelease(spanEx->primaryColor);
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts;
                        colorv();
                        spanEx->primaryColor = color;
                        break;
                case tag_3c:
                        CGColorRelease(spanEx->outlineColor);
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts;
                        {
                                SubRGBAColor rgba = ParseSSAColor(*(int*)p);
                                spanEx->outlineColor = MakeCGColorFromRGBOpaque(rgba, srgbCSpace);
                                spanEx->outlineAlpha = rgba.alpha;
                        }
                        break;
                case tag_4c:
                        CGColorRelease(spanEx->shadowColor);
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts | renderManualShadows;
                        colorv();
                        spanEx->shadowColor = color;
                        break;
                case tag_fscx:
                        fv();
                        spanEx->scaleX = fval / 100.;
                        mat = CGAffineTransformMakeScale(spanEx->scaleX, spanEx->scaleY);
                        SetATSUStyleOther(spanEx->style, kATSUFontMatrixTag, sizeof(CGAffineTransform), &mat);
                        break;
                case tag_fscy:
                        fv();
                        spanEx->scaleY = fval / 100.;
                        mat = CGAffineTransformMakeScale(spanEx->scaleX, spanEx->scaleY);
                        SetATSUStyleOther(spanEx->style, kATSUFontMatrixTag, sizeof(CGAffineTransform), &mat);
                        break;
                case tag_fsp:
                        fixv();
                        SetATSUStyleOther(spanEx->style, kATSUAfterWithStreamShiftTag, sizeof(Fixed), &fixval);
                        break;
                case tag_frz:
                        if (!isFirstSpan) div->render_complexity |= renderComplexTransforms; // this one's hard
                        fv();
                        spanEx->angle = fval;
                        break;
                case tag_1a:
                        iv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts;
                        spanEx->primaryAlpha = (255-ival)/255.;
                        break;
                case tag_3a:
                        iv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts;
                        spanEx->outlineAlpha = (255-ival)/255.;
                        break;
                case tag_4a:
                        iv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts | renderManualShadows;
                        spanEx->shadowColor = CloneCGColorWithAlpha(spanEx->shadowColor, (255-ival)/255.);
                        break;
                case tag_alpha:
                        iv();
                        fval = (255-ival)/255.;
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts | renderManualShadows;
                        spanEx->primaryAlpha = spanEx->outlineAlpha = fval;
                        spanEx->shadowColor = CloneCGColorWithAlpha(spanEx->shadowColor, fval);
                        break;
                case tag_r:
                        sv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts | renderManualShadows;
                        {
                                SubStyle *style = [context->styles objectForKey:sval];
                                if (!style) style = div->styleLine;
                                
                                [spanEx release];
                                span->ex = [[SubATSUISpanEx alloc] initWithStyle:(ATSUStyle)style->ex subStyle:style colorSpace:srgbCSpace];
                        }
                        break;
                case tag_be:
                        bv();
                        if (!isFirstSpan) div->render_complexity |= renderMultipleParts;
                        spanEx->blurEdges = bval;
                        break;
                default:
                        Codecprintf(NULL, "Unimplemented SSA tag #%d\n",tag);
        }
}

#pragma mark Rendering Helper Functions

static ATSUTextMeasurement GetLineHeight(ATSUTextLayout layout, UniCharArrayOffset lpos)
{
        ATSUTextMeasurement ascent, descent;
        
        ATSUGetLineControl(layout, lpos, kATSULineAscentTag,  sizeof(ATSUTextMeasurement), &ascent,  NULL);
        ATSUGetLineControl(layout, lpos, kATSULineDescentTag, sizeof(ATSUTextMeasurement), &descent, NULL);
        
        return ascent + descent;
}

static void ExpandCGRect(CGRect *rect, float radius)
{
        rect->origin.x -= radius;
        rect->origin.y -= radius;
        rect->size.height += radius*2.;
        rect->size.width += radius*2.;
}

static void GetTypographicRectangleForLayout(ATSUTextLayout layout, UniCharArrayOffset *breaks, ItemCount breakCount, Fixed extraHeight, Fixed *lX, Fixed *lY, Fixed *height, Fixed *width)
{
        ATSTrapezoid trap = {0};
        ItemCount trapCount;
        FixedRect largeRect = {0};
        Fixed baseY = 0;
        int i;

        for (i = breakCount; i >= 0; i--) {             
                UniCharArrayOffset end = breaks[i+1];
                FixedRect rect;
                
                ATSUGetGlyphBounds(layout, 0, baseY, breaks[i], end-breaks[i], kATSUseDeviceOrigins, 1, &trap, &trapCount);

                baseY += GetLineHeight(layout, breaks[i]) + extraHeight;
                
                rect.bottom = MAX(trap.lowerLeft.y, trap.lowerRight.y);
                rect.left = MIN(trap.lowerLeft.x, trap.upperLeft.x);
                rect.top = MIN(trap.upperLeft.y, trap.upperRight.y);
                rect.right = MAX(trap.lowerRight.x, trap.upperRight.x);
                
                if (i == breakCount) largeRect = rect;
                
                largeRect.bottom = MAX(largeRect.bottom, rect.bottom);
                largeRect.left = MIN(largeRect.left, rect.left);
                largeRect.top = MIN(largeRect.top, rect.top);
                largeRect.right = MAX(largeRect.right, rect.right);
        }
        
        if (lX) *lX = largeRect.left;
        if (lY) *lY = largeRect.bottom;
        *height = largeRect.bottom - largeRect.top;
        *width = largeRect.right - largeRect.left;
}

#if 0
static void GetImageBoundingBoxForLayout(ATSUTextLayout layout, UniCharArrayOffset *breaks, ItemCount breakCount, Fixed extraHeight, Fixed *lX, Fixed *lY, Fixed *height, Fixed *width)
{
        Rect largeRect = {0};
        ATSUTextMeasurement baseY = 0;
        int i;
        
        for (i = breakCount; i >= 0; i--) {
                UniCharArrayOffset end = breaks[i+1];
                Rect rect;
                
                ATSUMeasureTextImage(layout, breaks[i], end-breaks[i], 0, baseY, &rect);
                
                baseY += GetLineHeight(layout, breaks[i]) + extraHeight;
                
                if (i == breakCount) largeRect = rect;
                
                largeRect.bottom = MAX(largeRect.bottom, rect.bottom);
                largeRect.left = MIN(largeRect.left, rect.left);
                largeRect.top = MIN(largeRect.top, rect.top);
                largeRect.right = MAX(largeRect.right, rect.right);
                        }
        
        
        if (lX) *lX = IntToFixed(largeRect.left);
        if (lY) *lY = IntToFixed(largeRect.bottom);
        *height = IntToFixed(largeRect.bottom - largeRect.top);
        *width = IntToFixed(largeRect.right - largeRect.left);
}
#endif

enum {fillc, strokec};

static void SetColor(CGContextRef c, int whichcolor, CGColorRef col)
{
        if (whichcolor == fillc) CGContextSetFillColorWithColor(c, col);
        else CGContextSetStrokeColorWithColor(c, col);
}

static void SetStyleSpanRuns(ATSUTextLayout layout, SubRenderDiv *div)
{
        unsigned span_count = [div->spans count];
        int i;
        
        for (i = 0; i < span_count; i++) {
                SubRenderSpan *span = [div->spans objectAtIndex:i];
                UniCharArrayOffset next = (i == span_count-1) ? [div->text length] : ((SubRenderSpan*)[div->spans objectAtIndex:i+1])->offset;
                ATSUSetRunStyle(layout, span_ex(span)->style, span->offset, next - span->offset);
        }
}

static Fixed RoundFixed(Fixed n) {return IntToFixed(FixedToInt(n));}

static void SetLayoutPositioning(ATSUTextLayout layout, Fixed lineWidth, UInt8 align)
{
        const ATSUAttributeTag tags[] = {kATSULineFlushFactorTag, kATSULineWidthTag, kATSULineRotationTag};
        const ByteCount          sizes[] = {sizeof(Fract), sizeof(ATSUTextMeasurement), sizeof(Fixed)};
        Fract alignment;
        Fixed fixzero = 0;
        const ATSUAttributeValuePtr vals[] = {&alignment, &lineWidth, &fixzero};
        
        switch (align) {
                case kSubAlignmentLeft:
                        alignment = FloatToFract(0);
                        break;
                case kSubAlignmentCenter:
                        alignment = kATSUCenterAlignment;
                        break;
                case kSubAlignmentRight:
                        alignment = fract1;
                        break;
        }
        
        ATSUSetLayoutControls(layout,sizeof(vals) / sizeof(ATSUAttributeValuePtr),tags,sizes,vals);
}

static UniCharArrayOffset BreakOneLineSpan(ATSUTextLayout layout, SubRenderDiv *div, unsigned char *breakOpportunities,
                                                                                   ATSLayoutRecord *records, ItemCount lineLen, Fixed idealLineWidth, Fixed originalLineWidth, Fixed maximumLineWidth, unsigned numBreaks, unsigned lastHardBreak)
{               
        int recOffset = 0;
        Fixed widthOffset = 0;
        BOOL foundABreak;
        UniCharArrayOffset lastBreakOffset = 0;
        
        do {
                int j, lastIndex = 0;
                ATSUTextMeasurement error = 0;
                foundABreak = NO;
                                
                for (j = recOffset; j < lineLen; j++) {
                        ATSLayoutRecord *rec = &records[j];
                        Fixed recPos = rec->realPos - widthOffset;
                        UniCharArrayOffset charOffset = rec->originalOffset/2 + lastHardBreak;

                        if (bitfield_test(breakOpportunities, charOffset)) {
                                if (recPos >= idealLineWidth) {
                                        error = recPos - idealLineWidth;

                                        if (lastIndex) {
                                                Fixed lastError = abs((records[lastIndex].realPos - widthOffset) - idealLineWidth);
                                                if (lastError < error || div->wrapStyle == kSubLineWrapBottomWider) {
                                                        rec = &records[lastIndex];
                                                        j = lastIndex;
                                                        recPos = rec->realPos - widthOffset;
                                                        charOffset = rec->originalOffset/2 + lastHardBreak;
                                                }
                                        }
                                        
                                        // try not to leave short trailing lines
                                        if ((recPos + (originalLineWidth - rec->realPos)) < maximumLineWidth) return 0;
                                                
                                        foundABreak = YES;
                                        lastBreakOffset = charOffset;
                                        ATSUSetSoftLineBreak(layout, charOffset);
                                        break;
                                }
                                
                                lastIndex = j;
                        }
                }
                
                widthOffset = records[j].realPos;
                recOffset = j;
                numBreaks--;
        } while (foundABreak && numBreaks);
                
        return (numBreaks == 0) ? 0 : lastBreakOffset;
}

static void BreakLinesEvenly(ATSUTextLayout layout, SubRenderDiv *div, TextBreakLocatorRef breakLocator, Fixed breakingWidth, unichar *utext, unsigned textLen, ItemCount numHardBreaks)
{
        UniCharArrayOffset hardBreaks[numHardBreaks+2];
        declare_bitfield(breakOpportunities, textLen);
        float fBreakingWidth = FixedToFloat(breakingWidth);
        int i;
        
        ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, numHardBreaks, &hardBreaks[1], NULL);     
        FindAllPossibleLineBreaks(breakLocator, utext, textLen, breakOpportunities);
                
        hardBreaks[0] = 0;
        hardBreaks[numHardBreaks+1] = textLen;
        
        for (i = 0; i <= numHardBreaks; i++) {
                UniCharArrayOffset thisBreak = hardBreaks[i], nextBreak = hardBreaks[i+1];
                ATSUTextMeasurement leftEdge, rightEdge, ignore;
                
                ATSUGetUnjustifiedBounds(layout, thisBreak, nextBreak - thisBreak, &leftEdge, &rightEdge, &ignore, &ignore);
                Fixed lineWidth = rightEdge - leftEdge;
                float fLineWidth = FixedToFloat(lineWidth);
                                
                if (lineWidth > breakingWidth) {
                        ATSLayoutRecord *records;
                        ItemCount numRecords;
                        unsigned idealSplitLines = ceil(fLineWidth / fBreakingWidth);
                        Fixed idealBreakWidth = FloatToFixed(fLineWidth / idealSplitLines);
                        
                        ATSUDirectGetLayoutDataArrayPtrFromTextLayout(layout, thisBreak, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, (void*)&records, &numRecords);
                                                
                        UniCharArrayOffset res = BreakOneLineSpan(layout, div, breakOpportunities, records, numRecords, idealBreakWidth, lineWidth, breakingWidth, idealSplitLines-1, thisBreak);
                        
                        ATSUDirectReleaseLayoutDataArrayPtr(NULL, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, (void*)&records);
                        
                        if (res) ATSUBatchBreakLines(layout, res, nextBreak - res, breakingWidth, NULL);
                }
        }
}

static UniCharArrayOffset *FindLineBreaks(ATSUTextLayout layout, SubRenderDiv *div, TextBreakLocatorRef breakLocator, ItemCount *nbreaks, Fixed breakingWidth, unichar *utext, unsigned textLen)
{
        UniCharArrayOffset *breaks;
        ItemCount breakCount=0;
        
        switch (div->wrapStyle) {
                case kSubLineWrapSimple:
                        ATSUBatchBreakLines(layout, kATSUFromTextBeginning, kATSUToTextEnd, breakingWidth, &breakCount);
                        break;
                case kSubLineWrapTopWider:
                case kSubLineWrapBottomWider:
                case kSubLineWrapNone:
                        SetLayoutPositioning(layout, positiveInfinity, kSubAlignmentLeft);      
                        ATSUBatchBreakLines(layout, kATSUFromTextBeginning, kATSUToTextEnd, positiveInfinity, &breakCount);
                        if (div->wrapStyle != kSubLineWrapNone) {
                                BreakLinesEvenly(layout, div, breakLocator, breakingWidth, utext, textLen, breakCount);
                                ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, 0, NULL, &breakCount);
                        }
                        SetLayoutPositioning(layout, breakingWidth, div->alignH);       
                        break;
        }
                
        breaks = malloc(sizeof(UniCharArrayOffset) * (breakCount+2));
        ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, breakCount, &breaks[1], NULL);
        
        breaks[0] = 0;
        breaks[breakCount+1] = textLen;
                
        *nbreaks = breakCount;
        return breaks;
}

typedef struct {
        UniCharArrayOffset *breaks;
        ItemCount breakCount;
        unsigned lStart, lEnd;
        SInt8 direction;
} BreakContext;

enum {kTextLayerShadow, kTextLayerOutline, kTextLayerPrimary};

static BOOL SetupCGForSpan(CGContextRef c, SubATSUISpanEx *spanEx, SubATSUISpanEx *lastSpanEx, SubRenderDiv *div, int textType, BOOL endLayer)
{       
#define if_different(x) if (!lastSpanEx || lastSpanEx-> x != spanEx-> x)
        
        switch (textType) {
                case kTextLayerShadow:
                        if_different(shadowColor) {
                                if (endLayer) CGContextEndTransparencyLayer(c);

                                SetColor(c, fillc, spanEx->shadowColor);
                                SetColor(c, strokec, spanEx->shadowColor);
                                if (CGColorGetAlpha(spanEx->shadowColor) != 1.) {
                                        endLayer = YES;
                                        CGContextBeginTransparencyLayer(c, NULL);
                                } else endLayer = NO;
                        }
                        break;
                        
                case kTextLayerOutline:
                        if_different(outlineRadius) CGContextSetLineWidth(c, spanEx->outlineRadius ? (spanEx->outlineRadius*2. + .5) : 0.);
                        if_different(outlineColor)  SetColor(c, (div->styleLine->borderStyle == kSubBorderStyleNormal) ? strokec : fillc, spanEx->outlineColor);
                        
                        if_different(outlineAlpha) {
                                if (endLayer) CGContextEndTransparencyLayer(c);
                                
                                CGContextSetAlpha(c, spanEx->outlineAlpha);
                                if (spanEx->outlineAlpha != 1.) {
                                        endLayer = YES;
                                        CGContextBeginTransparencyLayer(c, NULL);
                                } else endLayer = NO;
                        }
                                
                        break;
                case kTextLayerPrimary:
                        if_different(primaryColor) SetColor(c, fillc, spanEx->primaryColor);
                        
                        if_different(primaryAlpha) {
                                if (endLayer) CGContextEndTransparencyLayer(c);

                                CGContextSetAlpha(c, spanEx->primaryAlpha);
                                if (spanEx->primaryAlpha != 1.) {
                                        endLayer = YES;
                                        CGContextBeginTransparencyLayer(c, NULL);
                                } else endLayer = NO;
                        }
                        break;
        }
        
        return endLayer;
}

static void RenderActualLine(ATSUTextLayout layout, UniCharArrayOffset thisBreak, UniCharArrayOffset lineLen, Fixed penX, Fixed penY, CGContextRef c, SubRenderDiv *div, SubATSUISpanEx *spanEx, int textType)
{       
        if (textType == kTextLayerOutline && div->styleLine->borderStyle == kSubBorderStyleBox) {
                ATSUTextMeasurement lineWidth, lineHeight, lineX, lineY;
                UniCharArrayOffset breaks[2] = {thisBreak, thisBreak + lineLen};
                GetTypographicRectangleForLayout(layout, breaks, 0, FloatToFixed(spanEx->outlineRadius), &lineX, &lineY, &lineHeight, &lineWidth);
                
                CGRect borderRect = CGRectMake(FixedToFloat(lineX + penX), FixedToFloat(penY - lineY), FixedToFloat(lineWidth), FixedToFloat(lineHeight));
                
                ExpandCGRect(&borderRect, spanEx->outlineRadius);
                
                borderRect.origin.x = floor(borderRect.origin.x);
                borderRect.origin.y = floor(borderRect.origin.y);
                borderRect.size.width = ceil(borderRect.size.width);
                borderRect.size.height = ceil(borderRect.size.height);
                
                CGContextFillRect(c, borderRect);
        } else ATSUDrawText(layout, thisBreak, lineLen, RoundFixed(penX), RoundFixed(penY));
}

static Fixed DrawTextLines(CGContextRef c, ATSUTextLayout layout, SubRenderDiv *div, const BreakContext breakc, Fixed penX, Fixed penY, SubATSUISpanEx *firstSpanEx, int textType)
{
        int i;
        BOOL endLayer = NO;
        SubATSUISpanEx *lastSpanEx = nil;
        const CGTextDrawingMode textModes[] = {kCGTextFillStroke, kCGTextStroke, kCGTextFill};
                
        CGContextSetTextDrawingMode(c, textModes[textType]);
        
        if (!(div->render_complexity & renderMultipleParts)) endLayer = SetupCGForSpan(c, firstSpanEx, lastSpanEx, div, textType, endLayer);
        
        for (i = breakc.lStart; i != breakc.lEnd; i -= breakc.direction) {
                UniCharArrayOffset thisBreak = breakc.breaks[i], nextBreak = breakc.breaks[i+1], linelen = nextBreak - thisBreak;
                float extraHeight = 0;
                
                if (!(div->render_complexity & renderMultipleParts)) {
                        RenderActualLine(layout, thisBreak, linelen, penX, penY, c, div, firstSpanEx, textType);
                        extraHeight = div->styleLine->outlineRadius;
                } else {
                        int j, spans = [div->spans count];
                        for (j = 0; j < spans; j++) {
                                SubRenderSpan *span = [di