CDToMP3(WAV)-2

[csz_cmy]

///////////////////////lame.cpp//////////////////////////////////////
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Lame.h"
//---------------------------------------------------------------------------

#pragma package(smart_init)

//---------------------------------------------------------------------------
TBEERR Err;
unsigned FileLength,Done;
unsigned dwWrite,toRead,isRead,toWrite,IsWritten;
AnsiString FWAVFileName,FMp3FileName;
Word PrcntComplete;

//---------------------------------------------------------------------------
__fastcall TLameVersion::TLameVersion(void)
: TPersistent()
{
beVersion(FBeV);
}
//---------------------------------------------------------------------------
void __fastcall TLameVersion::Assign(TPersistent *Source)
{
if(Source->ClassNameIs("TLameVersion"))
{
FBeV.byDLLMajorVersion=((TLameVersion *)Source)->FBeV.byDLLMajorVersion;
FBeV.byDLLMinorVersion=((TLameVersion *)Source)->FBeV.byDLLMinorVersion;
FBeV.byMajorVersion=((TLameVersion *)Source)->FBeV.byMajorVersion;
FBeV.byMinorVersion=((TLameVersion *)Source)->FBeV.byMinorVersion;
}
else TPersistent::Assign(Source);
}
//---------------------------------------------------------------------------
__fastcall TLameCoder::TLameCoder(TComponent *AOwner)
: TComponent(AOwner)
{
FSampleRate=44100;
FBitrate=128;
FMaxBitrate=320;
FQuality=NORMAL_QUALITY;
FCRC=true;
FVBRQuality=4;
FInputFiles=new TStringList;
FOutputFiles=new TStringList;
FLameVersion=new TLameVersion;
FDefaultExt=".mp3";
}
//---------------------------------------------------------------------------
__fastcall TLameCoder::~TLameCoder()
{
delete FInputFiles;
delete FOutputFiles;
delete FLameVersion;
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::Assign(TPersistent *Source)
{
if(Source->ClassNameIs("TLameCoder"))
{
FSampleRate =((TLameCoder *)Source)->FSampleRate;
FReSampleRate =((TLameCoder *)Source)->FReSampleRate;
FMode =((TLameCoder *)Source)->FMode;
FBitrate =((TLameCoder *)Source)->FBitrate;
FMaxBitrate =((TLameCoder *)Source)->FMaxBitrate;
FQuality =((TLameCoder *)Source)->FQuality;
FMpegVersion =((TLameCoder *)Source)->FMpegVersion;
FPsyModel =((TLameCoder *)Source)->FPsyModel;
FEmphasis =((TLameCoder *)Source)->FEmphasis;
FPrivate =((TLameCoder *)Source)->FPrivate;
FCRC =((TLameCoder *)Source)->FCRC;
FCopyright =((TLameCoder *)Source)->FCopyright;
FOriginal =((TLameCoder *)Source)->FOriginal;
FWriteVBRHeader=((TLameCoder *)Source)->FWriteVBRHeader;
FEnableVBR =((TLameCoder *)Source)->FEnableVBR;
FVBRQuality =((TLameCoder *)Source)->FVBRQuality;
}
else TComponent::Assign(Source);
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::SetSampleRate(unsigned Value)
{
FSampleRate=Value;
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::SetBitrate(unsigned Value)
{
FBitrate=Value;
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::SetEnableVBR(BOOL Value)
{
FEnableVBR=Value;
FWriteVBRHeader=Value;
}
//---------------------------------------------------------------------------
TLameVersion * __fastcall TLameCoder::GetLameVersion(void)
{
return FLameVersion;
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::SetInputFiles(TStrings *Value )
{
FInputFiles->Assign(Value);
FOutputFiles->Clear();
for(int I=0;I<FInputFiles->Count;I++)
FOutputFiles->Add(ChangeFileExt(FInputFiles->Strings[I],FDefaultExt));
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::SetOutputFiles(TStrings *Value)
{
FOutputFiles->Assign(Value);
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::SetMode(TLameMode Value)
{
switch(Value)
{
case STEREO : FMode=BE_MP3_MODE_STEREO;break;
case JSTEREO : FMode=BE_MP3_MODE_JSTEREO;break;
case DUALCHANNEL: FMode=BE_MP3_MODE_DUALCHANNEL;break;
case MONO : FMode=BE_MP3_MODE_MONO;break;
}
}
//---------------------------------------------------------------------------
TLameMode __fastcall TLameCoder::GetMode(void)
{
switch(FMode)
{
case BE_MP3_MODE_STEREO :return STEREO;
case BE_MP3_MODE_JSTEREO :return JSTEREO;
case BE_MP3_MODE_DUALCHANNEL:return DUALCHANNEL;
case BE_MP3_MODE_MONO :return MONO;
}
return MONO;
}
//---------------------------------------------------------------------------
TBEERR __fastcall TLameCoder::PrepareCoder(void)
{
FBeConfig.Format.dwConfig=BE_CONFIG_LAME;
TLHV1 *LHV1=&FBeConfig.Format.LHV1;
LHV1->dwStructVersion=1;
LHV1->dwStructSize =sizeof(FBeConfig);
LHV1->dwSampleRate =FSampleRate;
LHV1->dwReSampleRate =0;
LHV1->nMode =FMode;
LHV1->dwBitrate =FBitrate;
LHV1->dwMaxBitrate =FMaxBitrate;
LHV1->nQuality =unsigned(FQuality);
LHV1->dwMpegVersion =MPEG1;
LHV1->dwPsyModel =0;
LHV1->dwEmphasis =0;
LHV1->bPrivate =FPrivate;
LHV1->bCRC =FCRC;
LHV1->bCopyright =FCopyright;
LHV1->bOriginal =FOriginal;
LHV1->bWriteVBRHeader=FWriteVBRHeader;
LHV1->bEnableVBR =FEnableVBR;
LHV1->nVBRQuality =FVBRQuality;

Err=beInitStream(FBeConfig,FNumSamples,FBufSize,FHBeStream);
if(Err==BE_ERR_SUCCESSFUL)
FOutputBuf=new char[FBufSize];
return Err;
}

[csz_cmy]

//---------------------------------------------------------------------------
TBEERR __fastcall TLameCoder::UnPrepareCoder(void *Buf,unsigned &dwWrite)
{
return beDeinitStream(FHBeStream,(byte *)Buf,dwWrite);
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::CloseCoder(void)
{
delete[] (char *)FOutputBuf;
beCloseStream(FHBeStream);
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::CleanUp(void)
{
delete[] (char *)FInputBuf;
delete FWAVFile;
delete FMP3File;
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::ProcessFiles(void)
{
Word InputBufSize;
FCancelProcess=false;
if(FOnBeginProcess) FOnBeginProcess(this);
for(int FNum=0;FNum<FInputFiles->Count;FNum++)
{
PrepareCoder();
if(FOnBeginFile) FOnBeginFile(this,FNum,FInputFiles->Strings[FNum]);

FWAVFileName=FInputFiles->Strings[FNum];
FMp3FileName=FOutputFiles->Strings[FNum];

FWAVFile=new TFileStream(FWAVFileName,fmOpenRead);
FMP3File=new TFileStream(FMp3FileName,fmCreate|fmShareDenyNone);

FWAVFile->Read(&FWave,sizeof(TWaveHeader));

if(FWave.Marker2=="WAVE")
{
InputBufSize=FNumSamples*FWave.BytesPerSample;
FileLength=FWAVFile->Size-sizeof(TWaveHeader);
}
else
{
if(FMode==BE_MP3_MODE_MONO) InputBufSize=FNumSamples;
else InputBufSize=FNumSamples*2;
FileLength=FWAVFile->Size;
FWAVFile->Seek(0,soFromBeginning);
}

FInputBuf=new char[InputBufSize];

Done= 0;
while(Done!=FileLength)
{
if(Done+InputBufSize<FileLength)
toRead=InputBufSize;
else toRead=FileLength-Done;

isRead=FWAVFile->Read(FInputBuf,toRead);
if(isRead!=toRead)
{
CleanUp();
CloseCoder();
throw ELameError("Read Error");
}

Err=beEncodeChunk(FHBeStream,toRead/2,(short *)FInputBuf,(char *)FOutputBuf,toWrite);
if(Err!=BE_ERR_SUCCESSFUL)
{
CleanUp();
CloseCoder();
throw ELameError("beEncodeChunk failed "+IntToStr(Err));
}

IsWritten=FMP3File-> Write(FOutputBuf,toWrite);
if(toWrite!=IsWritten)
{
CleanUp();
CloseCoder();
throw ELameError("Write Error");
}

Done+=toRead;
PrcntComplete=Done*100/FileLength;
if(FOnProgress) FOnProgress(this,PrcntComplete);
Application->ProcessMessages();

if(FCancelProcess)
{
CleanUp();
CloseCoder();
return;
}
}
UnPrepareCoder(FOutputBuf,dwWrite);
IsWritten=FMP3File->Write(FOutputBuf,dwWrite);
if(dwWrite!=IsWritten)
{
CleanUp();
CloseCoder();
throw ELameError("Write error");
}

CleanUp();
CloseCoder();
if(FOnEndFile) FOnEndFile(this,FNum,FOutputFiles->Strings[FNum]);
}
if(FOnEndProcess) FOnEndProcess(this);
}
//---------------------------------------------------------------------------
void __fastcall TLameCoder::CancelProcess(void)
{
FCancelProcess=true;
}
//---------------------------------------------------------------------------
TBEERR __fastcall TLameCoder::EncodeBuffer(void *InBuf,void *OutBuf,unsigned &OutP)
{
return beEncodeChunk(FHBeStream,FNumSamples,(short *)InBuf,(byte *)OutBuf,OutP);
}
//---------------------------------------------------------------------------
__fastcall TLameStream::TLameStream(const AnsiString FileName,Word Mode)
:TFileStream(FileName,fmCreate|fmShareDenyNone)
{
FLameCoder=new TLameCoder(Application);
FLameCoder->PrepareCoder();
FOutBuf=new char[FLameCoder->BufSize];
}
//---------------------------------------------------------------------------
__fastcall TLameStream::~TLameStream()
{
unsigned FCount;
FLameCoder->UnPrepareCoder(FOutBuf,FCount);
TFileStream::Write(FOutBuf,FCount);
FLameCoder->CloseCoder();
delete FLameCoder;
delete[] (char *)FOutBuf;
}
//---------------------------------------------------------------------------
int __fastcall TLameStream::Write(const void *Buffer,int Count)
{
unsigned FCount;
if(FLameCoder->EncodeBuffer((void *)Buffer,FOutBuf,FCount)==BE_ERR_SUCCESSFUL)
return TFileStream::Write(FOutBuf,FCount);
else return 0;
}
//---------------------------------------------------------------------------
int __fastcall TLameStream::Read(void *Buffer,int Count)
{
throw EStreamError("Read from stream not supported");
}
//---------------------------------------------------------------------------
void __fastcall TLameStream::SetLameCoder(TLameCoder *Value)
{
FLameCoder->CloseCoder();
FLameCoder->Assign(Value);
FLameCoder->PrepareCoder();
}
//---------------------------------------------------------------------------

[csz_cmy]

///////////////////////////////cdrip.h//////////////////////////////
//---------------------------------------------------------------------------

#ifndef RipH
#define RipH
//---------------------------------------------------------------------------

#include <Dialogs.hpp> // Pascal unit
#include <Forms.hpp> // Pascal unit
#include <Controls.hpp> // Pascal unit
#include <Graphics.hpp> // Pascal unit
#include <Classes.hpp> // Pascal unit
#include <SysUtils.hpp> // Pascal unit
#include <Messages.hpp> // Pascal unit
#include <Windows.hpp> // Pascal unit
#include <SysInit.hpp> // Pascal unit
#include <System.hpp> // Pascal unit
#include "CdRip_dll.hpp"
#include "Lame.h"
//---------------------------------------------------------------------------
typedef Exception ECDRIPError;
typedef char TCDROMName[256];

class TTrack :public TObject
{
public:
int TrackNum;
int BegTrack;
int EndTrack;
char Mode[6];
};

typedef void __fastcall (__closure *TProcEvent)(TObject* Sender, Word PercentComplete);

typedef void __fastcall (__closure *TProcessTrackEvent)(TObject* Sender, Word TrackNum);

class TDriveTableClass :public TPersistent
{
public:
TDriveTable FDTable;
__published:
__property TDriveType DriveType = {read=FDTable.DriveType, write=FDTable.DriveType, nodefault};
__property TReadMethod ReadMethod = {read=FDTable.ReadMethod, write=FDTable.ReadMethod, nodefault};
__property TSetSpeed SetSpeed = {read=FDTable.SetSpeed, write=FDTable.SetSpeed, nodefault};
__property TEndian Endian = {read=FDTable.Endian, write=FDTable.Endian, nodefault};
__property TEnableMode EnableMode = {read=FDTable.EnableMode, write=FDTable.EnableMode, nodefault};
__property int Density = {read=FDTable.nDensity, write=FDTable.nDensity, nodefault};
__property BOOL Atapi = {read=FDTable.bAtapi, write=FDTable.bAtapi, nodefault};
};

class TCDRIP :public TComponent
{
private:
int FCDRomNum;
TDriveTableClass* FDriveTable;
TOutputFormat FOutputFormat;
char FCDRomName[256];
TLameCoder* FLameCoder;
int FTocNum;
TStrings* FTracks;
TStrings* FJitters;
int FJittersNum;
bool FJitter;
bool FEncode;
bool FWriteWAV;
bool FCancelRip;
int FSpeed;
TProcessTrackEvent FOnBeginTrack;
TProcessTrackEvent FOnEndTrack;
TProcEvent FOnProgress;
AnsiString FVersion;
void __fastcall SetActiveCD(int Value);
void __fastcall SetOutputFormat(Cdrip_dll::TOutputFormat Value);
void __fastcall SetLameCoder(TLameCoder* Value);
void __fastcall SetLameFormat(void);
void __fastcall SetJitterCorrection(bool Value);

protected:
void __fastcall RipSectors(int BegSector, int EndSector, AnsiString FileName);

public:
__fastcall virtual TCDRIP(Classes::TComponent* AOwner);
__fastcall virtual ~TCDRIP(void);
bool __fastcall IsCDROMReady(void);
bool __fastcall SetNewCDROMParams(void);
void __fastcall RipTrack(int TrackNum, AnsiString FileName);
void __fastcall RipTrackTime(int TrackNum, int BegTime, int LengthTime, AnsiString FileName);
void __fastcall CancelRip(void);

__property int TrackNum = {read=FTocNum, nodefault};
__property TStrings* Tracks = {read=FTracks};
__property TStrings* Jitters = {read=FJitters};
__property int JittersNum = {read=FJittersNum, nodefault};

__published:
__property TLameCoder* Coder = {read=FLameCoder, write=SetLameCoder};
__property int CDRomNum = {read=FCDRomNum, write=SetActiveCD, nodefault};
__property TDriveTableClass* DriveTable = {read=FDriveTable, write=FDriveTable};
__property TOutputFormat OutputFormat = {read=FOutputFormat, write=SetOutputFormat, default=0};
__property bool Encode = {read=FEncode, write=FEncode, default=0};
__property bool WriteWAV = {read=FWriteWAV, write=FWriteWAV, default=0};
__property bool JitterCorrect = {read=FJitter, write=SetJitterCorrection, default=1};
__property TProcessTrackEvent OnBeginTrack = {read=FOnBeginTrack, write=FOnBeginTrack};
__property TProcessTrackEvent OnEndTrack = {read=FOnEndTrack, write=FOnEndTrack};
__property TProcEvent OnProgress = {read=FOnProgress, write=FOnProgress};
__property AnsiString Version = {read=FVersion, write=FVersion};
__property int Speed = {read=FSpeed, write=FSpeed, nodefault};
};
//---------------------------------------------------------------------------
#endif

[csz_cmy]

///////////////////cdrip.cpp///////////////////////////////////
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Rip.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)
//---------------------------------------------------------------------------

TCDROMParams FParams;
AnsiString __fastcall LeadingZero2(Word w)
{
AnsiString S;
S.printf("%02d",(int)w);
return S;
}
//---------------------------------------------------------------------------
__fastcall TCDRIP::TCDRIP(TComponent *AOwner)
:TComponent(AOwner)
{
AnsiString S;
TTOCEntry Toc1,Toc2;
__int64 L1,L2;
try
{
FTracks=new TStringList;
FJitters=new TStringList;
L1=CR_GetCDRipVersion();
FVersion=IntToStr(L1);
if(CR_Init()!=CDEX_ERROR)
{
if(CR_GetCDROMParameters(FParams)!=CDEX_ERROR)
{
StrCopy(FCDRomName,FParams.lpszCDROMID);
FCDRomNum=CR_GetActiveCDROM();
FDriveTable=new TDriveTableClass;
FDriveTable->FDTable=FParams.DriveTable;
FOutputFormat=FParams.nOutputFormat;
FSpeed=FParams.nSpeed;
FJitter=true;
FParams.bJitterCorrection=LongBool(FJitter);
}
if(CR_ReadToc()!=CDEX_ERROR) FTocNum=CR_GetNumTocEntries();
for(int I=0;I<FTocNum;I++)
{
S="Track"+LeadingZero2(I+1);
L1=CR_GetTocEntry(I);
L2=CR_GetTocEntry(I+1);
Move(&L1,&Toc1,6);
Move(&L2,&Toc2,6);
FTracks->AddObject(S,new TTrack);
((TTrack *)FTracks->Objects[I])->TrackNum=I+1;
((TTrack *)FTracks->Objects[I])->BegTrack=Toc1.dwStartSector;
((TTrack *)FTracks->Objects[I])->EndTrack=Toc2.dwStartSector-1;
if(Toc1.btFlag==AUDIOTRKFLAG)
StrCopy(((TTrack *)FTracks->Objects[I])->Mode,"Audio");
else StrCopy(((TTrack *)FTracks->Objects[I])->Mode,"Data");
}
}
FJittersNum=0;
}
catch(...)
{
throw ECDRIPError("Initialization failure");
}
}
//---------------------------------------------------------------------------
__fastcall TCDRIP::~TCDRIP()
{
delete FTracks;
delete FJitters;
delete FDriveTable;
FLameCoder=NULL;
}
//---------------------------------------------------------------------------
void __fastcall TCDRIP::SetActiveCD(int Value)
{
AnsiString S;
__int64 L1,L2;
TTOCEntry Toc1,Toc2;
if(FCDRomNum!=Value)
try
{
if(CR_SetActiveCDROM(Value)!=CDEX_ERROR)
if(CR_GetCDROMParameters(FParams)!=CDEX_ERROR)
{
StrCopy(FCDRomName,FParams.lpszCDROMID);
FDriveTable->FDTable=FParams.DriveTable;
FOutputFormat=FParams.nOutputFormat;
FSpeed=FParams.nSpeed;
FCDRomNum=Value;
}
if(CR_ReadToc()!=CDEX_ERROR)
{
FTocNum=CR_GetNumTocEntries();
for(int I=1;I<=FTocNum;I++)
{
S="Track"+LeadingZero2(I+1);
L1=CR_GetTocEntry(I);
L2=CR_GetTocEntry(I+1);
Move(&L1,&Toc1,6);
Move(&L2,&Toc2,6);
FTracks->AddObject(S,new TTrack);
((TTrack *)FTracks->Objects[I])->TrackNum=I+1;
((TTrack *)FTracks->Objects[I])->BegTrack=Toc1.dwStartSector;
((TTrack *)FTracks->Objects[I])->EndTrack=Toc2.dwStartSector-1;
if(Toc1.btFlag==AUDIOTRKFLAG)
StrCopy(((TTrack *)FTracks->Objects[I])->Mode,"Audio");
else StrCopy(((TTrack *)FTracks->Objects[I])->Mode,"Data");
}
}
}
catch(...)
{
throw ECDRIPError("Initialization failure");
}
}
//---------------------------------------------------------------------------
void __fastcall TCDRIP::SetJitterCorrection(bool Value)
{
if(FJitter!=Value)
{
FJitter=Value;
FParams.bJitterCorrection=LongBool(Value);
}
}
//---------------------------------------------------------------------------
void __fastcall TCDRIP::SetLameFormat(void)
{
if(FLameCoder)
switch(FOutputFormat)
{
case STEREO44100: FLameCoder->Mode=STEREO;
FLameCoder->SampleRate=44100;
break;
case MONO44100 : FLameCoder->Mode=MONO;
FLameCoder->SampleRate=44100;
break;
case STEREO22050: FLameCoder->Mode=STEREO;
FLameCoder->SampleRate=22050;
break;
case MONO22050 : FLameCoder->Mode=MONO;
FLameCoder->SampleRate=22050;
break;
case STEREO11025: FLameCoder->Mode=STEREO;
FLameCoder->SampleRate=11025;
break;
case MONO11025 : FLameCoder->Mode=MONO;
FLameCoder->SampleRate=11025;
}
}
//---------------------------------------------------------------------------
void __fastcall TCDRIP::SetOutputFormat(TOutputFormat Value)
{
if(FOutputFormat!=Value)
FParams.nOutputFormat=Value;
FOutputFormat=Value;
SetLameFormat();
}
//---------------------------------------------------------------------------
bool __fastcall TCDRIP::IsCDROMReady(void)
{
return CR_IsUnitReady();
}
//---------------------------------------------------------------------------
bool __fastcall TCDRIP::SetNewCDROMParams(void)
{
bool Result=false;
try
{
if(CR_SetCDROMParameters(&FParams)!=CDEX_ERROR) Result=true;
}
catch(...)
{
throw ECDRIPError("Error setting parameters");
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TCDRIP::SetLameCoder(TLameCoder *Value)
{
FLameCoder=Value;
SetLameFormat();
}

[bluebird97073]

（：
收下~

[cdws222]

好呀，大哥，你能不能将工程发到我邮箱里，我放到我的主页上去供大家下载，怎么样？
[e-mail]