开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
mpegaudio.pas
资源名称：DelphiSWFSDK2[1].4.rar　[点击查看]
上传用户：raido2005
上传日期：2022-06-22
资源大小：5044k
文件大小：46k
源码类别：

Delphi控件源码

开发平台：

Delphi

mpegaudio.pas：源码内容
  1. { *************************************************************************** }
  2. {                                                                             }
  3. { Audio Tools Library (Freeware)                                              }
  4. { Class TMPEGaudio - for manipulating with MPEG audio file information        }
  5. {                                                                             }
  6. { Uses:                                                                       }
  7. {   - Class TID3v1                                                            }
  8. {   - Class TID3v2                                                            }
  9. {                                                                             }
  10. { Copyright (c) 2001 by Jurgen Faul                                           }
  11. { E-mail: jfaul@gmx.de                                                        }
  12. { http://jfaul.de/atl                                                         }
  13. {                                                                             }
  14. { Version 1.0 (31 August 2001)                                                }
  15. {   - Support for MPEG audio (versions 1, 2, 2.5, layers I, II, III)          }
  16. {   - Support for Xing & FhG VBR                                              }
  17. {   - Ability to guess audio encoder (Xing, FhG, LAME, Blade, GoGo, Shine)    }
  18. {   - Class TID3v1: reading & writing support for ID3v1.x tags                }
  19. {   - Class TID3v2: reading support for ID3v2.3.x tags                        }
  20. {                                                                             }
  21. { 11 mar 2007  - Add ReadFromStream mathod by DelphiFlash.com                 }
  22. { 10 mar 2008  - some bugs fixed                                              }
  23. {                                                                             }
  24. { *************************************************************************** }
  26. unit MPEGaudio;
  28. interface
  30. uses
  31.   Windows, Classes, SysUtils, Contnrs;
  33. const
  34.   { Table for bit rates }
  35.   MPEG_BIT_RATE: array [0..3, 0..3, 0..15] of Word =
  36.     (
  37.     { For MPEG 2.5 }
  38.     ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
  39.     (0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0),
  40.     (0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0),
  41.     (0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0)),
  42.     { Reserved }
  43.     ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
  44.     (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
  45.     (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
  46.     (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)),
  47.     { For MPEG 2 }
  48.     ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
  49.     (0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0),
  50.     (0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0),
  51.     (0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0)),
  52.     { For MPEG 1 }
  53.     ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
  54.     (0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0),
  55.     (0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0),
  56.     (0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0))
  57.     );
  59.   { Sample rate codes }
  60.   MPEG_SAMPLE_RATE_LEVEL_3 = 0;                                     { Level 3 }
  61.   MPEG_SAMPLE_RATE_LEVEL_2 = 1;                                     { Level 2 }
  62.   MPEG_SAMPLE_RATE_LEVEL_1 = 2;                                     { Level 1 }
  63.   MPEG_SAMPLE_RATE_UNKNOWN = 3;                               { Unknown value }
  65.   { Table for sample rates }
  66.   MPEG_SAMPLE_RATE: array [0..3, 0..3] of Word =
  67.     (
  68.     (11025, 12000, 8000, 0),                                   { For MPEG 2.5 }
  69.     (0, 0, 0, 0),                                                  { Reserved }
  70.     (22050, 24000, 16000, 0),                                    { For MPEG 2 }
  71.     (44100, 48000, 32000, 0)                                     { For MPEG 1 }
  72.     );
  74.   { VBR header ID for Xing/FhG }
  75.   VBR_ID_XING = 'Xing';                                         { Xing VBR ID }
  76.   VBR_ID_FHG = 'VBRI';                                           { FhG VBR ID }
  77.   VBR_ID_INFO = 'Info';
  79.   { MPEG version codes }
  80.   MPEG_VERSION_2_5 = 0;                                            { MPEG 2.5 }
  81.   MPEG_VERSION_UNKNOWN = 1;                                 { Unknown version }
  82.   MPEG_VERSION_2 = 2;                                                { MPEG 2 }
  83.   MPEG_VERSION_1 = 3;                                                { MPEG 1 }
  85.   { MPEG version names }
  86.   MPEG_VERSION: array [0..3] of string =
  87.     ('MPEG 2.5', 'MPEG ?', 'MPEG 2', 'MPEG 1');
  89.   { MPEG layer codes }
  90.   MPEG_LAYER_UNKNOWN = 0;                                     { Unknown layer }
  91.   MPEG_LAYER_III = 1;                                             { Layer III }
  92.   MPEG_LAYER_II = 2;                                               { Layer II }
  93.   MPEG_LAYER_I = 3;                                                 { Layer I }
  95.   { MPEG layer names }
  96.   MPEG_LAYER: array [0..3] of string =
  97.     ('Layer ?', 'Layer III', 'Layer II', 'Layer I');
  99.   { Channel mode codes }
  100.   MPEG_CM_STEREO = 0;                                                { Stereo }
  101.   MPEG_CM_JOINT_STEREO = 1;                                    { Joint Stereo }
  102.   MPEG_CM_DUAL_CHANNEL = 2;                                    { Dual Channel }
  103.   MPEG_CM_MONO = 3;                                                    { Mono }
  104.   MPEG_CM_UNKNOWN = 4;                                         { Unknown mode }
  106.   { Channel mode names }
  107.   MPEG_CM_MODE: array [0..4] of string =
  108.     ('Stereo', 'Joint Stereo', 'Dual Channel', 'Mono', 'Unknown');
  110.   { Extension mode codes (for Joint Stereo) }
  111.   MPEG_CM_EXTENSION_OFF = 0;                        { IS and MS modes set off }
  112.   MPEG_CM_EXTENSION_IS = 1;                             { Only IS mode set on }
  113.   MPEG_CM_EXTENSION_MS = 2;                             { Only MS mode set on }
  114.   MPEG_CM_EXTENSION_ON = 3;                          { IS and MS modes set on }
  115.   MPEG_CM_EXTENSION_UNKNOWN = 4;                     { Unknown extension mode }
  117.   { Emphasis mode codes }
  118.   MPEG_EMPHASIS_NONE = 0;                                              { None }
  119.   MPEG_EMPHASIS_5015 = 1;                                          { 50/15 ms }
  120.   MPEG_EMPHASIS_UNKNOWN = 2;                               { Unknown emphasis }
  121.   MPEG_EMPHASIS_CCIT = 3;                                         { CCIT J.17 }
  123.   { Emphasis names }
  124.   MPEG_EMPHASIS: array [0..3] of string =
  125.     ('None', '50/15 ms', 'Unknown', 'CCIT J.17');
  127.   { Encoder codes }
  128.   MPEG_ENCODER_UNKNOWN = 0;                                 { Unknown encoder }
  129.   MPEG_ENCODER_XING = 1;                                               { Xing }
  130.   MPEG_ENCODER_FHG = 2;                                                 { FhG }
  131.   MPEG_ENCODER_LAME = 3;                                               { LAME }
  132.   MPEG_ENCODER_BLADE = 4;                                             { Blade }
  133.   MPEG_ENCODER_GOGO = 5;                                               { GoGo }
  134.   MPEG_ENCODER_SHINE = 6;                                             { Shine }
  136.   { Encoder names }
  137.   MPEG_ENCODER: array [0..6] of string =
  138.     ('Unknown', 'Xing', 'FhG', 'LAME', 'Blade', 'GoGo', 'Shine');
  140.   TAG_VERSION_1_0 = 1;                                { Index for ID3v1.0 tag }
  141.   TAG_VERSION_1_1 = 2;                                { Index for ID3v1.1 tag }
  142.   TAG_VERSION_2_3 = 3;                               { Code for ID3v2.3.0 tag }
  144.   { Max. number of supported tag frames }
  145.   ID3V2_FRAME_COUNT = 7;
  147.   { Names of supported tag frames }
  148.   ID3V2_FRAME: array [1..ID3V2_FRAME_COUNT] of string =
  149.     ('TIT2', 'TPE1', 'TALB', 'TRCK', 'TYER', 'TCON', 'COMM');
  151.   MAX_MUSIC_GENRES = 148;                       { Max. number of music genres }
  152.   DEFAULT_GENRE = 255;                              { Index for default genre }
  154. var
  155.   MusicGenre: array [0..MAX_MUSIC_GENRES - 1] of PChar =        { Genre names }
  156.     ({ Standard genres }
  157.      'Blues', 'Classic Rock', 'Country', 'Dance', 'Disco', 'Funk', 'Grunge', 'Hip-Hop', 'Jazz', 'Metal',
  158.      'New Age',  'Oldies', 'Other', 'Pop', 'R&B', 'Rap', 'Reggae', 'Rock', 'Techno', 'Industrial',
  159.      'Alternative', 'Ska', 'Death Metal', 'Pranks', 'Soundtrack', 'Euro-Techno', 'Ambient', 'Trip-Hop',
  160.      'Vocal', 'Jazz+Funk', 'Fusion', 'Trance', 'Classical', 'Instrumental', 'Acid', 'House', 'Game',
  161.      'Sound Clip', 'Gospel', 'Noise', 'AlternRock', 'Bass', 'Soul', 'Punk', 'Space', 'Meditative',
  162.      'Instrumental Pop', 'Instrumental Rock', 'Ethnic', 'Gothic', 'Darkwave', 'Techno-Industrial',
  163.      'Electronic', 'Pop-Folk', 'Eurodance', 'Dream', 'Southern Rock', 'Comedy', 'Cult', 'Gangsta',
  164.      'Top 40', 'Christian Rap', 'Pop/Funk', 'Jungle', 'Native American', 'Cabaret', 'New Wave',
  165.      'Psychadelic', 'Rave', 'Showtunes', 'Trailer', 'Lo-Fi', 'Tribal', 'Acid Punk', 'Acid Jazz',
  166.      'Polka', 'Retro', 'Musical', 'Rock & Roll', 'Hard Rock',
  167.      { Extended genres }
  168.      'Folk', 'Folk-Rock', 'National Folk', 'Swing', 'Fast Fusion', 'Bebob', 'Latin', 'Revival',
  169.      'Celtic', 'Bluegrass', 'Avantgarde', 'Gothic Rock', 'Progessive Rock', 'Psychedelic Rock',
  170.      'Symphonic Rock', 'Slow Rock', 'Big Band', 'Chorus', 'Easy Listening', 'Acoustic', 'Humour',
  171.      'Speech', 'Chanson', 'Opera', 'Chamber Music', 'Sonata', 'Symphony', 'Booty Bass', 'Primus',
  172.      'Porn Groove', 'Satire', 'Slow Jam', 'Club', 'Tango', 'Samba', 'Folklore', 'Ballad', 'Power Ballad',
  173.      'Rhythmic Soul', 'Freestyle', 'Duet', 'Punk Rock', 'Drum Solo', 'A capella', 'Euro-House',
  174.      'Dance Hall', 'Goa', 'Drum & Bass', 'Club-House', 'Hardcore', 'Terror', 'Indie', 'BritPop',
  175.      'Negerpunk', 'Polsk Punk', 'Beat', 'Christian Gangsta Rap', 'Heavy Metal', 'Black Metal',
  176.      'Crossover', 'Contemporary Christian', 'Christian Rock', 'Merengue', 'Salsa', 'Trash Metal',
  177.      'Anime', 'JPop', 'Synthpop');
  179. type
  180.   { Used in TID3v1 class }
  181.   String04 = string[4];                          { String with max. 4 symbols }
  182.   String30 = string[30];                        { String with max. 30 symbols }
  185.   { Xing/FhG VBR header data }
  186.   VBRData = record
  187.     Found: Boolean;                                { True if VBR header found }
  188.     ID: array [1..4] of Char;                   { Header ID: "Xing" or "VBRI" }
  189.     Frames: longint;                                 { Total number of frames }
  190.     Bytes: longint;                                   { Total number of bytes }
  191.     Scale: Byte;                                         { VBR scale (1..100) }
  192.     VendorID: array [1..8] of Char;                  { Vendor ID (if present) }
  193.   end;
  195.   { MPEG frame header data}
  196.   FrameData = record
  197.     Found: Boolean;                                     { True if frame found }
  198.     Position: Integer;                           { Frame position in the file }
  199.     Size: Word;                                          { Frame size (bytes) }
  200.     Empty: Boolean;                       { True if no significant frame data }
  201.     Data: array [1..4] of Byte;                 { The whole frame header data }
  202.     VersionID: Byte;                                        { MPEG version ID }
  203.     LayerID: Byte;                                            { MPEG layer ID }
  204.     ProtectionBit: Boolean;                        { True if protected by CRC }
  205.     BitRateID: Word;                                            { Bit rate ID }
  206.     SampleRateID: Word;                                      { Sample rate ID }
  207.     PaddingBit: Boolean;                               { True if frame padded }
  208.     PrivateBit: Boolean;                                  { Extra information }
  209.     ModeID: Byte;                                           { Channel mode ID }
  210.     ModeExtensionID: Byte;             { Mode extension ID (for Joint Stereo) }
  211.     CopyrightBit: Boolean;                        { True if audio copyrighted }
  212.     OriginalBit: Boolean;                            { True if original media }
  213.     EmphasisID: Byte;                                           { Emphasis ID }
  214.   end;
  216.   { Real structure of ID3v1 tag }
  217.   TagID3v1 = record
  218.     Header: array [1..3] of Char;                { Tag header - must be "TAG" }
  219.     Title: array [1..30] of Char;                                { Title data }
  220.     Artist: array [1..30] of Char;                              { Artist data }
  221.     Album: array [1..30] of Char;                                { Album data }
  222.     Year: array [1..4] of Char;                                   { Year data }
  223.     Comment: array [1..30] of Char;                            { Comment data }
  224.     Genre: Byte;                                                 { Genre data }
  225.   end;
  227.     { ID3v2 header data - for internal use }
  228.   TagID3v2 = record
  229.     { Real structure of ID3v2 header }
  230.     ID: array [1..3] of Char;                                  { Always "ID3" }
  231.     Version: Byte;                                           { Version number }
  232.     Revision: Byte;                                         { Revision number }
  233.     Flags: Byte;                                               { Flags of tag }
  234.     Size: array [1..4] of Byte;                   { Tag size excluding header }
  235.     { Extended data }
  236.     FileSize: Integer;                                    { File size (bytes) }
  237.     Frame: array [1..ID3V2_FRAME_COUNT] of string;  { Information from frames }
  238.   end;
  240.   TID3v1 = class(TObject)
  241.     private
  242.       { Private declarations }
  243.       FExists: Boolean;
  244.       FVersionID: Byte;
  245.       FTitle: String30;
  246.       FArtist: String30;
  247.       FAlbum: String30;
  248.       FYear: String04;
  249.       FComment: String30;
  250.       FTrack: Byte;
  251.       FGenreID: Byte;
  252.     FSize: longint;
  253.       procedure FSetTitle(const NewTitle: String30);
  254.       procedure FSetArtist(const NewArtist: String30);
  255.       procedure FSetAlbum(const NewAlbum: String30);
  256.       procedure FSetYear(const NewYear: String04);
  257.       procedure FSetComment(const NewComment: String30);
  258.       procedure FSetTrack(const NewTrack: Byte);
  259.       procedure FSetGenreID(const NewGenreID: Byte);
  260.       function FGetGenre: string;
  261.     public
  262.       { Public declarations }
  263.       constructor Create;                                     { Create object }
  264.       procedure ResetData;                                   { Reset all data }
  265.       function ReadFromFile(const FileName: string): Boolean;      { Load tag }
  266.       function ReadFromStream(Src: TStream): Boolean;
  267.       property Size: longint read FSize;
  268.       property Exists: Boolean read FExists;              { True if tag found }
  269.       property VersionID: Byte read FVersionID;                { Version code }
  270.       property Title: String30 read FTitle write FSetTitle;      { Song title }
  271.       property Artist: String30 read FArtist write FSetArtist;  { Artist name }
  272.       property Album: String30 read FAlbum write FSetAlbum;      { Album name }
  273.       property Year: String04 read FYear write FSetYear;               { Year }
  274.       property Comment: String30 read FComment write FSetComment;   { Comment }
  275.       property Track: Byte read FTrack write FSetTrack;        { Track number }
  276.       property GenreID: Byte read FGenreID write FSetGenreID;    { Genre code }
  277.       property Genre: string read FGetGenre;                     { Genre name }
  278.   end;
  280.   
  281.   TID3v2 = class(TObject)
  282.     private
  283.       { Private declarations }
  284.       FExists: Boolean;
  285.       FVersionID: Byte;
  286.       FSize: Integer;
  287.       FTitle: string;
  288.       FArtist: string;
  289.       FAlbum: string;
  290.       FTrack: Byte;
  291.       FYear: string;
  292.       FGenre: string;
  293.       FComment: string;
  294.     public
  295.       { Public declarations }
  296.       constructor Create;                                     { Create object }
  297.       procedure ResetData;                                   { Reset all data }
  298.       function ReadFromStream(Src: TStream): boolean;
  299.       function ReadFromFile(const FileName: string): Boolean;      { Load tag }
  300.       property Exists: Boolean read FExists;              { True if tag found }
  301.       property VersionID: Byte read FVersionID;                { Version code }
  302.       property Size: Integer read FSize;                     { Total tag size }
  303.       property Title: string read FTitle;                        { Song title }
  304.       property Artist: string read FArtist;                     { Artist name }
  305.       property Album: string read FAlbum;                        { Album name }
  306.       property Track: Byte read FTrack;                        { Track number }
  307.       property Year: string read FYear;                                { Year }
  308.       property Genre: string read FGenre;                        { Genre name }
  309.       property Comment: string read FComment;                       { Comment }
  310.   end;
  312.   TMP3FrameInfo = class (TObject)
  313.   private
  314.     FPosition: longint;
  315.     FSize: Word;
  316.     FisSound: boolean;
  317.     FHeader: DWord;
  318.   public
  319.     property Header: DWord read FHeader write FHeader;
  320.     property Position: longint read FPosition write FPosition;
  321.     property Size: Word read FSize write FSize;
  322.     property isSound: boolean read FisSound write FisSound;
  323.   end;
  325.   { Class TMPEGaudio }
  326.   TMPEGaudio = class(TObject)
  327.     private
  328.       { Private declarations }
  329.       FFramesPos: TObjectList;
  330.       FFileLength: Integer;
  331.       FWaveHeader: Boolean;
  332.       FVBR: VBRData;
  333.       FFrame: FrameData;
  334.       FID3v1: TID3v1;
  335.       FID3v2: TID3v2;
  336.     FSoundFrameCount: longint;
  337.       procedure FResetData;
  338.       function FGetVersion: string;
  339.       function FGetLayer: string;
  340.       function FGetBitRate: Word;
  341.       function FGetSampleRate: Word;
  342.       function FGetChannelMode: string;
  343.       function FGetEmphasis: string;
  344.       function FGetFrames: Integer;
  345.       function FGetDuration: Double;
  346.       function FGetVBREncoderID: Byte;
  347.       function FGetCBREncoderID: Byte;
  348.       function FGetEncoderID: Byte;
  349.       function FGetEncoder: string;
  350.       function FGetValid: Boolean;
  351.     function GetMP3FrameInfo(index: Integer): TMP3FrameInfo;
  352.     protected
  353.       procedure EnumFrames(Src: TStream);
  354.     public
  355.       SkipCount: integer;
  356.       { Public declarations }
  357.       constructor Create;                                     { Create object }
  358.       destructor Destroy; override;                          { Destroy object }
  359.       function ReadFromFile(const FileName: string): Boolean;     { Load data }
  360.       function ReadFromStream(Src: TStream): boolean;
  361.       function isMP3File(const FileName: string): Boolean;   {check MP3 format}
  362.       property FileLength: Integer read FFileLength;    { File length (bytes) }
  363.       property FrameInfo[index: longint]: TMP3FrameInfo read GetMP3FrameInfo;
  364.       property VBR: VBRData read FVBR;                      { VBR header data }
  365.       property FirstFrame: FrameData read FFrame;         { Frame header data }
  366.       property ID3v1: TID3v1 read FID3v1;                    { ID3v1 tag data }
  367.       property ID3v2: TID3v2 read FID3v2;                    { ID3v2 tag data }
  368.       property Version: string read FGetVersion;          { MPEG version name }
  369.       property Layer: string read FGetLayer;                { MPEG layer name }
  370.       property BitRate: Word read FGetBitRate;            { Bit rate (kbit/s) }
  371.       property SampleRate: Word read FGetSampleRate;       { Sample rate (hz) }
  372.       property ChannelMode: string read FGetChannelMode;  { Channel mode name }
  373.       property Emphasis: string read FGetEmphasis;            { Emphasis name }
  374.       property FrameCount: longint read FGetFrames;  { Total number of frames }
  375.       property SoundFrameCount: longint read FSoundFrameCount;
  376.       property Duration: Double read FGetDuration;      { Song duration (sec) }
  377.       property EncoderID: Byte read FGetEncoderID;       { Guessed encoder ID }
  378.       property Encoder: string read FGetEncoder;       { Guessed encoder name }
  379.       property Valid: Boolean read FGetValid;       { True if MPEG file valid }
  380.   end;
  382.   procedure DecodeHeader(const HeaderData: array of Byte; var Frame: FrameData);
  383.   function GetFrameLength(const Frame: FrameData): Word;
  385. implementation
  386. type
  387.   MP3FrameHeader = record
  388.     ID: array [1..4] of Char;                                      { Frame ID }
  389.     Size: Integer;                                    { Size excluding header }
  390.     Flags: Word;                                                      { Flags }
  391.   end;
  393. const
  394.   { Limitation constants }
  395.   MAX_MPEG_FRAME_LENGTH = 1729;                      { Max. MPEG frame length }
  396.   MIN_MPEG_BIT_RATE = 8;                                { Min. bit rate value }
  397.   MAX_MPEG_BIT_RATE = 448;                              { Max. bit rate value }
  398.   MIN_ALLOWED_DURATION = 0.1;                      { Min. song duration value }
  400.   { VBR Vendor ID strings }
  401.   VBR_VENDOR_ID_LAME = 'LAME';                                     { For LAME }
  402.   VBR_VENDOR_ID_GOGO_NEW = 'GOGO';                           { For GoGo (New) }
  403.   VBR_VENDOR_ID_GOGO_OLD = 'MPGE';                           { For GoGo (Old) }
  405.   VBR_Lame_Track = 'UUUU';
  406. { ********************* Auxiliary functions & procedures ******************** }
  408. function WaveHeaderPresent(const Index: Integer; Data: array of Byte): Boolean;
  409. begin
  410.   { Check for WAV header }
  411.   Result :=
  412.     (Chr(Data[Index + 8]) = 'W') and
  413.     (Chr(Data[Index + 9]) = 'A') and
  414.     (Chr(Data[Index + 10]) = 'V') and
  415.     (Chr(Data[Index + 11]) = 'E');
  416. end;
  418. { --------------------------------------------------------------------------- }
  420. function IsFrameHeader(const HeaderData: array of Byte): Boolean;
  421. begin
  422.   { Check for valid frame header }
  423.   if ((HeaderData[0] and $FF) <> $FF) or
  424.     ((HeaderData[1] and $E0) <> $E0) or
  425.     (((HeaderData[1] shr 3) and 3) = 1) or
  426.     (((HeaderData[1] shr 1) and 3) = 0) or
  427.     ((HeaderData[2] and $F0) = $F0) or
  428.     ((HeaderData[2] and $F0) = 0) or
  429.     (((HeaderData[2] shr 2) and 3) = 3) or
  430.     ((HeaderData[3] and 3) = 2) then
  431.     Result := false
  432.   else
  433.     Result := true;
  434. end;
  436. { --------------------------------------------------------------------------- }
  438. procedure DecodeHeader(const HeaderData: array of Byte; var Frame: FrameData);
  439. begin
  440.   { Decode frame header data }
  441.   Move(HeaderData, Frame.Data, SizeOf(Frame.Data));
  442.   Frame.VersionID := (HeaderData[1] shr 3) and 3;
  443.   Frame.LayerID := (HeaderData[1] shr 1) and 3;
  444.   Frame.ProtectionBit := (HeaderData[1] and 1) <> 1;
  445.   Frame.BitRateID := HeaderData[2] shr 4;
  446.   Frame.SampleRateID := (HeaderData[2] shr 2) and 3;
  447.   Frame.PaddingBit := ((HeaderData[2] shr 1) and 1) = 1;
  448.   Frame.PrivateBit := (HeaderData[2] and 1) = 1;
  449.   Frame.ModeID := (HeaderData[3] shr 6) and 3;
  450.   Frame.ModeExtensionID := (HeaderData[3] shr 4) and 3;
  451.   Frame.CopyrightBit := ((HeaderData[3] shr 3) and 1) = 1;
  452.   Frame.OriginalBit := ((HeaderData[3] shr 2) and 1) = 1;
  453.   Frame.EmphasisID := HeaderData[3] and 3;
  454. end;
  456. { --------------------------------------------------------------------------- }
  458. function ValidFrameAt(const Index: Word; Data: array of Byte): Boolean;
  459. var
  460.   HeaderData: array [1..4] of Byte;
  461. begin
  462.   { Check for frame at given position }
  463.   HeaderData[1] := Data[Index];
  464.   HeaderData[2] := Data[Index + 1];
  465.   HeaderData[3] := Data[Index + 2];
  466.   HeaderData[4] := Data[Index + 3];
  467.   if IsFrameHeader(HeaderData) then Result := true
  468.   else Result := false;
  469. end;
  471. { --------------------------------------------------------------------------- }
  473. function GetCoefficient(const Frame: FrameData): Byte;
  474. begin
  475.   { Get frame coefficient }
  476.   if Frame.VersionID = MPEG_VERSION_1 then
  477.     if Frame.LayerID = MPEG_LAYER_I then Result := 48
  478.     else Result := 144
  479.   else
  480.     if Frame.LayerID = MPEG_LAYER_I then Result := 24
  481.     else Result := 72;
  482. end;
  484. { --------------------------------------------------------------------------- }
  486. function GetBitRate(const Frame: FrameData): Word;
  487. begin
  488.   { Get bit rate }
  489.   Result := MPEG_BIT_RATE[Frame.VersionID, Frame.LayerID, Frame.BitRateID];
  490. end;
  492. { --------------------------------------------------------------------------- }
  494. function GetSampleRate(const Frame: FrameData): Word;
  495. begin
  496.   { Get sample rate }
  497.   Result := MPEG_SAMPLE_RATE[Frame.VersionID, Frame.SampleRateID];
  498. end;
  500. { --------------------------------------------------------------------------- }
  502. function GetPadding(const Frame: FrameData): Byte;
  503. begin
  504.   { Get frame padding }
  505.   if Frame.PaddingBit then
  506.     if Frame.LayerID = MPEG_LAYER_I then Result := 4
  507.     else Result := 1
  508.   else Result := 0;
  509. end;
  511. { --------------------------------------------------------------------------- }
  513. function GetFrameLength(const Frame: FrameData): Word;
  514. var
  515.   Coefficient, BitRate, SampleRate, Padding: Word;
  516. begin
  517.   { Calculate MPEG frame length }
  519.   Coefficient := GetCoefficient(Frame);
  520.   BitRate := GetBitRate(Frame);
  521.   SampleRate := GetSampleRate(Frame);
  522.   Padding := GetPadding(Frame);
  523.   Result := Trunc(Coefficient * BitRate * 1000 / SampleRate) + Padding;
  524.   
  525. {  if Frame.LayerID = MPEG_LAYER_I then
  526.     Result := Trunc((12 * BitRate * 1000 / SampleRate + Padding) * 4)
  527.     else
  528.     Result := trunc(144 * BitRate * 1000 / SampleRate) + Padding;
  529. }
  531. end;
  533. { --------------------------------------------------------------------------- }
  535. function FrameIsEmpty(const Index: Word; Data: array of Byte): Boolean;
  536. begin
  537.   { Get true if frame has no significant data }
  538.   Result :=
  539.     (Data[Index] = 0) and
  540.     (Data[Index + 1] = 0) and
  541.     (Data[Index + 2] = 0) and
  542.     (Data[Index + 3] = 0) and
  543.     (Data[Index + 4] = 0) and
  544.     (Data[Index + 5] = 0);
  545. end;
  547. { --------------------------------------------------------------------------- }
  549. function GetXingInfo(const Index: Word; Data: array of Byte): VBRData;
  550. begin
  551.   { Extract Xing VBR info at given position }
  552.   FillChar(Result, SizeOf(Result), 0);
  553.   Result.Found := true;
  554.   Result.ID := VBR_ID_XING;
  555.   Result.Frames := Data[Index + 8] shl 24 + Data[Index + 9] shl 16 +
  556.                    Data[Index + 10] shl 8 + Data[Index + 11];
  557.   Result.Bytes :=  Data[Index + 12] shl 24 + Data[Index + 13] shl 16 +
  558.                    Data[Index + 14]  shl 8 + Data[Index + 15];
  559.   Result.Scale := Data[Index + 119];
  560.   { Encoder ID can be not present }
  561.   Result.VendorID[1] := Chr(Data[Index + 120]);
  562.   Result.VendorID[2] := Chr(Data[Index + 121]);
  563.   Result.VendorID[3] := Chr(Data[Index + 122]);
  564.   Result.VendorID[4] := Chr(Data[Index + 123]);
  565.   Result.VendorID[5] := Chr(Data[Index + 124]);
  566.   Result.VendorID[6] := Chr(Data[Index + 125]);
  567.   Result.VendorID[7] := Chr(Data[Index + 126]);
  568.   Result.VendorID[8] := Chr(Data[Index + 127]);
  569. end;
  571. { --------------------------------------------------------------------------- }
  573. function GetFhGInfo(const Index: Word; Data: array of Byte): VBRData;
  574. begin
  575.   { Extract FhG VBR info at given position }
  576.   FillChar(Result, SizeOf(Result), 0);
  577.   Result.Found := true;
  578.   Result.ID := VBR_ID_FHG;
  579.   Result.Scale :=  Data[Index + 9];
  580.   Result.Bytes :=  Data[Index + 10] shl 24 + Data[Index + 11] shl 16 +
  581.                    Data[Index + 12] shl 8  + Data[Index + 13];
  582.   Result.Frames := Data[Index + 14] shl 24 + Data[Index + 15] shl 16 +
  583.                    Data[Index + 16] shl 8  + Data[Index + 17];
  584. end;
  586. { --------------------------------------------------------------------------- }
  588. function GetVbrInfo(const Index: Word; Data: array of Byte): VBRData;
  589. var
  590.   PSize: PLongint;
  591.   PPos: PByte absolute PSize;
  592.   Flags: byte;
  593. begin
  594.   FillChar(Result, SizeOf(Result), 0);
  595.   Result.Found := true;
  596.   Result.ID := VBR_ID_INFO;
  597.   Flags := Data[Index + 7];
  598.   if (Flags and 1) = 1 then
  599.     Result.Frames := Data[Index + 8] shl 24 + Data[Index + 9] shl 16 +
  600.                      Data[Index + 10] shl 8  + Data[Index + 11];
  601.   if (Flags and 2) = 2 then
  602.     Result.Bytes :=  Data[Index + 12] shl 24 + Data[Index + 13] shl 16 +
  603.                      Data[Index + 14] shl 8  + Data[Index + 15];
  604.   if (Flags and 8) = 8 then
  605.     Result.Scale := Data[Index + 119];
  606. end;
  607. { --------------------------------------------------------------------------- }
  609. function FindVBR(const Index: Word; Data: array of Byte): VBRData;
  610. begin
  611.   { Check for VBR header at given position }
  612.   FillChar(Result, SizeOf(Result), 0);
  613.   if Chr(Data[Index]) +
  614.     Chr(Data[Index + 1]) +
  615.     Chr(Data[Index + 2]) +
  616.     Chr(Data[Index + 3]) = VBR_ID_XING then Result := GetXingInfo(Index, Data);
  617.   if Chr(Data[Index]) +
  618.     Chr(Data[Index + 1]) +
  619.     Chr(Data[Index + 2]) +
  620.     Chr(Data[Index + 3]) = VBR_ID_FHG then Result := GetFhGInfo(Index, Data);
  621.   if Chr(Data[Index]) +
  622.     Chr(Data[Index + 1]) +
  623.     Chr(Data[Index + 2]) +
  624.     Chr(Data[Index + 3]) = VBR_ID_INFO then Result := GetVbrInfo(Index, Data);
  626. end;
  628. { --------------------------------------------------------------------------- }
  630. function GetVBRDeviation(const Frame: FrameData): Byte;
  631. begin
  632.   { Calculate VBR deviation }
  633.   if Frame.VersionID = MPEG_VERSION_1 then
  634.     if Frame.ModeID <> MPEG_CM_MONO then Result := 36
  635.     else Result := 21
  636.   else
  637.     if Frame.ModeID <> MPEG_CM_MONO then Result := 21
  638.     else Result := 13;
  639. end;
  641. { --------------------------------------------------------------------------- }
  643. function FindFrame(const Data: array of Byte; var VBR: VBRData): FrameData;
  644. var
  645.   HeaderData: array [1..4] of Byte;
  646.   Iterator: Integer;
  647. //  isDecode: boolean;
  648. begin
  649.   { Search for valid frame }
  650.   FillChar(Result, SizeOf(Result), 0);
  651.   Move(Data, HeaderData, SizeOf(HeaderData));
  653.   for Iterator := 0 to SizeOf(Data) - MAX_MPEG_FRAME_LENGTH do
  654.   begin
  655.     { Decode data if frame header found }
  656.     if IsFrameHeader(HeaderData) then
  657.     begin
  658.       DecodeHeader(HeaderData, Result);
  659. //      if not isDecode then
  660. //      begin
  661. //        DecodeHeader(HeaderData, Result);
  662. //        isDecode := true;
  663. //        Result.Found := true;
  664. //        Result.Size := GetFrameLength(Result);
  665. //        Result.Empty := FrameIsEmpty(Iterator + SizeOf(HeaderData), Data);
  666. //      end;
  668.       { Check for next frame and try to find VBR header }
  669.       if ValidFrameAt(Iterator + GetFrameLength(Result), Data) then
  670.       begin
  671.         Result.Found := true;
  672.         Result.Position := Iterator;
  673.         Result.Size := GetFrameLength(Result);
  674.         Result.Empty := FrameIsEmpty(Iterator + SizeOf(HeaderData), Data);
  675.         VBR := FindVBR(Iterator + GetVBRDeviation(Result), Data);
  676.         break;
  677.       end;
  678.     end;
  679.     { Prepare next data block }
  680.     HeaderData[1] := HeaderData[2];
  681.     HeaderData[2] := HeaderData[3];
  682.     HeaderData[3] := HeaderData[4];
  683.     HeaderData[4] := Data[Iterator + SizeOf(HeaderData)];
  684.   end;
  685. end;
  687. { --------------------------------------------------------------------------- }
  689. function GetTrack(const TrackString: string): Byte;
  690. var
  691.   Index, Value, Code: Integer;
  692. begin
  693.   { Extract track from string }
  694.   Index := Pos('/', TrackString);
  695.   if Index = 0 then Val(Trim(TrackString), Value, Code)
  696.   else Val(Copy(Trim(TrackString), 1, Index), Value, Code);
  697.   if Code = 0 then Result := Value
  698.   else Result := 0;
  699. end;
  702. { ********************** Private functions & procedures ********************* }
  704. procedure TMPEGaudio.FResetData;
  705. begin
  706.   { Reset all variables }
  707.   FFileLength := 0;
  708.   FillChar(FVBR, SizeOf(FVBR), 0);
  709.   FillChar(FFrame, SizeOf(FFrame), 0);
  710.   FFrame.VersionID := MPEG_VERSION_UNKNOWN;
  711.   FFrame.SampleRateID := MPEG_SAMPLE_RATE_UNKNOWN;
  712.   FFrame.ModeID := MPEG_CM_UNKNOWN;
  713.   FFrame.ModeExtensionID := MPEG_CM_EXTENSION_UNKNOWN;
  714.   FFrame.EmphasisID := MPEG_EMPHASIS_UNKNOWN;
  715.   FID3v1.ResetData;
  716.   FID3v2.ResetData;
  717. end;
  719. function TMPEGaudio.GetMP3FrameInfo(index: longint): TMP3FrameInfo;
  720. begin
  721.   result := TMP3FrameInfo(FFramesPos[index]);
  722. end;
  724. function TMPEGaudio.isMP3File(const FileName: string): Boolean;
  725. var
  726.   F: TFileStream;
  727.   Data: array [1..MAX_MPEG_FRAME_LENGTH * 2] of Byte;
  728. begin
  729.   F := TFileStream.Create(FileName, fmOpenRead + fmShareDenyWrite);
  730.   Result := false;
  731.   FResetData;
  732.   if (FID3v1.ReadFromStream(F)) and (FID3v2.ReadFromStream(F)) then
  733.   begin
  734.     F.Position := FID3v2.Size;
  735.     F.Read(Data, SizeOf(Data));
  736.     FWaveHeader := WaveHeaderPresent(FID3v2.Size, Data);
  737.     FFrame := FindFrame(Data, FVBR);
  738.     Result := FFrame.Found;
  739.   end;
  740.   F.Free;
  741. end;
  743. { --------------------------------------------------------------------------- }
  745. function TMPEGaudio.FGetVersion: string;
  746. begin
  747.   { Get MPEG version name }
  748.   Result := MPEG_VERSION[FFrame.VersionID];
  749. end;
  751. { --------------------------------------------------------------------------- }
  753. function TMPEGaudio.FGetLayer: string;
  754. begin
  755.   { Get MPEG layer name }
  756.   Result := MPEG_LAYER[FFrame.LayerID];
  757. end;
  759. { --------------------------------------------------------------------------- }
  761. function TMPEGaudio.FGetBitRate: Word;
  762. begin
  763.   { Get bit rate, calculate average bit rate if VBR header found }
  764.   if (FVBR.Found) and (FVBR.Frames > 0) then
  765.     Result := Round((FVBR.Bytes / FVBR.Frames - GetPadding(FFrame)) *
  766.       GetSampleRate(FFrame) / GetCoefficient(FFrame) / 1000)
  767.   else
  768.     Result := GetBitRate(FFrame);
  769. end;
  771. { --------------------------------------------------------------------------- }
  773. function TMPEGaudio.FGetSampleRate: Word;
  774. begin
  775.   { Get sample rate }
  776.   Result := GetSampleRate(FFrame);
  777. end;
  779. { --------------------------------------------------------------------------- }
  781. function TMPEGaudio.FGetChannelMode: string;
  782. begin
  783.   { Get channel mode name }
  784.   Result := MPEG_CM_MODE[FFrame.ModeID];
  785. end;
  787. { --------------------------------------------------------------------------- }
  789. function TMPEGaudio.FGetEmphasis: string;
  790. begin
  791.   { Get emphasis name }
  792.   Result := MPEG_EMPHASIS[FFrame.EmphasisID];
  793. end;
  795. { --------------------------------------------------------------------------- }
  797. function TMPEGaudio.FGetFrames: LongInt;
  798. begin
  799.   { Get total number of frames, calculate if VBR header not found }
  800.   if FFramesPos.Count > 0 then
  801.     Result := FFramesPos.Count else
  802.   if FVBR.Found then
  803.     Result := FVBR.Frames
  804.   else
  805.     Result := (FFileLength - FID3v2.Size - FFrame.Position) div
  806.       GetFrameLength(FFrame);
  807. end;
  809. { --------------------------------------------------------------------------- }
  811. function TMPEGaudio.FGetDuration: Double;
  812. begin
  813.   { Calculate song duration }
  814.   if FFrame.Found then
  815.     if (FVBR.Found) and (FVBR.Frames > 0) then
  816.       Result := FVBR.Frames * GetCoefficient(FFrame) * 8 /
  817.         GetSampleRate(FFrame)
  818.     else
  819.       Result := (FFileLength - FID3v2.Size - FFrame.Position) * 8 /
  820.         GetBitRate(FFrame) / 1000
  821.   else
  822.     Result := 0;
  823. end;
  825. { --------------------------------------------------------------------------- }
  827. function TMPEGaudio.FGetVBREncoderID: Byte;
  828. begin
  829.   { Guess VBR encoder and get ID }
  830.   Result := 0;
  831.   if Copy(FVBR.VendorID, 1, 4) = VBR_VENDOR_ID_LAME then
  832.     Result := MPEG_ENCODER_LAME;
  833.   if Copy(FVBR.VendorID, 1, 4) = VBR_VENDOR_ID_GOGO_NEW then
  834.     Result := MPEG_ENCODER_GOGO;
  835.   if Copy(FVBR.VendorID, 1, 4) = VBR_VENDOR_ID_GOGO_OLD then
  836.     Result := MPEG_ENCODER_GOGO;
  837.   if (FVBR.ID = VBR_ID_XING) and
  838.     (Copy(FVBR.VendorID, 1, 4) <> VBR_VENDOR_ID_LAME) and
  839.     (Copy(FVBR.VendorID, 1, 4) <> VBR_VENDOR_ID_GOGO_NEW) and
  840.     (Copy(FVBR.VendorID, 1, 4) <> VBR_VENDOR_ID_GOGO_OLD) then
  841.     Result := MPEG_ENCODER_XING;
  842.   if FVBR.ID = VBR_ID_FHG then
  843.     Result := MPEG_ENCODER_FHG;
  844. end;
  846. { --------------------------------------------------------------------------- }
  848. function TMPEGaudio.FGetCBREncoderID: Byte;
  849. begin
  850.   { Guess CBR encoder and get ID }
  851.   Result := 0;
  852.   if (FFrame.OriginalBit) and
  853.     (FFrame.ProtectionBit) then
  854.     Result := MPEG_ENCODER_LAME;
  855.   if (FFrame.ModeID = MPEG_CM_JOINT_STEREO) and
  856.     (not FFrame.CopyrightBit) and
  857.     (not FFrame.OriginalBit) then
  858.     Result := MPEG_ENCODER_FHG;
  859.   if (GetBitRate(FFrame) <= 112) and
  860.     (FFrame.ModeID = MPEG_CM_STEREO) then
  861.     Result := MPEG_ENCODER_BLADE;
  862.   if (FFrame.CopyrightBit) and
  863.     (FFrame.OriginalBit) and
  864.     (not FFrame.ProtectionBit) then
  865.     Result := MPEG_ENCODER_XING;
  866.   if (FFrame.Empty) and
  867.     (FFrame.OriginalBit) then
  868.     Result := MPEG_ENCODER_XING;
  869.   if (FWaveHeader) then
  870.     Result := MPEG_ENCODER_FHG;
  871.   if (FFrame.ModeID = MPEG_CM_DUAL_CHANNEL) and
  872.     (FFrame.ProtectionBit) then
  873.     Result := MPEG_ENCODER_SHINE;
  874. end;
  876. { --------------------------------------------------------------------------- }
  878. function TMPEGaudio.FGetEncoderID: Byte;
  879. begin
  880.   { Get guessed encoder ID }
  881.   if FFrame.Found then
  882.     if FVBR.Found then Result := FGetVBREncoderID
  883.     else Result := FGetCBREncoderID
  884.   else
  885.     Result := 0;
  886. end;
  888. { --------------------------------------------------------------------------- }
  890. function TMPEGaudio.FGetEncoder: string;
  891. begin
  892.   { Get guessed encoder name }
  893.   Result := MPEG_ENCODER[FGetEncoderID];
  894.   if (FVBR.Found) and
  895.     (FGetEncoderID = MPEG_ENCODER_LAME) and
  896.     (FVBR.VendorID[5] in ['0'..'9']) and
  897.     (FVBR.VendorID[6] = '.') and
  898.     (FVBR.VendorID[7] in ['0'..'9']) and
  899.     (FVBR.VendorID[8] in ['0'..'9']) then
  900.     Result :=
  901.       Result + #32 +
  902.       FVBR.VendorID[5] +
  903.       FVBR.VendorID[6] +
  904.       FVBR.VendorID[7] +
  905.       FVBR.VendorID[8];
  906. end;
  908. { --------------------------------------------------------------------------- }
  910. function TMPEGaudio.FGetValid: Boolean;
  911. begin
  912.   { Check for right MPEG file data }
  913.   Result :=
  914.     (FFrame.Found) and
  915.     (FGetBitRate >= MIN_MPEG_BIT_RATE) and
  916.     (FGetBitRate <= MAX_MPEG_BIT_RATE) and
  917.     (FGetDuration >= MIN_ALLOWED_DURATION);
  918. end;
  920. { ********************** Public functions & procedures ********************** }
  922. constructor TMPEGaudio.Create;
  923. begin
  924.   inherited;
  925.   FID3v1 := TID3v1.Create;
  926.   FID3v2 := TID3v2.Create;
  927.   FResetData;
  928.   FFramesPos := TObjectList.Create;
  929. end;
  931. { --------------------------------------------------------------------------- }
  933. destructor TMPEGaudio.Destroy;
  934. begin
  935.   FFramesPos.Free;
  936.   FID3v1.Free;
  937.   FID3v2.Free;
  938.   inherited;
  939. end;
  941. { --------------------------------------------------------------------------- }
  943. function TMPEGaudio.ReadFromFile(const FileName: string): Boolean;
  944. var
  945.   F: TFileStream;
  946. begin
  947.   F := TFileStream.Create(FileName, fmOpenRead + fmShareDenyWrite);
  948.   Result := ReadFromStream(F);
  949.   F.Free;
  950. end;
  952. function TMPEGaudio.ReadFromStream(Src: TStream): boolean;
  953. var
  954.   Data: array [1..MAX_MPEG_FRAME_LENGTH * 2] of Byte;
  955. begin
  956.   Result := false;
  957.   FResetData;
  958.   if (FID3v1.ReadFromStream(Src)) and (FID3v2.ReadFromStream(Src)) then
  959.     try
  960.       { Open file, read first block of data and search for a frame }
  961.       FFileLength := Src.Size;
  962.       Src.Position := FID3v2.Size;
  963.       Src.Read(Data, SizeOf(Data));
  964. //      BlockRead(SourceFile, Data, SizeOf(Data), Transferred);
  965.       FWaveHeader := WaveHeaderPresent(FID3v2.Size, Data);
  966.       FFrame := FindFrame(Data, FVBR);
  967.       { Try to search in the middle if no frame at the beginning found }
  968.       if (not FFrame.Found) {and (Transferred = SizeOf(Data))} then
  969.       begin
  970.         Src.Position := (FFileLength - FID3v2.Size) div 2;
  971.         Src.Read(Data, SizeOf(Data));
  972.         FFrame := FindFrame(Data, FVBR);
  973.       end;
  974.       Result := true;
  975.       if FFrame.Found then
  976.         EnumFrames(Src);
  977.     except
  978.     end;
  979.   if not FFrame.Found then FResetData;
  980. end;
  982. procedure TMPEGaudio.EnumFrames(Src: TStream);
  983.  var HeaderData: array [1..4] of Byte;
  984.      DW: dword absolute HeaderData;
  985.      CFrame: FrameData;
  986.      FI: TMP3FrameInfo;
  987.      vbrflag: array [0..3] of char;
  988. begin
  989.   CFrame := FirstFrame;
  990.   FSoundFrameCount := 0;
  991.   CFrame.Position := FirstFrame.Position + ID3v2.Size;
  992.   Src.Position := CFrame.Position;
  993.   while (Src.Position + ID3v1.Size) < Src.Size do
  994.   begin
  995.     Src.Read(HeaderData, 4);
  996.     if IsFrameHeader(HeaderData) then
  997.     begin
  998.       FI := TMP3FrameInfo.Create;
  999.       FI.Header := DW;
  1000.       FI.Position := Src.Position - 4;
  1001.       DecodeHeader(HeaderData, CFrame);
  1002.       FI.Size := GetFrameLength(CFrame);
  1003.       Src.Seek(32, 1);
  1004.       Src.Read(vbrflag, 4);
  1005.       FI.isSound := not((vbrflag = VBR_ID_INFO) or (vbrflag = VBR_Lame_Track) or
  1006.                         (vbrflag = VBR_ID_XING) or (vbrflag = MPEG_ENCODER[3]));
  1007.       if FI.isSound then inc(FSoundFrameCount);
  1008.       FFramesPos.Add(FI);
  1009.       Src.Position := FI.Position + Fi.Size;
  1010.     end else
  1011.       Src.Position := Src.Size;
  1012.   end;
  1013. end;
  1015. function GetTagVersion(const TagData: TagID3v1): Byte;
  1016. begin
  1017.   Result := TAG_VERSION_1_0;
  1018.   { Terms for ID3v1.1 }
  1019.   if ((TagData.Comment[29] = #0) and (TagData.Comment[30] <> #0)) or
  1020.     ((TagData.Comment[29] = #32) and (TagData.Comment[30] <> #32)) then
  1021.     Result := TAG_VERSION_1_1;
  1022. end;
  1024. function Swap32(const Figure: Integer): Integer;
  1025. var
  1026.   ByteArray: array [1..4] of Byte absolute Figure;
  1027. begin
  1028.   { Swap 4 bytes }
  1029.   Result :=
  1030.     ByteArray[1] * $100000000 +
  1031.     ByteArray[2] * $10000 +
  1032.     ByteArray[3] * $100 +
  1033.     ByteArray[4];
  1034. end;
  1036. { ********************** TID3v1  ********************* }
  1038. constructor TID3v1.Create;
  1039. begin
  1040.   inherited;
  1041.   ResetData;
  1042. end;
  1044. { --------------------------------------------------------------------------- }
  1046. procedure TID3v1.ResetData;
  1047. begin
  1048.   FExists := false;
  1049.   FVersionID := TAG_VERSION_1_0;
  1050.   FTitle := '';
  1051.   FArtist := '';
  1052.   FAlbum := '';
  1053.   FYear := '';
  1054.   FComment := '';
  1055.   FTrack := 0;
  1056.   FGenreID := DEFAULT_GENRE;
  1057. end;
  1059. { --------------------------------------------------------------------------- }
  1061. function TID3v1.ReadFromFile(const FileName: string): Boolean;
  1062.  var
  1063.    F: TFileStream;
  1064. begin
  1065.   F := TFileStream.Create(FileName, fmOpenRead + fmShareDenyWrite);
  1066.   Result := ReadFromStream(F);
  1067.   F.Free;
  1068. end;
  1070. { --------------------------------------------------------------------------- }
  1072. function TID3v1.ReadFromStream(Src: TStream): Boolean;
  1073.  var
  1074.    TagData: TagID3v1;
  1075. begin
  1076.   Result := true;
  1077.   Src.Position := Src.Size - 128;
  1078.   Src.Read(TagData, 128);
  1079.   FSize := 0;
  1080.   if (TagData.Header = 'TAG') then
  1081.   begin
  1082.     FSize := 128;
  1083.     FExists := true;
  1084.     FVersionID := GetTagVersion(TagData);
  1085.     { Fill properties with tag data }
  1086.     FTitle := TrimRight(TagData.Title);
  1087.     FArtist := TrimRight(TagData.Artist);
  1088.     FAlbum := TrimRight(TagData.Album);
  1089.     FYear := TrimRight(TagData.Year);
  1090.     if FVersionID = TAG_VERSION_1_0 then
  1091.       FComment := TrimRight(TagData.Comment)
  1092.     else
  1093.     begin
  1094.       FComment := TrimRight(Copy(TagData.Comment, 1, 28));
  1095.       FTrack := Ord(TagData.Comment[30]);
  1096.     end;
  1097.     FGenreID := TagData.Genre;
  1098.     Result := true;
  1099.   end;
  1100. end;
  1102. procedure TID3v1.FSetTitle(const NewTitle: String30);
  1103. begin
  1104.   FTitle := TrimRight(NewTitle);
  1105. end;
  1107. { --------------------------------------------------------------------------- }
  1109. procedure TID3v1.FSetArtist(const NewArtist: String30);
  1110. begin
  1111.   FArtist := TrimRight(NewArtist);
  1112. end;
  1114. { --------------------------------------------------------------------------- }
  1116. procedure TID3v1.FSetAlbum(const NewAlbum: String30);
  1117. begin
  1118.   FAlbum := TrimRight(NewAlbum);
  1119. end;
  1121. { --------------------------------------------------------------------------- }
  1123. procedure TID3v1.FSetYear(const NewYear: String04);
  1124. begin
  1125.   FYear := TrimRight(NewYear);
  1126. end;
  1128. { --------------------------------------------------------------------------- }
  1130. procedure TID3v1.FSetComment(const NewComment: String30);
  1131. begin
  1132.   FComment := TrimRight(NewComment);
  1133. end;
  1135. { --------------------------------------------------------------------------- }
  1137. procedure TID3v1.FSetTrack(const NewTrack: Byte);
  1138. begin
  1139.   FTrack := NewTrack;
  1140. end;
  1142. { --------------------------------------------------------------------------- }
  1144. procedure TID3v1.FSetGenreID(const NewGenreID: Byte);
  1145. begin
  1146.   if NewGenreID >= MAX_MUSIC_GENRES
  1147.     then FGenreID := MAX_MUSIC_GENRES - 1
  1148.     else FGenreID := NewGenreID;
  1149. end;
  1151. { --------------------------------------------------------------------------- }
  1153. function TID3v1.FGetGenre: string;
  1154. begin
  1155.   Result := '';
  1156.   { Return an empty string if the current GenreID is not valid }
  1157.   if FGenreID in [0..MAX_MUSIC_GENRES - 1] then Result := MusicGenre[FGenreID];
  1158. end;
  1161. { ********************************** TID3v2 ******************************** }
  1163. constructor TID3v2.Create;
  1164. begin
  1165.   inherited;
  1166.   ResetData;
  1167. end;
  1169. { --------------------------------------------------------------------------- }
  1171. procedure TID3v2.ResetData;
  1172. begin
  1173.   FExists := false;
  1174.   FVersionID := 0;
  1175.   FSize := 0;
  1176.   FTitle := '';
  1177.   FArtist := '';
  1178.   FAlbum := '';
  1179.   FTrack := 0;
  1180.   FYear := '';
  1181.   FGenre := '';
  1182.   FComment := '';
  1183. end;
  1185. { --------------------------------------------------------------------------- }
  1187. function TID3v2.ReadFromFile(const FileName: string): Boolean;
  1188. var
  1189.   F: TFileStream;
  1190. begin
  1191.   F := TFileStream.Create(FileName, fmOpenRead + fmShareDenyWrite);
  1192.   Result := ReadFromStream(F);
  1193.   F.Free;
  1194. end;
  1196. function TID3v2.ReadFromStream(Src: TStream): boolean;
  1197. var
  1198.   TagData: TagID3v2;
  1199.   Frame: MP3FrameHeader;
  1200.   DataPosition: longint;
  1201.   Data: array [1..250] of Char;
  1202.   Iterator: Byte;
  1203. begin
  1204.   ResetData;
  1205.   Result := true;
  1206.   Src.Position := 0;
  1207.   Src.Read(TagData, 10);
  1208.   if TagData.ID = 'ID3' then
  1209.   begin
  1210.     FExists := true;
  1211.     TagData.FileSize := Src.Size;
  1212.     { Fill properties with header data }
  1213.     FVersionID := TagData.Version;
  1214.     FSize := TagData.Size[1] * $200000 + TagData.Size[2] * $4000 + TagData.Size[3] * $80 + TagData.Size[4] + 10;
  1215.     if FSize > TagData.FileSize then FSize := 0;;
  1216.     { Get information from frames if version supported }
  1217.     if (FVersionID = TAG_VERSION_2_3) and (FSize > 0) then
  1218.     begin
  1219.       while (Src.Position < FSize) and (Src.Position < Src.Size) do
  1220.       begin
  1221.         FillChar(Data, SizeOf(Data), 0);
  1223.         Src.Read(Frame, 10);
  1225.         DataPosition := Src.Position;
  1226.         Src.Read(Data, Swap32(Frame.Size) mod SizeOf(Data));
  1228.         for Iterator := 1 to ID3V2_FRAME_COUNT do
  1229.           if ID3V2_FRAME[Iterator] = Frame.ID then TagData.Frame[Iterator] := Data;
  1231.         Src.Seek(DataPosition + Swap32(Frame.Size), 0);
  1232.       end;
  1234.       { Fill properties with data from frames }
  1235.       FTitle := Trim(TagData.Frame[1]);
  1236.       FArtist := Trim(TagData.Frame[2]);
  1237.       FAlbum := Trim(TagData.Frame[3]);
  1238.       FTrack := GetTrack(TagData.Frame[4]);
  1239.       FYear := Trim(TagData.Frame[5]);
  1240.       FGenre := Trim(TagData.Frame[6]);
  1241.       if Pos(')', FGenre) > 0 then Delete(FGenre, 1, LastDelimiter(')', FGenre));
  1242.       FComment := Trim(Copy(TagData.Frame[7], 5, Length(TagData.Frame[7]) - 4));
  1243.     end;
  1244.   end;
  1245. end;
  1247. { TMP3FrameInfo }
  1250. end.