您的位置:首页 > 其它

解析swf文件的音频数据并生成mp3

2008-10-23 18:37 295 查看
#pragma once
#include <memory>
#include <Shlwapi.h>
#pragma comment(lib,"Shlwapi.lib")

#include <tchar.h>
#include <strsafe.h>

typedef unsigned char UI8;
typedef unsigned short UI16;
typedef unsigned char UB;
typedef unsigned int UI32;
typedef unsigned char byte;
//File mp3File;

#define SWFHEADSIZE 8
enum TagType
{
/// <summary>Unknown tag</summary>
Unknown = -1,
/// <summary>End tag</summary>
End = 0,
/// <summary>ShowFrame tag</summary>
ShowFrame = 1,
/// <summary>DefineShape tag</summary>
DefineShape = 2,
/// <summary>PlaceObject tag</summary>
PlaceObject = 3,
/// <summary>RemoveObject tag</summary>
RemoveObject = 4,
/// <summary>DefineBits tag</summary>
DefineBits = 6,
/// <summary>DefineButton tag</summary>
DefineButton = 7,
/// <summary>JPEGTable tag</summary>
JpegTable = 8,
/// <summary>SetBackgroundColor tag</summary>
SetBackgroundColor = 9,
/// <summary>DefineFont tag</summary>
DefineFont = 10,
/// <summary>DefineText tag</summary>
DefineText = 11,
/// <summary>DoAction tag</summary>
DoAction = 12,
/// <summary>DefineFontInfo tag</summary>
DefineFontInfo = 13,
/// <summary>DefineSound tag</summary>
DefineSound = 14,
/// <summary>StartSound tag</summary>
StartSound = 15,
/// <summary>DefineButtonSound tag</summary>
DefineButtonSound = 17,
/// <summary>SoundStreamHead tag</summary>
SoundStreamHead = 18,
/// <summary>SoundStreamBlock tag</summary>
SoundStreamBlock = 19,
/// <summary>DefineBitsLossLess tag</summary>
DefineBitsLossLess = 20,
/// <summary>DefineBitsJPEG2 tag</summary>
DefineBitsJpeg2 = 21,
/// <summary>DefineShape2 tag</summary>
DefineShape2 = 22,
/// <summary>DefineButtonCxForm tag</summary>
DefineButtonCxForm = 23,
/// <summary>Protect tag</summary>
Protect = 24,
/// <summary>PlaceObject2 tag</summary>
PlaceObject2 = 26,
/// <summary>RemoveObject2 tag</summary>
RemoveObject2 = 28,
/// <summary>DefineShape3 tag</summary>
DefineShape3 = 32,
/// <summary>DefineText2 tag</summary>
DefineText2 = 33,
/// <summary>DefineButton2 tag</summary>
DefineButton2 = 34,
/// <summary>DefineBitsJPEG3 tag</summary>
DefineBitsJpeg3 = 35,
/// <summary>DefineBitsLossLess2 tag</summary>
DefineBitsLossLess2 = 36,
/// <summary>DefineEditText tag</summary>
DefineEditText = 37,
/// <summary>DefineSprite tag</summary>
DefineSprite = 39,
/// <summary>FrameLabel tag</summary>
FrameLabel = 43,
/// <summary>SoundStreamHead2 tag</summary>
SoundStreamHead2 = 45,
/// <summary>DefineMorphShape tag</summary>
DefineMorphShape = 46,
/// <summary>DefineFont2 tag</summary>
DefineFont2 = 48,
/// <summary>ExportAssets tag</summary>
ExportAssets = 56,
/// <summary>ImportAssets tag</summary>
ImportAssets = 57,
/// <summary>EnableDebugger tag</summary>
EnableDebugger = 58,
/// <summary>InitAction tag</summary>
InitAction = 59,
/// <summary>DefineVideoStream tag</summary>
DefineVideoStream = 60,
/// <summary>VideoFrame tag</summary>
VideoFrame = 61,
/// <summary>DefineFontInfo2 tag</summary>
DefineFontInfo2 = 62,
/// <summary>EnableDebugger2 tag</summary>
EnableDebugger2 = 64,
/// <summary>ScriptLimit tag</summary>
ScriptLimit = 65,
/// <summary>SetTabIndex tag</summary>
SetTabIndex = 66
};

