unit cmxMP3;

Windows, Classes, SysUtils, Messages;

{

eMciDeviceError = class( Exception );

{

TMPMode = ( mpNotReady,mpStopped,mpPlaying,mpRecording,mpSeeking

,mpPaused,mpOpen,mpUnknown );

{

TMPTimeFormat = ( tfMilliseconds,tfHMS,tfMSF,tfFrames,tfSMPTE24,tfSMPTE25

,tfSMPTE30,tfSMPTE30Drop,tfBytes,tfSamples,tfTMSF );

{

TcmxPlayProgress = procedure(Sender : TObject; aSecs : integer) of object;

{

TcmxID3 = packed record

Tag : array[0..2] of Char;

Title : array[0..29] of Char;

Artist : array[0..29] of Char;

Album : array[0..29] of Char;

Year : array[0..3] of Char;

Comment : array[0..27] of Char;

Filler : Char;

Track : Byte;

Genre : Byte;

end; // TcmxID3

{

TcmxProgressThread = class(TThread)

private

fEvent : TNotifyEvent;

// private methods

procedure DoExecute;

procedure SyncOnProgress;

protected

procedure Execute; override;

public

constructor Create(aProgressEvent : TNotifyEvent);

end; // TcmxProgressThread

{

TcmxMP3 = class(TObject)

private

fDeviceID : WORD;

fFilePath : string;

fHWND : HWND;

fID3 : TcmxID3;

fLgthInSecs : integer;

fOnPlayProgress: TcmxPlayProgress;

fOnPlayComplete: TNotifyEvent;

fProgressTimer : TcmxProgressThread;

// getters

function getFileName: string;

function getFilePath: string;

function getAlbum: string;

function getArtist: string;

function getComment: string;

function getTitle: string;

function getYear: string;

function getTrack: byte;

function getGenreNdx: byte;

function getGenreText(aNdx: integer): string;

function getLengthInSeconds: integer;

function getState: TMPMode;

// mci methods

procedure mciOpen;

procedure mciClose;

function mciGetErrorMessage(aError : integer) : string;

procedure mciCheckError(aError : integer);

function mciGetMode : TMPMode;

procedure mciResume;

procedure mciPause;

procedure mciPlay;

procedure mciStop;

procedure mciNotifyEvent(var Msg: TMessage);

procedure mciWndMethod(var Msg: TMessage);

procedure mciSetTimeFormat(aValue: TMPTimeFormat);

function mciGetLength : Longint;

function mciLgthInSecs : integer;

function mciGetPosition: Longint;

// ID3 methods

function id3Init : TcmxID3;

function id3Get : TcmxID3;

procedure id3Put(aID3: TcmxID3);

// method passed to progress thread

procedure OnProgressTimer(Sender : TObject);

public

// create an object for a specific .mp3 file

constructor Create(const aFilePath : string);

destructor Destroy; override;

// player methods

procedure Play;

procedure Stop;

procedure Pause;

procedure Resume;

// change ID3 record

procedure ChgID3(const aTitle, aArtist, aAlbum, aComment: string;

aYear: integer; aTrack, aGenre: byte);

// change .mp3 file path (.mp3 extension is assumed)

function ChgFilePath(const aFilePath, aFileName: string): boolean;

// returns largest valid GenreID (0 is the lowest value)

function MaxGenreID : integer;

// returns genre text given a valid index

property GenreText[aNdx : integer] : string

read getGenreText;

// length of .mp3 in seconds

property LengthInSeconds : integer

read getLengthInSeconds;

// state of player (see TMPMode above)

property State : TMPMode

read getState;

// ID3 values

property Title : string

read getTitle;

property Artist : string

read getArtist;

property Album : string

read getAlbum;

property Comment : string

read getComment;

property Year : string

read getYear;

property Track : byte

read getTrack;

property GenreNdx : byte

read getGenreNdx;

// .mp3 file name only (no path and no extension)

property FileName : string

read getFileName;

// .mp3 file path (directory where the file resides)

property FilePath : string

read getFilePath;

// event fired at end of play

property OnPlayComplete : TNotifyEvent

read fOnPlayComplete write fOnPlayComplete;

// event fired each second as play progresses

property OnPlayProgress : TcmxPlayProgress

read fOnPlayProgress write fOnPlayProgress;

end; // TcmxMP3

// Forms unit needed when compiling under Delphi 5

Forms,

mmSystem, Consts;

cMaxID3Genre = 147;

cID3Genre: array[ 0..cMaxID3Genre ] of string = (

'Blues'

,'Classic Rock'

,'Country'

,'Dance'

,'Disco'

,'Funk'

,'Grunge'

,'Hip-Hop'

,'Jazz'

,'Metal'

,'New Age'

,'Oldies'

,'Other'

,'Pop'

,'R&B'

,'Rap'

,'Reggae'

,'Rock'

,'Techno'

,'Industrial'

,'Alternative'

,'Ska'

,'Death Metal'

,'Pranks'

,'Soundtrack'

,'Euro-Techno'

,'Ambient'

,'Trip-Hop'

,'Vocal'

,'Jazz+Funk'

,'Fusion'

,'Trance'

,'Classical'

,'Instrumental'

,'Acid'

,'House'

,'Game'

,'Sound Clip'

,'Gospel'

,'Noise'

,'AlternRock'

,'Bass'

,'Soul'

,'Punk'

,'Space'

,'Meditative'

,'Instrumental Pop'

,'Instrumental Rock'

,'Ethnic'

,'Gothic'

,'Darkwave'

,'Techno-Industrial'

,'Electronic'

,'Pop-Folk'

,'Eurodance'

,'Dream'

,'Southern Rock'

,'Comedy'

,'Cult'

,'Gangsta'

,'Top 40'

,'Christian Rap'

,'Pop/Funk'

,'Jungle'

,'Native American'

,'Cabaret'

,'New Wave'

,'Psychadelic'

,'Rave'

,'Showtunes'

,'Trailer'

,'Lo-Fi'

,'Tribal'

,'Acid Punk'

,'Acid Jazz'

,'Polka'

,'Retro'

,'Musical'

,'Rock & Roll'

,'Hard Rock'

,'Folk'

,'Folk-Rock'

,'National Folk'

,'Swing'

,'Fast Fusion'

,'Bebob'

,'Latin'

,'Revival'

,'Celtic'

,'Bluegrass'

,'Avantgarde'

,'Gothic Rock'

,'Progressive Rock'

,'Psychedelic Rock'

,'Symphonic Rock'

,'Slow Rock'

,'Big Band'

,'Chorus'

,'Easy Listening'

,'Acoustic'

,'Humour'

,'Speech'

,'Chanson'

,'Opera'

,'Chamber Music'

,'Sonata'

,'Symphony'

,'Booty Bass'

,'Primus'

,'Porn Groove'

,'Satire'

,'Slow Jam'

,'Club'

,'Tango'

,'Samba'

,'Folklore'

,'Ballad'

,'Power Ballad'

,'Rhythmic Soul'

,'Freestyle'

,'Duet'

,'Punk Rock'

,'Drum Solo'

,'Acapella'

,'Euro-House'

,'Dance Hall'

,'Goa'

,'Drum & Bass'

,'Club-House'

,'Hardcore'

,'Terror'

,'Indie'

,'BritPop'

,'Negerpunk'

,'Polsk Punk'

,'Beat'

,'Christian Gangsta Rap'

,'Heavy Metal'

,'Black Metal'

,'Crossover'

,'Contemporary Christian'

,'Christian Rock'

,'Merengue'

,'Salsa'

,'Trash Metal'

,'Anime'

,'Jpop'

,'Synthpop'

);

constructor TcmxProgressThread.Create(aProgressEvent: TNotifyEvent);

// create the thread in a suspended state

inherited Create( True );

// when the thread is terminated; free the thread object

FreeOnTerminate := True;

// save the progress event

fEvent := aProgressEvent;

// start the thread

Resume;

end; // Create

procedure TcmxProgressThread.Execute;

// don't allow any exceptions to escape from the thread

try

DoExecute;

except

// do nothing

end; // try except

end; // Execute

procedure TcmxProgressThread.DoExecute;

{

repeat

if( not Terminated )then Synchronize( SyncOnProgress );

until Terminated or (SleepEx( 1000,False ) <> 0);

end; // DoExecute

procedure TcmxProgressThread.SyncOnProgress;

// fire the event if it is assigned (it should be)

if( Assigned( fEvent ) )then

begin

fEvent( self );

end; // if

end; // SyncOnProgress

constructor TcmxMP3.Create(const aFilePath: string);

// set initial values

fDeviceID := 0;

fFilePath := aFilePath;

fID3 := id3Get;

fLgthInSecs := mciLgthInSecs;

// allocate window proc to snag mci messages

fHWND := AllocateHWND( mciWndMethod );

end; // Create

destructor TcmxMP3.Destroy;

// deallocate window proc

DeallocateHWND( fHWND );

// call inherited destructor

inherited Destroy;

end; // Destroy

procedure TcmxMP3.mciCheckError(aError: integer);

strMsg : string;

// exit if no error

if( aError = 0 )then Exit;

// get error message and raise exception

strMsg := mciGetErrorMessage( aError );

raise eMciDeviceError.CreateFmt( '%d - %s',[aError,strMsg] );

end; // mciCheckError

function TcmxMP3.mciGetErrorMessage(aError: integer): string;

ErrMsg : array[0..4095] of Char;

if( mciGetErrorString( aError,ErrMsg,SizeOf( ErrMsg ) ) )then

begin

SetString( Result,ErrMsg,StrLen( ErrMsg ) );

end // if

else

begin

Result := SMCIUnknownError;

end; // else

end; // mciGetErrorMessage

function TcmxMP3.mciLgthInSecs: integer;

intLength : integer;

intMM, intSS : integer;

{

mciOpen;

try

// set time format to milliseconds

mciSetTimeFormat( tfMilliseconds );

// get length of .mp3

intLength := mciGetLength;

// do the math to return number of seconds

intLength := intLength div 1000;

intMM := intLength div 60;

intSS := intLength mod 60;

Result := (intMM * 60) + intSS;

finally

mciClose;

end; // try finally

end; // mciLgthInSecs

procedure TcmxMP3.mciOpen;

OpenParm: TMCI_Open_Parms;

intFlags : integer;

intError : integer;

// close player if active

mciClose;

// open player

OpenParm.dwCallback := 0;

OpenParm.lpstrDeviceType := 'WaveAudio';

OpenParm.lpstrElementName := PChar( fFilePath );

intFlags := MCI_WAIT or MCI_OPEN_ELEMENT or MCI_OPEN_SHAREABLE;

intError := mciSendCommand( 0,mci_Open,intFlags,Longint( @OpenParm ) );

mciCheckError( intError );

// save device ID

fDeviceID := OpenParm.wDeviceID;

end; // mciOpen

procedure TcmxMP3.mciClose;

intFlags : integer;

intError : integer;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// close player

intFlags := MCI_WAIT;

intError := mciSendCommand( fDeviceID,mci_Close,intFlags,0 );

mciCheckError( intError );

// zero device ID

fDeviceID := 0;

end; // mciClose

function TcmxMP3.mciGetMode : TMPMode;

StatusParm: TMCI_Status_Parms;

intFlags : integer;

intError : integer;

// set initial result

Result := mpUnknown;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// get current state

intFlags := mci_Wait or mci_Status_Item;

StatusParm.dwItem := mci_Status_Mode;

intError := mciSendCommand( fDeviceID

,mci_Status,intFlags,Longint( @StatusParm ) );

mciCheckError( intError );

// set result

case StatusParm.dwReturn of

MCI_MODE_NOT_READY :

begin

Result := mpNotReady;

end; // MCI_MODE_NOT_READY

MCI_MODE_STOP :

begin

Result := mpStopped;

end; // MCI_MODE_STOP

MCI_MODE_PLAY :

begin

Result := mpPlaying;

end; // MCI_MODE_PLAY

MCI_MODE_RECORD :

begin

Result := mpRecording;

end; // MCI_MODE_RECORD

MCI_MODE_SEEK :

begin

Result := mpSeeking;

end; // MCI_MODE_SEEK

MCI_MODE_PAUSE :

begin

Result := mpPaused;

end; //

MCI_MODE_OPEN :

begin

Result := mpOpen;

end; // MCI_MODE_OPEN

end; // case

end; // mciGetMode

procedure TcmxMP3.mciSetTimeFormat(aValue : TMPTimeFormat);

SetParm: TMCI_Set_Parms;

intFlags : integer;

intError : integer;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// set player to return specified time format

intFlags := mci_Set_Time_Format;

SetParm.dwTimeFormat := Longint( aValue );

intError := mciSendCommand( fDeviceID

,mci_Set,intFlags,Longint( @SetParm ) );

mciCheckError( intError );

end; // mciSetTimeFormat

function TcmxMP3.mciGetLength : Longint;

StatusParm: TMCI_Status_Parms;

intFlags : integer;

intError : integer;

// set initial result

Result := 0;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// get length of .mp3

intFlags := mci_Wait or mci_Status_Item;

StatusParm.dwItem := mci_Status_Length;

intError := mciSendCommand( fDeviceID

,mci_Status,intFlags,Longint( @StatusParm ) );

mciCheckError( intError );

Result := StatusParm.dwReturn;

end; // mciGetLength

function TcmxMP3.mciGetPosition : Longint;

StatusParm: TMCI_Status_Parms;

intFlags : integer;

intError : integer;

// set initial result

Result := 0;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// get current position

intFlags := mci_Wait or mci_Status_Item;

StatusParm.dwItem := mci_Status_Position;

intError := mciSendCommand( fDeviceID

,mci_Status,intFlags,Longint( @StatusParm ) );

mciCheckError( intError );

Result := StatusParm.dwReturn;

end; // mciGetPosition

procedure TcmxMP3.mciPlay;

PlayParm : TMCI_Play_Parms;

intFlags : integer;

intError : integer;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

{

intFlags := mci_Notify;

PlayParm.dwCallback := fHWND;

intError := mciSendCommand(

fDeviceID,mci_Play,intFlags,Longint( @PlayParm ) );

mciCheckError( intError );

end; // mciPlay

procedure TcmxMP3.mciWndMethod(var Msg : TMessage);

// snag MCI notify message

if( Msg.Msg = MM_MCINOTIFY )then

begin

mciNotifyEvent( Msg );

end // if

// sink all other messages in the default window proc

else

begin

Msg.Result := DefWindowProc( fHWND,Msg.Msg,Msg.wParam,Msg.lParam );

end; // else

end; // mciWndMethod

procedure TcmxMP3.mciNotifyEvent(var Msg : TMessage);

case Msg.wParam of

// end of play has been reached

mci_Notify_Successful :

begin

// stop and close player

Stop;

// notify end of play

if( Assigned( fOnPlayComplete ) )then

begin

fOnPlayComplete( self );

end; // if

end; // mci_Notify_Successful

end; // case

end; // mciNotifyEvent

procedure TcmxMP3.mciStop;

intError : integer;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// do stop

intError := mciSendCommand( fDeviceID,mci_Stop,0,0 );

mciCheckError( intError );

end; // mciStop

procedure TcmxMP3.mciPause;

intError : integer;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// do pause

intError := mciSendCommand( fDeviceID,mci_Pause,0,0 );

mciCheckError( intError );

end; // mciPause

procedure TcmxMP3.mciResume;

intError : integer;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// do resume

intError := mciSendCommand( fDeviceID,mci_Resume,0,0 );

mciCheckError( intError );

end; // mciResume

procedure TcmxMP3.Play;

lMode : TMPMode;

// open player if not already open

if( fDeviceID = 0 )then mciOpen;

// get current state

lMode := State;

// if currently playing; stop player (to restart at the beginning)

if( lMode = mpPlaying )then Stop;

// play the .mp3

mciPlay;

// start progress thread

if( Assigned( fOnPlayProgress ) )then

begin

fProgressTimer := TcmxProgressThread.Create( OnProgressTimer );

end; // if

end; // Play

procedure TcmxMP3.Stop;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// stop the player

mciStop;

// terminate the progress thread

if( fProgressTimer <> nil )then

begin

fProgressTimer.Terminate;

fProgressTimer := nil;

end; // if

// close the player

mciClose;

end; // Stop

procedure TcmxMP3.Pause;

lMode : TMPMode;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// get current state

lMode := State;

{

if( lMode = mpPlaying )then

begin

mciPause;

if( fProgressTimer <> nil )then fProgressTimer.Suspend;

end; // else if

end; // Pause

procedure TcmxMP3.Resume;

lMode : TMPMode;

// exit if player is not active

if( fDeviceID = 0 )then Exit;

// get current state

lMode := State;

{

if( lMode = mpPaused )then

begin

mciResume;

if( fProgressTimer <> nil )then fProgressTimer.Resume;

end; // if

end; // Resume

function TcmxMP3.getState: TMPMode;

// get current state

Result := mciGetMode;

end; // getState

function TcmxMP3.id3Init : TcmxID3;

FillChar( Result,SizeOf( Result ),0 );

Result.Tag := 'TAG';

end; // id3Init

function TcmxMP3.id3Get : TcmxID3;

lMP3: TFileStream;

// read the end of the file

lMP3 := TFileStream.Create( fFilePath,fmOpenRead ) ;

try

lMP3.Position := lMP3.Size - SizeOf( Result );

lMP3.Read( Result,SizeOf( Result ) );

finally

lMP3.Free;

end; // try finally

// if result isn't a valid ID3 record; return initialized record

if( Result.Tag <> 'TAG' )then

begin

Result := id3Init;

end; // if

end; // id3Get

procedure TcmxMP3.id3Put(aID3: TcmxID3);

lMP3: file of Byte;

OldID3 : TcmxID3;

// open the .mp3 file

AssignFile( lMP3,fFilePath );

Reset( lMP3 );

try

// find the end of the file

Seek( lMP3,FileSize( lMP3 ) - SizeOf( OldID3 ) );

// read the ID3 record

BlockRead( lMP3,OldID3,SizeOf( OldID3 ) );

// is the record valid?

if( OldID3.Tag = 'TAG' )then

begin

// re-position for write

Seek( lMP3,FileSize( lMP3 ) - SizeOf( OldID3 ) );

end // if

else

begin

// position to the end for write

Seek( lMP3,FileSize( lMP3 ) );

end; // else

// write the new ID3 record

BlockWrite( lMP3,aID3,SizeOf( aID3 ) );

finally

// close the .mp3 file

CloseFile( lMP3 );

end; // try finally

end; // id3Put

function TcmxMP3.ChgFilePath(const aFilePath, aFileName: string) : boolean;

strNewPath : string;

{

strNewPath := IncludeTrailingBackSlash( aFilePath )

+ aFileName + '.mp3';

strNewPath := IncludeTrailingPathDelimiter( aFilePath )

+ aFileName + '.mp3';

// rename (or move) the file

Result := MoveFile( PChar( fFilePath ),PChar( strNewPath ) );

// if rename is successful; save new path name

if( Result )then

begin

fFilePath := strNewPath;

end; // if

end; // ChgFilePath

function TcmxMP3.getFileName: string;

// return name of file (no path; no extension)

Result := ChangeFileExt( ExtractFileName( fFilePath ),'' );

end; // getFileName

function TcmxMP3.getFilePath: string;

// return file path only

Result := ExtractFilePath( fFilePath );

end; // getFilePath

function TcmxMP3.getAlbum: string;

Result := fID3.Album;

end; // getAlbum

function TcmxMP3.getArtist: string;

Result := fID3.Artist;

end; // getArtist

function TcmxMP3.getComment: string;

Result := fID3.Comment;

end; // getComment

function TcmxMP3.getTitle: string;

Result := fID3.Title;

end; // getTitle

function TcmxMP3.getYear: string;

Result := fID3.Year;

end; // getYear

function TcmxMP3.getTrack: byte;

Result := fID3.Track;

end; // getTrack

function TcmxMP3.getGenreNdx: byte;

Result := fID3.Genre;

end; // getGenreNdx

procedure TcmxMP3.ChgID3(const aTitle, aArtist, aAlbum, aComment: string;

aYear: integer; aTrack, aGenre: byte);

lID3 : TcmxID3;

// initialize ID3 record structure

lID3 := id3Init;

// fill values

StrPCopy( lID3.Title,aTitle );

StrPCopy( lID3.Artist,aArtist );

StrPCopy( lID3.Album,aAlbum );

StrPCopy( lID3.Year,IntToStr( aYear ) );

StrPCopy( lID3.Comment,aComment );