spliter.c.svn-base

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

    MCp=reader->MovieClipsPointer;
    while (MCp->NextP) {
        MCp=MCp->NextP;
    }
    p->Frame=MCp->frame;
    size-=reader_GetString(reader,&(p->NameP));
    for(i=0;i<size;i++) {
        if (reader->read(reader, &tmp, 1) !=1 )
            return gg_error();
    }
    dq=MCp->MovieClipP->FrameLabelListP;
    if (dq) {
        while (dq->NextP)
            dq=dq->NextP;
        dq->NextP=p;
    } else {
        MCp->MovieClipP->FrameLabelListP=p;
    }
    return 0;
}

int g_GetEnd(struct reader_t *reader) {
    struct MovieClips *MCp,*pr=NULL;
    MCp=reader->MovieClipsPointer;
    while (MCp->NextP) {
        pr=MCp;
        MCp=MCp->NextP;
    }
    if(MCp==reader->MovieClipsPointer) {
        return -1;
    } else {
        free(MCp);
        pr->NextP=NULL;
        return 0;
    }
}

int g_GetDefineSprite(struct reader_t *reader,swf_file_t *swf_p,int len) {
    UI16 id,count;
    struct MovieClip *p;
    struct MovieClips *MCp;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    if (reader->read(reader, &count, 2) !=2 )
        return gg_error();
    count=SWAP16(count);
    p=(struct MovieClip *)malloc(sizeof(struct MovieClip)+sizeof(struct Frame)*count);
    bzero((void *)p,sizeof(struct MovieClip)+sizeof(struct Frame)*count);
    g_AddToDict(swf_p,id,(struct DefineCharacter*)p);
    p->CharacterType = CharMovieClip;
    p->TotalFrames=count;
    MCp=reader->MovieClipsPointer;
    if (MCp) {
        while(MCp->NextP)
            MCp=MCp->NextP;
        MCp->NextP=(struct MovieClips *)malloc(sizeof(struct MovieClips));
        bzero((void *)MCp->NextP,sizeof(struct MovieClips));
        MCp=MCp->NextP;
        MCp->frame=0;
        MCp->MovieClipP=p;
    }
    return 0;
}

int g_GetJPEGTables(struct reader_t *reader,swf_file_t *swf_p,int len) {
    struct JPEGTable *p;
    p=(struct JPEGTable *)malloc(sizeof(struct JPEGTable)+len-1);
    p->Count=len;
    if (reader->read(reader, (void *)(p->JPEGTables), len) !=len )
        return gg_error();
    swf_p->JPEGTableP=p;
    return 0;
}

int g_GetDefineButtonSound(struct reader_t *reader,swf_file_t *swf_p,int len) {

    struct  DefineButton *p;
    UI16 id;
    UI16 Num;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    p=((struct  DefineButton *)swf_p->dict_p->dict[id]);
    if (reader->read(reader, &Num, 2) !=2 )
        return gg_error();
    p->ButtonSoundChar0=SWAP16(Num);
    if(p->ButtonSoundChar0) {
        g_GetSoundInfo(reader,0,&(p->ButtonSoundInfo0));
    }
    if (reader->read(reader, &Num, 2) !=2 )
        return gg_error();
    p->ButtonSoundChar1=SWAP16(Num);
    if(p->ButtonSoundChar1) {
        g_GetSoundInfo(reader,0,&(p->ButtonSoundInfo1));
    }
    if (reader->read(reader, &Num, 2) !=2 )
        return gg_error();
    p->ButtonSoundChar2=SWAP16(Num);
    if(p->ButtonSoundChar2) {
        g_GetSoundInfo(reader,0,&(p->ButtonSoundInfo2));
    }
    if (reader->read(reader, &Num, 2) !=2 )
        return gg_error();
    p->ButtonSoundChar3=SWAP16(Num);
    if(p->ButtonSoundChar3) {
        g_GetSoundInfo(reader,0,&(p->ButtonSoundInfo3));
    }
    return 0;
}

int g_GetSoundStreamBlock(struct reader_t *reader,int len) {
    struct SoundStreamBlock *p;
    struct MovieClips *MCp;
    MCp=reader->MovieClipsPointer;
    while(MCp->NextP)
        MCp=MCp->NextP;
    p=(struct SoundStreamBlock *)malloc(sizeof(struct SoundStreamBlock)+len-1);
    bzero((void *)p,sizeof(struct SoundStreamBlock)+len-1);
    p->Count=len;
    p->MovieClipP=MCp->MovieClipP;
    if (reader->read(reader, (void *)(p->StreamSoundData), len) !=len )
        return gg_error();
    MCp->MovieClipP->Frames[MCp->frame].SoundStreamBlockP=p;
    return 0;

}