struct RGB
{
UI8 red;
UI8 green;
UI8 blue;
};
struct RGBA
{
UI8 red;
UI8 green;
UI8 blue;
UI8 alpha;
};
struct varRECT
{
/************************************************************************/
/* The FrameSize field defines the width and height of the on-screen display. This field is stored
as a RECT structure, meaning that its size may vary according to the number of bits needed
to encode the coordinates. */
/************************************************************************/
private:
unsigned __int64 padA;
unsigned __int64 padB;
public:
int GetNbits()
{
return (padA>>3)&0x0000001F;
}
int GetRectBytesCount()
{
int Nbits = GetNbits();
return (5+Nbits*4)/8+1;
}
//取一个字节的某几个字节,要从左边开始取
void GetRect(RECT& rt)
{

unsigned char buf[16];
memcpy(buf,&padA,8);
memcpy(buf+8,&padB,8);

int nByteIndex = 0;
int nLeaveBits = 0;
nLeaveBits = 3;
int Nbits = buf[nByteIndex]>>nLeaveBits;

int Xmin = 0;
int size[4]={0,0,0,0};
for (int n=0;n<4;n++)
{
int nFillBits = 0;
while (nFillBits<Nbits)
{
if (nLeaveBits>0)
{
if (nLeaveBits<Nbits-nFillBits)
{
//取buf[nByteIndex]的剩下nLeaveBits位
int andMode = 0;
for (int i=0;i<nLeaveBits;i++)
{
andMode |= 0x01<<i;
}
size
|= (andMode&buf[nByteIndex])<<(Nbits-nFillBits-nLeaveBits);

nFillBits += nLeaveBits;
nLeaveBits = 0;
}
else
{
//取buf[nByteIndex]的剩下Nbits-nFillBits位
int andMode = 0;
int nNeedBits = Nbits - nFillBits;
for (int i=0;i<nLeaveBits;i++)
{
if (i<nLeaveBits-nNeedBits)
continue;
andMode |= 0x01<<i;
}
nLeaveBits -= Nbits-nFillBits;
size
|= (andMode&buf[nByteIndex])>>nLeaveBits;

nFillBits += Nbits-nFillBits;
}

}
else
{
//上一个字节填充完了,指向下一个字节
nByteIndex++;
nLeaveBits = 8;
}
}
}

//如果符号位为1,则转换数字
int mode = 0x01<<(Nbits-1);
int andmode = 0;
for (int i=0;i<Nbits;i++)
{
andmode |= 0x01<<i;
}
andmode ^= 0xFFFFFFFF;
for(int i=0;i<4;i++)
{
if (size[i]&mode)
{
size[i] |= andmode;
}
}
rt.left = size[0];
rt.right = size[1];
rt.top = size[2];
rt.bottom = size[3];
return ;
}
};

struct SwfFrameRate
{
private:
unsigned short data;
public:
float GetFrameRate()
{
unsigned char decimal = data&0xFF;
float fDecimal = 0.0f;
fDecimal+=(data>>8);
for(int i=0;i<8;i++)
{
fDecimal += ((decimal&(0x80>>i))>>(7-i))*(1.0f/(2<<i));
}
return fDecimal;
}
};
struct SwfFileHeader
{
/************************************************************************/
/* An FWS signature indicates an uncompressed SWF file; CWS
indicates that the entire file after the first 8 bytes (that is, after the FileLength field) was
compressed by using the ZLIB open standard. */
/************************************************************************/
unsigned char Sigcompressed;
unsigned char SigW;
unsigned char SigS;
unsigned char Version;
/************************************************************************/
/* If this is an uncompressed SWF file (FWS signature), the FileLength field should exactly match the file
size. If this is a compressed SWF file (CWS signature), the FileLength field indicates the total
length of the file after decompression, and thus generally does not match the file size. */
/************************************************************************/
unsigned int FileLenth;
};
struct tagHeader
{
private:
unsigned short TagCodeAndLength;
unsigned short lowLength;
unsigned short HighLength;

public:
int GetType()
{
return TagCodeAndLength>>6;
}
//The length specified in the TagCodeAndLength field does not include the
//RECORDHEADER that starts a tag.
int GetLength()
{
int len = TagCodeAndLength&0x003F;
return len;
}
int GetLengthEx()
{
signed long Length=0;
Length |= lowLength;
unsigned long high = HighLength;
high=high<<16;
Length |= high;
return Length;
}
};

