morphing_ins.c.svn-base

A Flash Player with ActionScript support. Write in C and C++. It have two part, one is Player and an

#include <math.h>
#include <stdio.h>
#include <assert.h>
#include "config.h"
#include "base_types.h"
#include "define.h"
#include "movie_clips_def.h"
#include "swf_file_pub.h"
#include "morphing_ins.h"
#include "morphing_def.h"
#include <stdlib.h>
#include <glib.h>
#if WITH_DMALLOC
#include <dmalloc.h>
#endif

//#define PRINT_LOG
//#define PRINT_DG

//get Current RGBA
int CurrRGBA(GNode* node_p,struct RGBA *Start,struct RGBA *End,struct RGBA *Curr) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);
    Curr->Red	=	Start->Red+(End->Red-Start->Red)*data_p->ratio/65535;
    Curr->Green	=	Start->Green+(End->Green-Start->Green)*data_p->ratio/65535;
    Curr->Blue	=	Start->Blue+(End->Blue-Start->Blue)*data_p->ratio/65535;
    Curr->Alpha	=	Start->Alpha+(End->Alpha-Start->Alpha)*data_p->ratio/65535;
    Curr->pixel	=	Start->pixel+(End->pixel-Start->pixel)*data_p->ratio/65535;
    return 0;
}
//get Current Matrix
int CurrMatrix(GNode* node_p,struct Matrix *Start,struct Matrix *End,struct Matrix *Curr) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);
    Curr->HasScale = Start->HasScale;
    Curr->HasRotate = Start->HasRotate;

    Curr->ScaleX	=	Start->ScaleX+(End->ScaleX-Start->ScaleX)*data_p->ratio/65535;
    Curr->ScaleY	=	Start->ScaleY+(End->ScaleY-Start->ScaleY)*data_p->ratio/65535;
    Curr->RotateSkew0	=	Start->RotateSkew0+(End->RotateSkew0-Start->RotateSkew0)*data_p->ratio/65535;
    Curr->RotateSkew1	=	Start->RotateSkew1+(End->RotateSkew1-Start->RotateSkew1)*data_p->ratio/65535;
    Curr->TranslateX	=	Start->TranslateX+(End->TranslateX-Start->TranslateX)*data_p->ratio/65535;
    Curr->TranslateY	=	Start->TranslateY+(End->TranslateY-Start->TranslateY)*data_p->ratio/65535;
    return 0;
}
//get Current MorphGradRecord
int CurrGradient(GNode* node_p,struct MorphGradRecord *Morph,struct Gradient **Curr) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);
    struct MorphGradRecord *tmpMorph;
    struct Gradient *Grad;
    int i = 0;

    tmpMorph = Morph;
    while(tmpMorph) {
        tmpMorph = tmpMorph->NextP;
        i++;
    }
    if(i==0) {
        Grad=(struct Gradient *)malloc(sizeof(struct Gradient)+(sizeof(struct GradRecord)*i));
        bzero((void *)(Grad),sizeof(struct Gradient)+(sizeof(struct GradRecord)*i));
    } else {
        Grad=(struct Gradient *)malloc(sizeof(struct Gradient)+(sizeof(struct GradRecord)*(i-1)));
        bzero((void *)(Grad),sizeof(struct Gradient)+(sizeof(struct GradRecord)*(i-1)));
    }
    assert(Grad != NULL);
    Grad->NumGradients = i;
    i = 0;
    while(Morph) {
        Grad->GradientRecords[i].Ratio = Morph->StartRatio+(Morph->EndRatio-Morph->StartRatio)*data_p->ratio/65535;
        CurrRGBA(node_p,&Morph->StartColor,&Morph->EndColor,&(Grad->GradientRecords[i].Color));
        Morph = Morph->NextP;
        i++;
    }

    *Curr = Grad;
    return 0;
}