int g_GetDefineBitsLossLess(struct reader_t *reader,swf_file_t *swf_p,int len,int type) {
    struct DefineBitsLossless2 *p;
    UI16 id;
    UI16 Num;
    UI8 format;
    UI8 size=0;
    int datacount=0;
    datacount=len-7;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    if (reader->read(reader, &format, 1) !=1 )
        return gg_error();
    if (format==3) {
        datacount-=1;
    }
    p=(struct DefineBitsLossless2 *)malloc(sizeof(struct DefineBitsLossless2)+datacount);
    bzero((void *)p,sizeof(struct DefineBitsLossless2)+datacount);
    if (reader->read(reader, &Num, 2) !=2 )
        return gg_error();
    p->BitmapWidth=SWAP16(Num);
    if (reader->read(reader, &Num, 2) !=2 )
        return gg_error();
    p->BitmapHeight=SWAP16(Num);
    if (format==3) {
        if (reader->read(reader, &size, 1) !=1 )
            return gg_error();
    }
    if (type==1) {
        p->CharacterType=(CharBitsLosslessOne);
    } else {
        p->CharacterType=(CharBitsLosslessTwo);
    }
    p->BitmapColorTableSize=size;
    p->BitmapFormat=format;
    p->ZlibBitmapDataLength=datacount;
    if (reader->read(reader, (p->ZlibBitmapData), datacount) !=datacount )
        return gg_error();
    // bmp_makebmp(p);
    return g_AddToDict(swf_p,id,(struct DefineCharacter*)p);
}

int g_GetButtonRecords(struct reader_t *reader,struct  DefineButton *p,int type) {
    struct PlaceObject *POp=NULL,*POp1=NULL;
    struct PAndRObjects* dq;
    UI8 Flags;
    UI16 Num;
    int size=reader->pos;
    while(1) {
        if (!POp) {
            POp=(struct PlaceObject *)malloc(sizeof(struct PlaceObject));
            bzero((void *)POp,sizeof(struct PlaceObject));
        }
        if (reader->read(reader, &Flags, 1) !=1 )
            return gg_error();
        if (!Flags) {
            size-=reader->pos;
            free(POp);
            return size;
        }
        if (reader->read(reader, &Num, 2) !=2 )
            return gg_error();
        POp->CharacterID=SWAP16(Num);
        POp->PlaceAndRemoveType=TPlaceObjectTwo;
        if (reader->read(reader, &Num, 2) !=2 )
            return gg_error();
        POp->Depth=SWAP16(Num);
        reader_GetMatrix(reader,&(POp->Matrix));
        if (type==2) {
            reader_GetCxFromWithAlpha(reader,&(POp->ColorTransform));
        }
        if ((Flags&(BtnStateUp))==(BtnStateUp)) {
            POp1=(struct PlaceObject *)malloc(sizeof(struct PlaceObject));
            bzero((void *)POp1,sizeof(struct PlaceObject));
            memcpy((void *)POp1,(void *)POp,sizeof(struct PlaceObject));
            dq=(struct PAndRObjects*)p->StateUpP;
            if(dq) {
                while(dq->NextP)
                    dq=dq->NextP;
                dq->NextP=(struct PAndRObjects*)POp1;
            } else {
                p->StateUpP=POp1;
            }
        }
        if ((Flags&(BtnStateOver))==(BtnStateOver)) {
            POp1=(struct PlaceObject *)malloc(sizeof(struct PlaceObject));
            bzero((void *)POp1,sizeof(struct PlaceObject));
            memcpy((void *)POp1,(void *)POp,sizeof(struct PlaceObject));
            dq=(struct PAndRObjects*)p->StateOverP;
            if(dq) {
                while(dq->NextP)
                    dq=dq->NextP;
                dq->NextP=(struct PAndRObjects*)POp1;
            } else {
                p->StateOverP=POp1;
            }
        }
        if ((Flags&(BtnStateDown))==(BtnStateDown)) {
            POp1=(struct PlaceObject *)malloc(sizeof(struct PlaceObject));
            bzero((void *)POp1,sizeof(struct PlaceObject));
            memcpy((void *)POp1,(void *)POp,sizeof(struct PlaceObject));
            dq=(struct PAndRObjects*)p->StateDownP;
            if(dq) {
                while(dq->NextP)
                    dq=dq->NextP;
                dq->NextP=(struct PAndRObjects*)POp1;
            } else {
                p->StateDownP=POp1;
            }
        }
        if ((Flags&(BtnStateHitTest))==(BtnStateHitTest)) {
            POp1=(struct PlaceObject *)malloc(sizeof(struct PlaceObject));
            bzero((void *)POp1,sizeof(struct PlaceObject));
            memcpy((void *)POp1,(void *)POp,sizeof(struct PlaceObject));
            dq=(struct PAndRObjects*)p->StateHitTestP;
            if(dq) {
                while(dq->NextP)
                    dq=dq->NextP;
                dq->NextP=(struct PAndRObjects*)POp1;
            } else {
                p->StateHitTestP=POp1;
            }
        }
    }
}