struct tagSoundStreamHead2
{
unsigned char PlaybackSoundType:1;
unsigned char PlaybackSoundSize:1;
unsigned char PlaybackSoundRate:2;
unsigned char Reserved:4;

unsigned char StreamSoundType:1;
unsigned char StreamSoundSize:1;
unsigned char StreamSoundRate:2;
unsigned char StreamSoundCompression:4;

unsigned short StreamSoundSampleCount;
short LatencySeek;
};
struct tagFrameLabel
{
};
struct MATRIX
{
};
struct GRADIENT
{
};
struct FOCALGRADIENT
{
};
struct FILLSTYLE
{
UI8 FillStyleType;
union
{
RGBA ColorA;
RGB Color;
};
union
{
struct
{
MATRIX GradientMatrix;
GRADIENT Gradient;
};
FOCALGRADIENT FocalGradient;
struct
{
UI16 BitmapId;
MATRIX BitmapMatrix;
};

};

};
struct FILLSTYLEARRAY
{
UI8 FillStyleCount;
union
{
struct
{
UI16 FillStyleCountExtended;
FILLSTYLE *FillStylesEx;
};
FILLSTYLE *FillStyles;

};

};
struct LINESTYLE
{
};
struct LINESTYLE2
{
};
struct LINESTYLEARRAY
{
UI8 LineStyleCount;// Count of line styles.
union
{
struct
{
UI16 LineStyleCountExtended; //If LineStyleCount = 0xFF Extended count of line styles.
union
{
LINESTYLE *LineStylesEx;// (if Shape1,Shape2, or Shape3)
LINESTYLE2 *LineStyles2Ex;// (if Shape4)
};
};
union
{
LINESTYLE *LineStyles;// (if Shape1,Shape2, or Shape3)
LINESTYLE2 *LineStyles2;// (if Shape4)
};
};
};
struct SHAPERECORD
{
};
struct SHAPEWITHSTYLE
{
LINESTYLEARRAY FillStyles;//Array of fill styles.
LINESTYLEARRAY LineStyles;//Array of line styles.
unsigned char Number:4;// Number of fill index bits.
unsigned char NumLineBits:4;//Number of line index bits.
SHAPERECORD ShapeRecords;// Shape records
};
/************************************************************************/
/* Generally speaking, tags in a SWF can occur in any order. */
/************************************************************************/
/************************************************************************/
/* Following the header is a series of tagged data blocks. All tags share a common format, so any
program parsing a SWF file can skip over blocks it does not understand. */
/************************************************************************/
struct BaseTag
{
};
struct tagDefineSound
{
UI16 SoundId;
UB SoundType:1;
UB SoundSize:1;
UB SoundRate:2;
UB SoundFormat:4;
UI32 SoundSampleCount;
byte *SoundData;

};
struct FrameHeader
{
unsigned char sync1:8; //同步信息1 0xFF

unsigned char crc:1; //CRC校验 0x01/0x00
unsigned char layer:2; //层 0x01
unsigned char version:2; //版本 0x03
unsigned char sync2:3; //同步信息2 0x07

unsigned char privatebit:1; //私有bit,可以用来做特殊应用 0x00
unsigned char padding:1; //填充空白字 0x00/0x01
unsigned char sample_rate_index:2; //采样率索引 0x00
unsigned char bit_rate_index:4; //位率索引 0x0A

unsigned char emphasis:2; //强调方式 0x00
unsigned char original:1; //原始媒体 0x01
unsigned char copyright:1; //版权标志 0x00
unsigned char mode_extension:2; //扩展模式,仅用于联合立体声 0x00
unsigned char channel_mode:2; //声道模式 0x00
};

struct MP3SOUNDDATA
{
short SeekSamples;
FrameHeader mp3FrameHead;
};

struct tagPlaceObject
{
UI16 CharacterId;
UI16 Depth;
MATRIX matrix;
};