//get Current FillStyle
int CurrFillStyle(GNode* node_p,struct MorphFillStyle *Morph,struct FillStyle *Curr) {
    Curr->FillStyleType = Morph->FillStyleType;
    //RGBA Morph
    CurrRGBA(node_p,&Morph->StartColor,&Morph->EndColor,&Curr->Color);
    //GradientMatrix Morph
    CurrMatrix(node_p,&Morph->StartGradientMatrix,&Morph->EndGradientMatrix,&Curr->GradientMatrix);
    //MorphGradRecord morph
    CurrGradient(node_p,Morph->GradientP,&Curr->GradientP);
    Curr->BitmapId = Morph->BitmapId;
    //BitmapMatrix morph
    CurrMatrix(node_p,&Morph->StartBitmapMatrix,&Morph->EndBitmapMatrix,&Curr->BitmapMatrix);

    return 0;
}
//deal with MorphFillStyleArray morhp
int CurrFillArray(GNode* node_p,struct MorphFillStyleArray *Morph,struct FillStyleArray **Curr) {
    int i;
    struct FillStyleArray *tmpFill;
    if(Morph->count==0) {
        tmpFill=(struct FillStyleArray*)malloc(sizeof(struct FillStyleArray)+sizeof(struct FillStyle)*(Morph->count));
        bzero((void *)(tmpFill),(sizeof(struct FillStyleArray)+sizeof(struct FillStyle)*(Morph->count)));
    } else {
        tmpFill=(struct FillStyleArray*)malloc(sizeof(struct FillStyleArray)+sizeof(struct FillStyle)*(Morph->count-1));
        bzero((void *)(tmpFill),(sizeof(struct FillStyleArray)+sizeof(struct FillStyle)*(Morph->count-1)));
    }
    assert(tmpFill != NULL);
    for(i=0;i<Morph->count;i++) {
        CurrFillStyle(node_p,&Morph->MorphFillStyles[i],&tmpFill->FillStyles[i]);
    }
    tmpFill->count = Morph->count ;
    *Curr = tmpFill;
    return 0;
}
//deal with MorphLineStyle morph
int CurrLineStyle(GNode* node_p,struct MorphLineStyle *Morph,struct LineStyle *Curr) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    Curr->Width	=	Morph->StartWidth+(Morph->EndWidth-Morph->StartWidth)*data_p->ratio/65535;
    //RGBA morph
    CurrRGBA(node_p,&Morph->StartColor,&Morph->EndColor,&Curr->ColorRGB);

    return 0;
}
//deal with MorphLineStyleArray morph
int CurrLineArray(GNode* node_p,struct MorphLineStyleArray *Morph,struct LineStyleArray **Curr) {
    int i;
    struct LineStyleArray *tmpFill;
    if(Morph->count==0) {
        tmpFill=(struct LineStyleArray*)malloc(sizeof(struct LineStyleArray)+sizeof(struct LineStyle)*(Morph->count));
        bzero((void *)(tmpFill),(sizeof(struct LineStyleArray)+sizeof(struct LineStyle)*(Morph->count)));
    } else {
        tmpFill=(struct LineStyleArray*)malloc(sizeof(struct LineStyleArray)+sizeof(struct LineStyle)*(Morph->count-1));
        bzero((void *)(tmpFill),(sizeof(struct LineStyleArray)+sizeof(struct LineStyle)*(Morph->count-1)));
    }
    assert(tmpFill != NULL);
    for(i=0;i<Morph->count;i++) {
        CurrLineStyle(node_p,&Morph->MorphLineStyles[i],&tmpFill->LineStyles[i]);
    }
    tmpFill->count = Morph->count ;
    *Curr = tmpFill;
    return 0;
}

//deal with StyleChangeRecord
int StartToCurrent(GNode* node_p,struct StyleChangeRecord* StartRed,struct StyleChangeRecord* EndRed,struct StyleChangeRecord* outRed) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    outRed->MoveDeltaX = StartRed->MoveDeltaX + (EndRed->MoveDeltaX-StartRed->MoveDeltaX)*data_p->ratio/65535;
    outRed->MoveDeltaY = StartRed->MoveDeltaY + (EndRed->MoveDeltaY-StartRed->MoveDeltaY)*data_p->ratio/65535;

    return 0;
}
//curved morph
int CurvedToCurved(GNode* node_p,struct CurvedEdgeRecord* SCurRed,struct CurvedEdgeRecord* ECurRed,struct CurvedEdgeRecord* outCurRed) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    outCurRed->ControlDeltaX = SCurRed->ControlDeltaX +(ECurRed->ControlDeltaX-SCurRed->ControlDeltaX)*data_p->ratio/65535;
    outCurRed->ControlDeltaY = SCurRed->ControlDeltaY +(ECurRed->ControlDeltaY-SCurRed->ControlDeltaY)*data_p->ratio/65535;
    outCurRed->AnchorDeltaX = SCurRed->AnchorDeltaX +(ECurRed->AnchorDeltaX-SCurRed->AnchorDeltaX)*data_p->ratio/65535;
    outCurRed->AnchorDeltaY = SCurRed->AnchorDeltaY +(ECurRed->AnchorDeltaY-SCurRed->AnchorDeltaY)*data_p->ratio/65535;

    return 0;
}

