So bearbeiten Sie MP3-Datei Details (Delphi)

Question

Wie kann ich MP3-Datei Details, wie Beschreibung, Titel, Untertitel, Bewertung, Künstler, ... mit Delphi bearbeiten. Gibt es irgendeine Komponente, um dies zu tun?

Danke

Answer 1

Sie können wahrscheinlich nicht nur ID3V1, sondern ID3V2 auch manipulieren.

so ist diese Bibliothek, die Sie möglicherweise

http://www.3delite.hu/Object Pascal Developer Resources/id3v2library.html helfen

Answer 2

einen Blick auf id3mgmnt.pas nehmen, es sieht aus wie das, was du bist für.

Noch nie getestet, nur erste Google Ergebnis veröffentlichen.

Answer 3

Ich erinnere mich nicht, wo ich dieses Gerät bekam aus, aber ich habe es für ein Haustier Projekt vor einer Weile:

unit ID3v2; 

interface 

uses 
    Classes, SysUtils; 

const 
    TAG_VERSION_2_3 = 3;        { Code for 
ID3v2.3.0 tag } 

type 
    { Class TID3v2 } 
    TID3v2 = class(TObject) 
    private 
     { Private declarations } 
     FExists: Boolean; 
     FVersionID: Byte; 
     FSize: Integer; 
     FTitle: string; 
     FArtist: string; 
     FAlbum: string; 
     FTrack: Byte; 
     FYear: string; 
     FGenre: string; 
     FComment: string; 
    public 
     { Public declarations } 
     constructor Create;          { Create 
object } 
     procedure ResetData;         { Reset 
all data } 
     function ReadFromFile(const FileName: string): Boolean;  { 
Load tag } 
     property Exists: Boolean read FExists;    { True if tag 
found } 
     property VersionID: Byte read FVersionID;    { 
Version code } 
     property Size: Integer read FSize;      { Total 
tag size } 
     property Title: string read FTitle;      { Song 
title } 
     property Artist: string read FArtist;      { 
Artist name } 
     property Album: string read FAlbum;      { 
Album name } 
     property Track: Byte read FTrack;      { Track 
number } 
     property Year: string read FYear; 
{ Year } 
     property Genre: string read FGenre;      { 
Genre name } 
     property Comment: string read FComment;      { 
Comment } 
    end; 

implementation 

const 
    { Max. number of supported tag frames } 
    ID3V2_FRAME_COUNT = 7; 

    { Names of supported tag frames } 
    ID3V2_FRAME: array [1..ID3V2_FRAME_COUNT] of string = 
    ('TIT2', 'TPE1', 'TALB', 'TRCK', 'TYER', 'TCON', 'COMM'); 

type 
    { ID3v2 frame header } 
    FrameHeader = record 
    ID: array [1..4] of AnsiChar;          { 
Frame ID } 
    Size: Integer;         { Size excluding 
header } 
    Flags: Word;              { 
Flags } 
    end; 

    { ID3v2 header data - for internal use } 
    TagInfo = record 
    { Real structure of ID3v2 header } 
    ID: array [1..3] of AnsiChar;         { Always 
"ID3" } 
    Version: Byte;           { Version 
number } 
    Revision: Byte;           { Revision 
number } 
    Flags: Byte;            { Flags 
of tag } 
    Size: array [1..4] of Byte;     { Tag size excluding 
header } 
    { Extended data } 
    FileSize: Integer;         { File size 
(bytes) } 
    Frame: array [1..ID3V2_FRAME_COUNT] of string; { Information from 
frames } 
    end; 

{ ********************* Auxiliary functions & procedures 
******************** } 

function ReadHeader(const FileName: string; var Tag: TagInfo): Boolean; 
var 
    SourceFile: file; 
    Transferred: Integer; 
begin 
    try 
    Result := true; 
    { Set read-access and open file } 
    AssignFile(SourceFile, FileName); 
    FileMode := 0; 
    Reset(SourceFile, 1); 
    { Read header and get file size } 
    BlockRead(SourceFile, Tag, 10, Transferred); 
    Tag.FileSize := FileSize(SourceFile); 
    CloseFile(SourceFile); 
    { if transfer is not complete } 
    if Transferred < 10 then Result := false; 
    except 
    { Error } 
    Result := false; 
    end; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

function GetVersionID(const Tag: TagInfo): Byte; 
begin 
    { Get tag version from header } 
    Result := Tag.Version; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

function GetTagSize(const Tag: TagInfo): Integer; 
begin 
    { Get total tag size } 
    Result := 
    Tag.Size[1] * $200000 + 
    Tag.Size[2] * $4000 + 
    Tag.Size[3] * $80 + 
    Tag.Size[4] + 10; 
    if Result > Tag.FileSize then Result := 0; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

procedure SetTagItem(const ID, Data: string; var Tag: TagInfo); 
var 
    Iterator: Byte; 