struct tagPlaceObject2
{
UB PlaceFlagMove:1;
UB PlaceFlagHasCharacter:1;
UB PlaceFlagHasMatrix:1;
UB PlaceFlagHasColorTransform:1;
UB PlaceFlagHasRatio:1;
UB PlaceFlagHasName:1;
UB PlaceFlagHasClipDepth:1;
UB PlaceFlagHasClipActions:1;
UI16 Depth;// Depth of character
};
// int g_TagIndex = -1;
//
// void GetTagInfo(File& swf ,TagType type,int len)
// {
//
// g_TagIndex++;
//
// switch(type)
// {
// case SetBackgroundColor:
// {
// RGB backgroundColor;
// swf.Read(&backgroundColor,len);
// break;
// }
// case SoundStreamHead:
// {
// tagSoundStreamHead2 head;
// swf.Read(&head,len);
// break;
// }
// case SoundStreamHead2:
// {
// tagSoundStreamHead2 head;
// swf.Read(&head,len);
// break;
// }
// case SoundStreamBlock:
// {
// //printf("Writing sound data---%d/n",g_TagIndex);
// unsigned char*pBuf = (unsigned char*)malloc(len);
// swf.Read(pBuf,len);
// mp3File.Write(pBuf+4,len-4);
// free(pBuf);
// break;
// }
// case FrameLabel:
// {
// unsigned char*pBuf = (unsigned char*)malloc(len);
// swf.Read(pBuf,len);
// break;
// }
// // case DefineShape2:
// // {
// // UI16 ShapeId;
// // swf.Read(&ShapeId,sizeof(ShapeId));
// // varRECT ShapeBounds;
// // swf.Read(&ShapeBounds,sizeof(varRECT));
// // RECT ShapeBoundsEx;
// // ShapeBounds.GetRect(ShapeBoundsEx);
// // int bytes = ShapeBounds.GetRectBytesCount();
// // swf.Seek(bytes-sizeof(varRECT),FILE_CURRENT);
// //
// // break;
// // }
// case DefineSound:
// {
// tagDefineSound ds;
// swf.Read(&ds,7);
// ds.SoundData = (byte*)malloc(len-7);
// swf.Read(ds.SoundData,len-7);
// MP3SOUNDDATA data;
// CopyMemory(&data,ds.SoundData,6);
// //mp3File.Write(ds.SoundData+2,len-9);
// free(ds.SoundData);
// break;
// }
// case PlaceObject2:
// {
// if (len>0)
// {
// unsigned char*pBuf = (unsigned char*)malloc(len);
// swf.Read(pBuf,len);
//
// tagPlaceObject2 po;
// CopyMemory(&po,pBuf,3);
//
// UI16 CharacterId = 0;
// if (po.PlaceFlagHasCharacter)
// {
// CopyMemory(&CharacterId,pBuf+3,2);
// }
// if (po.PlaceFlagHasMatrix)
// {
// }
//
// free(pBuf);
// }
// break;
// }
// case RemoveObject:
// {
// if (len>0)
// {
// unsigned char*pBuf = (unsigned char*)malloc(len);
// swf.Read(pBuf,len);
// free(pBuf);
// }
// break;
// }
// case RemoveObject2:
// {
// if (len>0)
// {
// unsigned char*pBuf = (unsigned char*)malloc(len);
// swf.Read(pBuf,len);
// free(pBuf);
// }
// break;
// }
// case ShowFrame:
// {
// //do nothing
// break;
// }
// case End:
// {
// //do nothing
// break;
// }
// default:
// {
// if (len>0)
// {
// unsigned char*pBuf = (unsigned char*)malloc(len);
// swf.Read(pBuf,len);
// free(pBuf);
// }
//
// }
//
// }
//}

#pragma once
#include <windows.h>
#include <tchar.h>
//#include <strsafe.h>
class File
{
public:
File(void);
public:
~File(void);

BOOL Open(LPCTSTR lpFileName,DWORD dwDesiredAccess/*参考CreateFile*/);
void Close();
DWORD Seek(LONG lDistanceToMove,DWORD dwMoveMethod/*参考SetFilePointer*/);
DWORD SeekToBegin( );
DWORD SeekToEnd( );
DWORD GetLength( ) const;
DWORD Read( LPVOID lpBuffer,DWORD nNumberOfBytesToRead);
DWORD Write(LPVOID lpBuffer,DWORD nNumberOfBytesToWrite);
private:
HANDLE m_hFile;
};

#include "StdAfx.h"
#include "File.h"
#include <assert.h>

extern DWORD g_dwLastError;
File::File(void)
{
m_hFile=INVALID_HANDLE_VALUE;
}