//Straight morph
int StraightToStraight(GNode* node_p,struct StraightEdgeRecord* SRed,struct StraightEdgeRecord* ERed,struct StraightEdgeRecord* outRed) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    if(SRed->StraightLineFlag) {
        if(ERed->StraightLineFlag) {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = SRed->StraightLineDeltaX +(ERed->StraightLineDeltaX-SRed->StraightLineDeltaX)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = SRed->StraightLineDeltaY +(ERed->StraightLineDeltaY-SRed->StraightLineDeltaY)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        } else if(ERed->VertLineFlag) {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = SRed->StraightLineDeltaX +(0-SRed->StraightLineDeltaX)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = SRed->StraightLineDeltaY +(ERed->VertLineDeltaY-SRed->StraightLineDeltaY)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        } else {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = SRed->StraightLineDeltaX +(ERed->HorLineDeltaX-SRed->StraightLineDeltaX)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = SRed->StraightLineDeltaY +(0-SRed->StraightLineDeltaY)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        }
    } else if(SRed->VertLineFlag) {
        if(ERed->StraightLineFlag) {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = 0 +(ERed->StraightLineDeltaX-0)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = SRed->VertLineDeltaY +(ERed->StraightLineDeltaY-SRed->VertLineDeltaY)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        } else if(ERed->VertLineFlag) {
            outRed->StraightLineFlag = 0;
            outRed->StraightLineDeltaX = 0;
            outRed->StraightLineDeltaY = 0;
            outRed->VertLineFlag = 1;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = SRed->VertLineDeltaY +(ERed->VertLineDeltaY-SRed->VertLineDeltaY)*data_p->ratio/65535;
        } else {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = 0 +(ERed->HorLineDeltaX-0)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = SRed->VertLineDeltaY +(0-SRed->VertLineDeltaY)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        }
    } else {
        if(ERed->StraightLineFlag) {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = SRed->HorLineDeltaX +(ERed->StraightLineDeltaX-SRed->HorLineDeltaX)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = 0 +(ERed->StraightLineDeltaY-0)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        } else if(ERed->VertLineFlag) {
            outRed->StraightLineFlag = 1;
            outRed->StraightLineDeltaX = SRed->HorLineDeltaX +(0-SRed->HorLineDeltaX)*data_p->ratio/65535;
            outRed->StraightLineDeltaY = 0+(ERed->VertLineDeltaY-0)*data_p->ratio/65535;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = 0;
            outRed->VertLineDeltaY = 0;
        } else {
            outRed->StraightLineFlag = 0;
            outRed->StraightLineDeltaX = 0;
            outRed->StraightLineDeltaY =0;
            outRed->VertLineFlag = 0;
            outRed->HorLineDeltaX = SRed->HorLineDeltaX +(ERed->HorLineDeltaX-SRed->HorLineDeltaX)*data_p->ratio/65535;
            outRed->VertLineDeltaY = 0;
        }
    }

    return 0;
}

//verify the straight to curved
int VerifyStraight(GNode* node_p,struct StraightEdgeRecord* StrRed,struct CurvedEdgeRecord* EndRed,struct CurvedEdgeRecord* CurRed) {
    double pf;
    double a,b,c,d;
    a = (EndRed->ControlDeltaX)*(EndRed->ControlDeltaX);
    b = (EndRed->ControlDeltaY)*(EndRed->ControlDeltaY);
    c = (EndRed->AnchorDeltaX-EndRed->ControlDeltaX)*(EndRed->AnchorDeltaX-EndRed->ControlDeltaX);
    d = (EndRed->AnchorDeltaY-EndRed->ControlDeltaY)*(EndRed->AnchorDeltaY-EndRed->ControlDeltaY);
    pf = sqrt(a+b)/(sqrt(a+b)+sqrt(c+d));

    if(StrRed->StraightLineFlag) {
        CurRed->ControlDeltaX = (StrRed->StraightLineDeltaX)*pf;
        CurRed->ControlDeltaY = (StrRed->StraightLineDeltaY)*pf;
        CurRed->AnchorDeltaX = StrRed->StraightLineDeltaX - CurRed->ControlDeltaX;
        CurRed->AnchorDeltaY = StrRed->StraightLineDeltaY - CurRed->ControlDeltaY;
    } else if(StrRed->VertLineFlag) {
        CurRed->ControlDeltaX = 0;
        CurRed->ControlDeltaY = (StrRed->VertLineDeltaY)*pf;
        CurRed->AnchorDeltaX = 0;
        CurRed->AnchorDeltaY = StrRed->VertLineDeltaY - CurRed->ControlDeltaY;
    } else {
        CurRed->ControlDeltaX = (StrRed->HorLineDeltaX)*pf;
        CurRed->ControlDeltaY = 0;
        CurRed->AnchorDeltaX = StrRed->HorLineDeltaX - CurRed->ControlDeltaX;
        CurRed->AnchorDeltaY = 0;
    }
    return 0;
}