int g_GetDefineButton(struct reader_t *reader,swf_file_t *swf_p,int len) {
    struct  DefineButton *p;
    UI16 id;
    int actionsize;
    p=malloc(sizeof(struct  DefineButton));
    bzero((void *)p,sizeof(struct  DefineButton));
    p->CharacterType=CharButton;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    p->ButtonID=id;
    actionsize=len-2;
    actionsize-=g_GetButtonRecords(reader,p,1);
    reader_GetActionRecord(reader,actionsize,&(p->CondOverDownToOverUpP));
    return g_AddToDict(swf_p,id,(struct DefineCharacter*)p);
}

int g_GetDefineButton2(struct reader_t *reader,swf_file_t *swf_p,int len) {
    struct  DefineButton *p;
    struct ActionRecord *ARp;
    UI16 id;
    UI16 ActionOffset;
    UI16 CondActionSize;
    UI8 Flags1,Flags2,keycode;
    int tagsize;
    int endactionsize;
    tagsize=len;
    endactionsize=tagsize-3;
    p=malloc(sizeof(struct  DefineButton));
    bzero((void *)p,sizeof(struct  DefineButton));
    p->CharacterType=CharButton;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    p->ButtonID=id;
    if (reader->read(reader, &(p->Flags), 1) !=1 )
        return gg_error();
    if (reader->read(reader, &ActionOffset, 2) !=2 )
        return gg_error();
    ActionOffset=SWAP16(ActionOffset);
    endactionsize-=ActionOffset;
    g_GetButtonRecords(reader,p,2);
    if (ActionOffset) {
        CondActionSize=ActionOffset;
        while(CondActionSize) {
            if (reader->read(reader, &CondActionSize, 2) !=2 )
                return gg_error();
            CondActionSize=SWAP16(CondActionSize);
            if (reader->read(reader, &Flags1, 1) !=1 )
                return gg_error();
            if (reader->read(reader, &Flags2, 1) !=1 )
                return gg_error();
            keycode=(Flags2>>1);
            ARp=NULL;
            if (CondActionSize) {
                endactionsize-=CondActionSize;
                reader_GetActionRecord(reader,(CondActionSize-4),&(ARp));
            } else {
                reader_GetActionRecord(reader,(endactionsize-4),&(ARp));
            }
            if((Flags1&(TCondIdleToOverDown))) {
                reader_AddActionRecord(&p->CondIdleToOverDownP,ARp);
            }
            if((Flags1&(TCondOutDownToIdle))) {
                reader_AddActionRecord(&p->CondOutDownToIdleP,ARp);
            }
            if((Flags1&(TCondOutDownToOverDown))) {
                reader_AddActionRecord(&p->CondOutDownToOverDownP,ARp);
            }
            if((Flags1&(TCondOverDownToOutDown))) {
                reader_AddActionRecord(&p->CondOverDownToOutDownP,ARp);
            }
            if((Flags1&(TCondOverDownToOverUp))) {
                reader_AddActionRecord(&p->CondOverDownToOverUpP,ARp);
            }
            if((Flags1&(TCondOverUpToOverDown))) {
                reader_AddActionRecord(&p->CondOverUpToOverDownP,ARp);
            }
            if((Flags1&(TCondOverUpToIdle))) {
                reader_AddActionRecord(&p->CondOverUpToIdleP,ARp);
            }
            if((Flags1&(TCondIdleToOverUp))) {
                reader_AddActionRecord(&p->CondIdleToOverUpP,ARp);
            }
            if(keycode) {
                reader_AddActionRecord(&p->CondKeyPressP[keycode],ARp);
            }
            if(Flags2&0x1) {
                reader_AddActionRecord(&p->CondOverDownToIdleP,ARp);
            }
        }

    }
    return g_AddToDict(swf_p,id,(struct DefineCharacter*)p);
}

int g_GetDefineButtonCxform(struct reader_t *reader,swf_file_t *swf_p,int len) {
    struct CxFormWithAlpha* p;
    UI16 id;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    p=&(((struct  DefineButton *)swf_p->dict_p->dict[id])->ColorTransform);
    reader_GetCxFrom(reader,p);
    return 0;
}

int g_GetDefineFont(struct reader_t *reader,swf_file_t *swf_p,int len) {
    struct  DefineFont *p;
    UI16 id;
    UI16 offset;
    int count=0,i,tmpint;
    if (reader->read(reader, &id, 2) !=2 )
        return gg_error();
    id=SWAP16(id);
    if (reader->read(reader, &offset, 2) !=2 )
        return gg_error();
    offset=SWAP16(offset);
    count=offset/2;
    p=(struct DefineFont *)malloc(sizeof(struct DefineFont)+(count-1)*sizeof(struct GlyphShape));
    bzero((void *)p,sizeof(struct DefineFont)+(count-1)*sizeof(struct GlyphShape));
    p->CharacterType=CharFontOne;
    p->NumGlyphs=count;
    for (i=1;i<count;i++) {
        if (reader->read(reader, &offset, 2) !=2 )
            return gg_error();