File::~File(void)
{
if (m_hFile!=INVALID_HANDLE_VALUE)
{
CloseHandle(m_hFile);
m_hFile = INVALID_HANDLE_VALUE;
}
}
BOOL File::Open(LPCTSTR lpFileName,DWORD dwDesiredAccess)
{
m_hFile = CreateFile(lpFileName,dwDesiredAccess,FILE_SHARE_READ,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
return m_hFile!=INVALID_HANDLE_VALUE ? TRUE:FALSE;
}
void File::Close()
{
if (m_hFile!=INVALID_HANDLE_VALUE)
{
CloseHandle(m_hFile);
m_hFile = INVALID_HANDLE_VALUE;
}
}
DWORD File::Seek(LONG lDistanceToMove,DWORD dwMoveMethod/*参考SetFilePointer*/)
{
assert(m_hFile!=INVALID_HANDLE_VALUE);
return SetFilePointer(m_hFile,lDistanceToMove,NULL,dwMoveMethod);
}

DWORD File::SeekToBegin( )
{
assert(m_hFile!=INVALID_HANDLE_VALUE);
return SetFilePointer(m_hFile,0,NULL,FILE_BEGIN);
}
DWORD File::SeekToEnd( )
{
assert(m_hFile!=INVALID_HANDLE_VALUE);
return SetFilePointer(m_hFile,0,NULL,FILE_END);
}

DWORD File::GetLength( ) const
{
assert(m_hFile!=INVALID_HANDLE_VALUE);
return GetFileSize(m_hFile,NULL);
}

DWORD File::Read( LPVOID lpBuffer,DWORD nNumberOfBytesToRead)
{
assert(m_hFile!=INVALID_HANDLE_VALUE);
DWORD dwNumberOfBytesRead;
ReadFile(m_hFile,lpBuffer,nNumberOfBytesToRead,&dwNumberOfBytesRead,NULL);
return dwNumberOfBytesRead;
}

DWORD File::Write(LPVOID lpBuffer,DWORD nNumberOfBytesToWrite)
{
assert(m_hFile!=INVALID_HANDLE_VALUE);
DWORD dwNumberOfBytesWrite;
WriteFile(m_hFile,lpBuffer,nNumberOfBytesToWrite,&dwNumberOfBytesWrite,NULL);
return dwNumberOfBytesWrite;
}

#pragma once
#include "File.h"
#include "DataType.h"

#define SWF_EXPORT __declspec(dllexport)
#define WM_PROGRESS_CONVERT WM_USER+1001
class SWF_EXPORT CSwf : public File
{
private:
SwfFileHeader m_head;
RECT m_rFrameSize;
float m_fFrameRate;
USHORT m_nFrameCount;

BOOL CheckCompress();
int DeCompressSwf(const TCHAR *pDest,const TCHAR *pSrc);
public:
CSwf();
public:
~CSwf(void);

BOOL ReadSwf(const TCHAR *pFilePath);
BOOL ParseSoundData2Mp3(const TCHAR *pMp3File);

int GetSwfVersion(){return m_head.Version;};
public:
void SetMessageHwnd(HWND hwnd){m_hwnd = hwnd;};
private:
TCHAR m_szSrcFile[MAX_PATH];
DWORD m_dwHeadSize;
HWND m_hwnd;
};

#include "StdAfx.h"
#include "Swf.h"
#include "zlib.h"
#pragma comment(lib,"zlib.lib")

static const TCHAR *pTmpFile = L"tmp.swf";
CSwf::CSwf()
{
ZeroMemory(&m_head,sizeof(m_head));
ZeroMemory(&m_rFrameSize,sizeof(m_rFrameSize));
m_fFrameRate = 0.0f;
m_nFrameCount = 0;
m_dwHeadSize = 0;
m_hwnd = NULL;
ZeroMemory(m_szSrcFile,sizeof(m_szSrcFile));
}

CSwf::~CSwf(void)
{
if (PathFileExists(pTmpFile))
{
Close();
DeleteFile(pTmpFile);
}
}

BOOL CSwf::ReadSwf(const TCHAR *pFilePath)
{
StringCchCopy(m_szSrcFile,MAX_PATH,pFilePath);
if(!Open(pFilePath,FILE_READ_DATA))
return FALSE;
if (CheckCompress())
{
Close();
int err = DeCompressSwf(pTmpFile,pFilePath);
if (err<0)
{
return FALSE;
}
if(!Open(pTmpFile,FILE_READ_DATA))
return FALSE;
}

SeekToBegin();//前面可能有读过数据,必须seek到开始,确保读取正确数据

DWORD dwRead = 0;
dwRead = Read(&m_head,SWFHEADSIZE);
m_dwHeadSize+=SWFHEADSIZE;

varRECT FrameSize;
dwRead = Read(&FrameSize,sizeof(FrameSize));
FrameSize.GetRect(m_rFrameSize);

Seek(FrameSize.GetRectBytesCount()-dwRead,FILE_CURRENT);//读取的字节比实际需要大了,需要往前seek
m_dwHeadSize+=FrameSize.GetRectBytesCount();

SwfFrameRate fr;
dwRead = Read(&fr,sizeof(fr));
m_fFrameRate = fr.GetFrameRate();
m_dwHeadSize+=dwRead;

dwRead = Read(&m_nFrameCount,sizeof(m_nFrameCount));
m_dwHeadSize+=dwRead;
}
BOOL CSwf::ParseSoundData2Mp3(const TCHAR *pMp3File)
{
File mp3File;
File mp3Event;
TCHAR EventFile[MAX_PATH];

BOOL bExistSoundData = FALSE;
BOOL bExistEventSoundData = FALSE;
Seek(m_dwHeadSize,FILE_BEGIN);

DWORD dwTagIndex = 0;

tagHeader taghead;
DWORD dwRead = 0;
while ((dwRead=Read(&taghead,sizeof(taghead)))>0)
{
int tagLen = taghead.GetLength();
TagType type = (TagType)taghead.GetType();

if (tagLen==0x3F)
{
tagLen = taghead.GetLengthEx();
}
else
{
Seek(sizeof(unsigned short)-dwRead,FILE_CURRENT);
}

if (type==SoundStreamBlock)
{
if (!bExistSoundData)
{
if (!mp3File.Open(pMp3File,FILE_WRITE_DATA))
{
return FALSE;
}
}
bExistSoundData = TRUE;
unsigned char*pBuf = (unsigned char*)malloc(tagLen);
Read(pBuf,tagLen);
mp3File.Write(pBuf+4,tagLen-4);//SampleCount and SeekSamples size = 4
free(pBuf);
}
else if (type == DefineSound)
{
if (!bExistEventSoundData)
{
StringCchCopy(EventFile,MAX_PATH,pMp3File);
//PathRemoveFileSpec(EventFile);
//StringCchCat(EventFile,MAX_PATH,L"//event.mp3");
LPTSTR lpFile = PathFindExtension(EventFile);
StringCchCopy(lpFile,sizeof(L"_event.mp3"),L"_event.mp3");
if (!mp3Event.Open(EventFile,FILE_WRITE_DATA))
{
return FALSE;
}
}
bExistEventSoundData = TRUE;

unsigned char*pBuf = (unsigned char*)malloc(tagLen);
Read(pBuf,tagLen);
mp3Event.Write(pBuf+4,tagLen-4);//SampleCount and SeekSamples size = 4
free(pBuf);
}
else
{
if (type == ShowFrame)
{
dwTagIndex++;
int percent = (int)dwTagIndex*100/m_nFrameCount;
if (m_hwnd)
{
::SendMessage(m_hwnd,WM_PROGRESS_CONVERT,NULL,(LPARAM)percent);
}
}
if (tagLen>0)
{
unsigned char*pBuf = (unsigned char*)malloc(tagLen);
Read(pBuf,tagLen);
free(pBuf);
}
}

}
if (bExistEventSoundData&&!bExistSoundData)
{
mp3Event.Close();
_wrename(EventFile,pMp3File);
}
return bExistSoundData||bExistEventSoundData;
}
BOOL CSwf::CheckCompress()
{
SeekToBegin();
byte c;
Read(&c,sizeof(c));
return c == 'F' ? FALSE : TRUE;
}

int CSwf::DeCompressSwf(const TCHAR *pDest,const TCHAR *pSrc)
{

File a;
if(!a.Open(pSrc,FILE_ALL_ACCESS)) return -1;

File b;
if(!b.Open(pDest,FILE_ALL_ACCESS)) return -1;

DWORD dwSize = a.GetLength();
DWORD dwReal = 0;
unsigned char* pData = (unsigned char*)malloc(dwSize);
dwReal=a.Read(pData,dwSize);
if (pData[0]=='F')
{
return 0;
}
pData[0]='F';

b.Write(pData,SWFHEADSIZE);
uLong uncomprLen = dwSize*10;
unsigned char* uncompr = (unsigned char*)malloc(uncomprLen);
int err = uncompress(uncompr, &uncomprLen, (const Bytef*)pData+SWFHEADSIZE, dwReal-SWFHEADSIZE);
b.Write(uncompr,uncomprLen);
free(pData);
free(uncompr);
return err;
}

// ConvertSwfToMp3Dlg.h : 头文件
//

#pragma once
#include "afxcmn.h"
#include "afxwin.h"

// CConvertSwfToMp3Dlg 对话框
class CConvertSwfToMp3Dlg : public CDialog
{
// 构造
public:
CConvertSwfToMp3Dlg(CWnd* pParent = NULL); // 标准构造函数

// 对话框数据
enum { IDD = IDD_CONVERTSWFTOMP3_DIALOG };

protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持

// 实现
protected:
HICON m_hIcon;

// 生成的消息映射函数
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
DECLARE_MESSAGE_MAP()
public:
CString m_szSwfFile;
public:
CString m_szMp3File;
public:
afx_msg void OnBnClickedButtonOpen();
public:
afx_msg void OnBnClickedButtonSave();
public:
afx_msg void OnBnClickedButtonStart();
afx_msg LRESULT OnProgressConvert(WPARAM wparm, LPARAM lparm);
public:
CProgressCtrl m_Progress;
BOOL m_bConverting;
public:
CStatic m_text;
};

// ConvertSwfToMp3Dlg.cpp : 实现文件
//

#include "stdafx.h"
#include "ConvertSwfToMp3.h"
#include "ConvertSwfToMp3Dlg.h"
#include "Swf.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialog
{
public:
CAboutDlg();

// 对话框数据
enum { IDD = IDD_ABOUTBOX };

protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持

// 实现
protected:
DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()

// CConvertSwfToMp3Dlg 对话框

CConvertSwfToMp3Dlg::CConvertSwfToMp3Dlg(CWnd* pParent /*=NULL*/)
: CDialog(CConvertSwfToMp3Dlg::IDD, pParent)
, m_szSwfFile(_T(""))
, m_szMp3File(_T(""))
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
m_bConverting = FALSE;
}

void CConvertSwfToMp3Dlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Text(pDX, IDC_EDIT1, m_szSwfFile);
DDX_Text(pDX, IDC_EDIT2, m_szMp3File);
DDX_Control(pDX, IDC_PROGRESS_Convert, m_Progress);
DDX_Control(pDX, IDC_STATIC_PRO, m_text);
}