begin 
    { Set tag item if supported frame found } 
    for Iterator := 1 to ID3V2_FRAME_COUNT do 
    if ID3V2_FRAME[Iterator] = ID then Tag.Frame[Iterator] := Data; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

function Swap32(const Figure: Integer): Integer; 
var 
    ByteArray: array [1..4] of Byte absolute Figure; 
begin 
    { Swap 4 bytes } 
    Result := 
    ByteArray[1] * $100000000 + 
    ByteArray[2] * $10000 + 
    ByteArray[3] * $100 + 
    ByteArray[4]; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

procedure ReadFrames(const FileName: string; var Tag: TagInfo); 
var 
    SourceFile: file; 
    Frame: FrameHeader; 
    Data: array [1..250] of AnsiChar; 
    DataPosition: Integer; 
begin 
    try 
    { Set read-access, open file } 
    AssignFile(SourceFile, FileName); 
    FileMode := 0; 
    Reset(SourceFile, 1); 
    Seek(SourceFile, 10); 
    while (FilePos(SourceFile) < GetTagSize(Tag)) and (not 
EOF(SourceFile)) do 
    begin 
     FillChar(Data, SizeOf(Data), 0); 
     { Read frame header } 
     BlockRead(SourceFile, Frame, 10); 
     DataPosition := FilePos(SourceFile); 
     { Read frame data and set tag item if frame supported } 
     BlockRead(SourceFile, Data, Swap32(Frame.Size) mod SizeOf(Data)); 
     SetTagItem(Frame.ID, Data, Tag); 
     Seek(SourceFile, DataPosition + Swap32(Frame.Size)); 
    end; 
    CloseFile(SourceFile); 
    except 
    end; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

function GetTrack(const TrackString: string): Byte; 
var 
    Index, Value, Code: Integer; 
begin 
    { Extract track from string } 
    Index := Pos('/', TrackString); 
    if Index = 0 then Val(Trim(TrackString), Value, Code) 
    else Val(Copy(Trim(TrackString), 1, Index), Value, Code); 
    if Code = 0 then Result := Value 
    else Result := 0; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

function GetGenre(const GenreString: string): string; 
begin 
    { Extract genre from string } 
    Result := Trim(GenreString); 
    if Pos(')', Result) > 0 then Delete(Result, 1, LastDelimiter(')', 
Result)); 
end; 

{ ********************** Public functions & procedures 
********************** } 

constructor TID3v2.Create; 
begin 
    inherited; 
    ResetData; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

procedure TID3v2.ResetData; 
begin 
    FExists := false; 
    FVersionID := 0; 
    FSize := 0; 
    FTitle := ''; 
    FArtist := ''; 
    FAlbum := ''; 
    FTrack := 0; 
    FYear := ''; 
    FGenre := ''; 
    FComment := ''; 
end; 

{ 
--------------------------------------------------------------------------- 

} 

function TID3v2.ReadFromFile(const FileName: string): Boolean; 
var 
    Tag: TagInfo; 
begin 
    { Reset data and load header from file to variable } 
    ResetData; 
    Result := ReadHeader(FileName, Tag); 
    { Process data if loaded and header valid } 
    if (Result) and (Tag.ID = 'ID3') then 
    begin 
    FExists := true; 
    { Fill properties with header data } 
    FVersionID := GetVersionID(Tag); 
    FSize := GetTagSize(Tag); 
    { Get information from frames if version supported } 
    if (FVersionID = TAG_VERSION_2_3) and (FSize > 0) then 
    begin 
     ReadFrames(FileName, Tag); 
     { Fill properties with data from frames } 
     FTitle := Trim(Tag.Frame[1]); 
     FArtist := Trim(Tag.Frame[2]); 
     FAlbum := Trim(Tag.Frame[3]); 
     FTrack := GetTrack(Tag.Frame[4]); 
     FYear := Trim(Tag.Frame[5]); 
     FGenre := GetGenre(Tag.Frame[6]); 
     FComment := Trim(Copy(Tag.Frame[7], 5, Length(Tag.Frame[7]) - 4)); 
    end; 
    end; 
end; 

end. 

Answer 4

können Sie TJvID3v1 oder TJvID3v2 Komponenten verwenden, um von http://www.delphi-jedi.org/

Answer 5

ich benutzte Teile Jürgen Faul Bibliothek Audio tools vor einer Weile. Es ist ein bisschen alt (2002), aber diese Bibliothek wurde von anderen Leuten bis 2005 gepflegt. Sie können die alte Version 2002 von verschiedenen Komponenten-Repositories erhalten oder die "neueste" Version von http://mac.sourceforge.net/atl/ bekommen. Ich weiß nicht, ob diese dem neuesten ID3-Standard entsprechen, aber der Code 2002 holt immer noch Daten aus MP3-Dateien für mein altes Audio-Player-Projekt.

@ioan: Die von Ihnen gepostete Einheit stammt tatsächlich aus einer Version dieser Bibliothek.