//change straight to curved
int StraightToCurved(struct StraightEdgeRecord* StrRed,struct CurvedEdgeRecord* CurRed) {

    if(StrRed->StraightLineFlag) {
        CurRed->ControlDeltaX = StrRed->StraightLineDeltaX/2;
        CurRed->ControlDeltaY = StrRed->StraightLineDeltaY/2;
        CurRed->AnchorDeltaX = StrRed->StraightLineDeltaX/2;
        CurRed->AnchorDeltaY = StrRed->StraightLineDeltaY/2;
    } else if(StrRed->VertLineFlag) {
        CurRed->ControlDeltaX = 0;
        CurRed->ControlDeltaY = StrRed->VertLineDeltaY/2;
        CurRed->AnchorDeltaX = 0;
        CurRed->AnchorDeltaY = StrRed->VertLineDeltaY/2;
    } else {
        CurRed->ControlDeltaX = StrRed->HorLineDeltaX/2;
        CurRed->ControlDeltaY = 0;
        CurRed->AnchorDeltaX = StrRed->HorLineDeltaX/2;
        CurRed->AnchorDeltaY = 0;
    }

    return 0;
}

//get current RECT Bounds
int CurrBounds(GNode* node_p,struct RECT StartBounds,struct RECT EndBounds,struct RECT *Curr) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);

    Curr->Xmin=StartBounds.Xmin+(EndBounds.Xmin-StartBounds.Xmin)*data_p->ratio/65535;
    Curr->Xmax=StartBounds.Xmax+(EndBounds.Xmax-StartBounds.Xmax)*data_p->ratio/65535;
    Curr->Ymin=StartBounds.Ymin+(EndBounds.Ymin-StartBounds.Ymin)*data_p->ratio/65535;
    Curr->Ymax=StartBounds.Ymax+(EndBounds.Ymax-StartBounds.Ymax)*data_p->ratio/65535;

    return 0;
}

//deal with Shape morph
int GetShapePos(GNode* node_p,struct ShapeRecord* StartRed,struct ShapeRecord* EndRed,struct ShapeRecord** outCurRed) {
    mrp_ins_t	*data_p = (mrp_ins_t*)(node_p->data);
    struct ShapeRecord* tmpCurRed;
    struct StraightEdgeRecord* StartStraightRecord = NULL;
    struct CurvedEdgeRecord* StartCurvedRecord;
    struct StyleChangeRecord* StartSChangeRecord;

    struct StraightEdgeRecord* EndStraightRecord = NULL;
    struct CurvedEdgeRecord* EndCurvedRecord;
    struct StyleChangeRecord* EndSChangeRecord;

    struct StraightEdgeRecord* outStraightRecord;
    struct CurvedEdgeRecord* outCurvedRecord;
    struct StyleChangeRecord* outSChangeRecord;
#ifdef PRINT_DG

    printf("flash: loading GetShapePos Start---\n");
#endif
    //judge shape
    if(StartRed->Flags&128) {
        //start record
        if(StartRed->Flags&64) {
            //straight record
            StartCurvedRecord = (struct CurvedEdgeRecord*)malloc(sizeof(struct CurvedEdgeRecord));
            assert(StartCurvedRecord != NULL) ;
            bzero((void *)(StartCurvedRecord),sizeof(struct CurvedEdgeRecord));
            StartStraightRecord = (struct StraightEdgeRecord*)StartRed;
            if(EndRed->Flags&64) {
                data_p->isStraight = 0;
                StraightToCurved(StartStraightRecord,StartCurvedRecord);
            } else {
                data_p->isStraight = 0;
                EndCurvedRecord = (struct CurvedEdgeRecord*)EndRed;
                VerifyStraight(node_p,StartStraightRecord,EndCurvedRecord,StartCurvedRecord);
            }
        } else {
            //curved record
            data_p->isStraight = 0;
            StartCurvedRecord = (struct CurvedEdgeRecord*)StartRed;
        }

        //end record
        if(EndRed->Flags&64) {
            //straight record