BEGIN_MESSAGE_MAP(CConvertSwfToMp3Dlg, CDialog)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
ON_BN_CLICKED(IDC_BUTTON_OPEN, &CConvertSwfToMp3Dlg::OnBnClickedButtonOpen)
ON_BN_CLICKED(IDC_BUTTON_SAVE, &CConvertSwfToMp3Dlg::OnBnClickedButtonSave)
ON_BN_CLICKED(IDC_BUTTON_START, &CConvertSwfToMp3Dlg::OnBnClickedButtonStart)
ON_MESSAGE(WM_PROGRESS_CONVERT,&CConvertSwfToMp3Dlg::OnProgressConvert)
END_MESSAGE_MAP()

// CConvertSwfToMp3Dlg 消息处理程序

BOOL CConvertSwfToMp3Dlg::OnInitDialog()
{
CDialog::OnInitDialog();

// 将“关于...”菜单项添加到系统菜单中。

// IDM_ABOUTBOX 必须在系统命令范围内。
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);

CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}

// 设置此对话框的图标。当应用程序主窗口不是对话框时,框架将自动
// 执行此操作
SetIcon(m_hIcon, TRUE); // 设置大图标
SetIcon(m_hIcon, FALSE); // 设置小图标

// TODO: 在此添加额外的初始化代码
m_Progress.SetRange(0,100);
return TRUE; // 除非将焦点设置到控件,否则返回 TRUE
}

void CConvertSwfToMp3Dlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}

// 如果向对话框添加最小化按钮,则需要下面的代码
// 来绘制该图标。对于使用文档/视图模型的 MFC 应用程序,
// 这将由框架自动完成。

void CConvertSwfToMp3Dlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // 用于绘制的设备上下文

SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

// 使图标在工作矩形中居中
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;

// 绘制图标
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}

//当用户拖动最小化窗口时系统调用此函数取得光标显示。
//
HCURSOR CConvertSwfToMp3Dlg::OnQueryDragIcon()
{
return static_cast<HCURSOR>(m_hIcon);
}

void CConvertSwfToMp3Dlg::OnBnClickedButtonOpen()
{
// TODO: 在此添加控件通知处理程序代码
CFileDialog openFileDlg(TRUE,NULL,NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_EXPLORER,L"Flash Files (*.swf)|*.swf||");
if (IDOK == openFileDlg.DoModal())
{
m_szSwfFile = openFileDlg.GetOFN().lpstrFile;

TCHAR musicFile[MAX_PATH];
GetModuleFileName(NULL,musicFile,MAX_PATH);
PathRemoveFileSpec(musicFile);
StringCchCat(musicFile,MAX_PATH,L"//FlashToMp3//");
if (!PathFileExists(musicFile))
{
CreateDirectory(musicFile,NULL);
}
StringCchCat(musicFile,MAX_PATH,PathFindFileName(m_szSwfFile));
PathRenameExtension(musicFile,L".mp3");
m_szMp3File = musicFile;

m_Progress.SetPos(0);
CString text;
text.Format(L"%d",0);
text+=L"%";
m_text.SetWindowText(text);
UpdateData(FALSE);
}
}

void CConvertSwfToMp3Dlg::OnBnClickedButtonSave()
{
// TODO: 在此添加控件通知处理程序代码
CFileDialog openFileDlg(FALSE,NULL,NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_EXPLORER,L"Flash Files (*.mp3)|*.mp3||");
if (IDOK == openFileDlg.DoModal())
{
TCHAR tmp[MAX_PATH];
StringCchCopy(tmp,MAX_PATH,openFileDlg.GetOFN().lpstrFile);
PathRenameExtension(tmp,L".mp3");
m_szMp3File = tmp;
UpdateData(FALSE);
}
}
UINT __cdecl ConverThead( LPVOID pParam )
{

CConvertSwfToMp3Dlg *pDlg = (CConvertSwfToMp3Dlg*)pParam;
pDlg->m_bConverting = TRUE;
if (pDlg->m_szSwfFile==_T(""))
{
AfxMessageBox(L"Please select a flash first!");
pDlg->m_bConverting = FALSE;
return -1;
}

CSwf swf;
swf.ReadSwf(pDlg->m_szSwfFile);
swf.SetMessageHwnd(pDlg->m_hWnd);

TCHAR path[MAX_PATH];
StringCchCopy(path,MAX_PATH,pDlg->m_szMp3File);
PathRemoveFileSpec(path);

if(!swf.ParseSoundData2Mp3(pDlg->m_szMp3File))
AfxMessageBox(L"No sound data exits!");
else
{
ShellExecute(NULL, L"explore", path, NULL, NULL, SW_SHOWNORMAL);
}

pDlg->m_bConverting = FALSE;

return 0;
}

void CConvertSwfToMp3Dlg::OnBnClickedButtonStart()
{
// TODO: 在此添加控件通知处理程序代码
if (m_bConverting)
{
return;
}

if (m_szMp3File==_T(""))
{
TCHAR musicFile[MAX_PATH];
GetModuleFileName(NULL,musicFile,MAX_PATH);
PathRemoveFileSpec(musicFile);
StringCchCat(musicFile,MAX_PATH,L"//FlashToMp3//");
if (!PathFileExists(musicFile))
{
CreateDirectory(musicFile,NULL);
}
StringCchCat(musicFile,MAX_PATH,PathFindFileName(m_szSwfFile));
PathRenameExtension(musicFile,L".mp3");
m_szMp3File = musicFile;

UpdateData(FALSE);
}

AfxBeginThread(ConverThead,(LPVOID)this);
}
LRESULT CConvertSwfToMp3Dlg::OnProgressConvert(WPARAM wparm, LPARAM lparm)
{
m_Progress.SetPos((int)lparm);
CString text;
text.Format(L"%d",(int)lparm);
text+=L"%";
m_text.SetWindowText(text);
return 0;
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: