winamp/Src/Plugins/Input/in_mp3/MP3Info.cpp
2024-09-24 14:54:57 +02:00

612 lines
18 KiB
C++

#include "main.h"
#include "LAMEInfo.h"
#include "AACFrame.h"
#include "config.h"
#include "../winamp/wa_ipc.h"
#include <Richedit.h>
#include "api__in_mp3.h"
#include "FactoryHelper.h"
#include <shlwapi.h>
#include <strsafe.h>
#include <foundation/error.h>
int fixAACCBRbitrate(int br);
#if 0
/*
*/
/*
int MP3Info::remove_id3v1()
{
char temp[3] = {0, 0, 0};
DWORD x;
int err = 0;
HANDLE hFile = CreateFile(file, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile == INVALID_HANDLE_VALUE)
{
return 0; //1;
}
SetFilePointer(hFile, -128, NULL, FILE_END);
ReadFile(hFile, temp, 3, &x, NULL);
if (!memcmp(temp, "TAG", 3))
{
SetFilePointer(hFile, -128, NULL, FILE_END);
if (!SetEndOfFile(hFile))
{
err = 1;
}
}
CloseHandle(hFile);
if (!err) fbuf[0] = 0;
return err;
return 0;
}
*/
/*
da_tag.SetUnsync(false);
da_tag.SetExtendedHeader(true);
da_tag.SetCompression(false);
da_tag.SetPadding(true);
*/
#endif
int FindAverageAACBitrate(unsigned __int8 *data, int sizeBytes)
{
AACFrame aacFrame;
aacFrame.ReadBuffer(data);
if (aacFrame.OK())
{
int aac_frame_length = aacFrame.frameLength;
int no_rawdb = aacFrame.numDataBlocks;
int fc_tot = aac_frame_length;
int fc_cnt = no_rawdb + 1;
unsigned char *aa = data + aac_frame_length;
int tt = sizeBytes - aac_frame_length;
while (tt >= 8)
{
AACFrame nextFrame;
nextFrame.ReadBuffer(aa);
if (!nextFrame.OK()) break; // error
int fcaac_frame_length = nextFrame.frameLength;
int fcno_rawdb = nextFrame.numDataBlocks;
fc_cnt += fcno_rawdb + 1;
fc_tot += fcaac_frame_length;
aa += fcaac_frame_length;
tt -= fcaac_frame_length;
}
int avg_framesize = fc_tot / (fc_cnt ? fc_cnt : 1);
return fixAACCBRbitrate(MulDiv(avg_framesize * 8, aacFrame.GetSampleRate(), 1024 * 1000));
}
return 0;
}
static bool ScanForFrame(CGioFile *file, int *bytesRead)
{
unsigned char buffer[512] = {0}; /* don't want to read too much, since most MP3's start at 0 */
int buflen = 0;
int checked=0;
if (file->Peek(buffer, sizeof(buffer), &buflen) != NErr_Success)
return false;
unsigned char *b = buffer;
while (buflen >= 4)
{
MPEGFrame frame1;
frame1.ReadBuffer(b);
if (frame1.IsSync())
{
if (checked)
file->Read(buffer, checked, &buflen);
*bytesRead=checked;
return true;
}
checked++;
buflen--;
b++;
}
if (checked)
file->Read(buffer, checked, &buflen);
*bytesRead=checked;
return false;
}
static bool mp3sync(CGioFile *file)
{
unsigned char buffer[1448 + 4] = {0}; /* large enough for one max-size frame and the header of the second */
int buflen = 0;
static const unsigned long gdwHeaderSyncMask = 0xfffe0c00L;
unsigned long ulHdr1=0;
unsigned long ulHdr2=0;
int bytesChecked=0;
while (bytesChecked<32768)
{
int bytesRead=0;
if (ScanForFrame(file, &bytesRead))
{
if (file->Peek(buffer, sizeof(buffer), &buflen) != NErr_Success)
return false;
if (buflen >= 4)
{
MPEGFrame frame1;
frame1.ReadBuffer(buffer);
if (frame1.IsSync())
{
ulHdr1 = (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
int framelength= frame1.FrameSize();
if (buflen >= (framelength+4))
{
unsigned char *b = buffer + framelength;
buflen -= frame1.FrameSize();
MPEGFrame frame2;
frame2.ReadBuffer(b);
ulHdr2 = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
if (!((ulHdr1 ^ ulHdr2) & gdwHeaderSyncMask) && frame2.IsSync())
return true;
else
{
}
}
}
file->Read(buffer, 1, &buflen);
bytesChecked++;
}
}
else if (file->EndOf())
return 0;
bytesChecked+=bytesRead;
}
return false;
}
static const wchar_t *GetMPEGVersionString(int mpegVersion)
{
switch (mpegVersion)
{
case MPEGFrame::MPEG1:
return L"MPEG-1";
case MPEGFrame::MPEG2:
return L"MPEG-2";
case MPEGFrame::MPEG2_5:
return L"MPEG-2.5";
default:
static wchar_t temp[64];
return WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,temp,64);
}
}
static const wchar_t *GetEmphasisString(int emphasis)
{
static wchar_t tempE[32];
switch (emphasis)
{
case 0:
return WASABI_API_LNGSTRINGW_BUF(IDS_NONE,tempE,32);
case 1:
return WASABI_API_LNGSTRINGW_BUF(IDS_50_15_MICROSEC,tempE,32);
case 2:
return WASABI_API_LNGSTRINGW_BUF(IDS_INVALID,tempE,32);
case 3:
return L"CITT j.17";
default:
return WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,tempE,32);
}
}
static const wchar_t *GetChannelModeString(int channelMode)
{
static wchar_t tempM[32];
switch (channelMode)
{
case 0:
return WASABI_API_LNGSTRINGW_BUF(IDS_STEREO,tempM,32);
case 1:
return WASABI_API_LNGSTRINGW_BUF(IDS_JOINT_STEREO,tempM,32);
case 2:
return WASABI_API_LNGSTRINGW_BUF(IDS_2_CHANNEL,tempM,32);
case 3:
return WASABI_API_LNGSTRINGW_BUF(IDS_MONO,tempM,32);
default:
return WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,tempM,32);
}
}
#define INFO_READ_SIZE 32768
void GetFileDescription(const wchar_t *file, CGioFile &_file, wchar_t *data, size_t datalen)
{
int hdroffs = 0;
size_t size = datalen;
wchar_t *mt = data;
wchar_t *ext = PathFindExtension(file);
wchar_t langbuf[256] = {0};
int flen = _file.GetContentLength();
StringCchPrintfExW(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_PAYLOAD_SIZE, langbuf, 256), _file.GetContentLength());
if (!_wcsicmp(ext, L".aac") || !_wcsicmp(ext, L".vlb"))
{
#if 0 // TODO!
if (_wcsicmp(ext, L".vlb")) // aacplus can't do VLB
{
if (aacPlus)
{
aacPlus->EasyOpen(AACPLUSDEC_OUTPUTFORMAT_INT16_HOSTENDIAN, 6);
AACPLUSDEC_EXPERTSETTINGS *pConf = aacPlus->GetDecoderSettingsHandle();
pConf->bEnableOutputLimiter = 1;
pConf->bDoUpsampling = 1;
aacPlus->SetDecoderSettings();
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW_BUF(IDS_FORMAT_AAC, langbuf, 256), &mt, &size, 0);
char buffer[INFO_READ_SIZE] = {0};
int inputRead;
_file.Read(buffer, INFO_READ_SIZE, &inputRead);
AACPLUSDEC_BITSTREAMBUFFERINFO bitbufInfo = { inputRead, 0, 0};
aacPlus->StreamFeed((unsigned char *)buffer, &bitbufInfo);
unsigned char tempBuf[65536] = {0}; // grr, can't we find a better way to do this?
AACPLUSDEC_AUDIOBUFFERINFO audioBufInfo = {65536, 0, 0};
aacPlus->StreamDecode(tempBuf, &audioBufInfo, 0, 0);
audioBufInfo.nBytesBufferSizeIn -= audioBufInfo.nBytesWrittenOut;
aacPlus->StreamDecode(tempBuf + audioBufInfo.nBytesWrittenOut, &audioBufInfo, 0, 0);
AACPLUSDEC_STREAMPROPERTIES *streamProperties = aacPlus->GetStreamPropertiesHandle();
if (streamProperties->nDecodingState == AACPLUSDEC_DECODINGSTATE_STREAMVERIFIED)
{
AACPLUSDEC_PROGRAMPROPERTIES *currentProgram = &(streamProperties->programProperties[streamProperties->nCurrentProgram]);
switch (currentProgram->nStreamType)
{
case AACPLUSDEC_MPEG2_PROFILE_AACMAIN:
StringCchCatEx(mt, size, L"\r\nMPEG-2 AAC", &mt, &size, 0);
break;
case AACPLUSDEC_MPEG2_PROFILE_AACLC:
if (currentProgram->bProgramSbrEnabled)
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW_BUF(IDS_MPEG2_HE_AAC_IS, langbuf, 256), &mt, &size, 0);
else
StringCchCatEx(mt, size, L"\r\nMPEG-2 AAC LC", &mt, &size, 0);
break;
case AACPLUSDEC_MPEG4_AOT_AACMAIN:
StringCchCatEx(mt, size, L"\r\nMPEG-4 AAC", &mt, &size, 0);
break;
case AACPLUSDEC_MPEG4_AOT_AACLC:
if (currentProgram->bProgramSbrEnabled)
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW_BUF(IDS_MPEG4_HE_AAC_IS, langbuf, 256), &mt, &size, 0);
else
StringCchCatEx(mt, size, L"\r\nMPEG-4 AAC LC", &mt, &size, 0);
break;
case AACPLUSDEC_MPEG4_AOT_SBR:
StringCchCatEx(mt, size, L"\r\nMPEG-4 HE-AAC", &mt, &size, 0);
break;
}
if (currentProgram->nAacSamplingRate != currentProgram->nOutputSamplingRate)
StringCchPrintfEx(mt, size, &mt, &size, 0,
WASABI_API_LNGSTRINGW(IDS_SAMPLE_RATE_OUTPUT),
currentProgram->nAacSamplingRate, currentProgram->nOutputSamplingRate);
else
StringCchPrintfEx(mt, size, &mt, &size, 0,
WASABI_API_LNGSTRINGW(IDS_SAMPLE_RATE),
currentProgram->nAacSamplingRate);
int srate = currentProgram->nOutputSamplingRate;
if (currentProgram->bProgramSbrEnabled)
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_SBR_PRESENT), &mt, &size, 0);
else
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_SBR_NOT_PRESENT), &mt, &size, 0);
if (currentProgram->nAacChannels != currentProgram->nOutputChannels)
StringCchPrintfEx(mt, size, &mt, &size, 0,
WASABI_API_LNGSTRINGW(IDS_CHANNELS_OUTPUT),
currentProgram->nAacChannels, currentProgram->nOutputChannels);
else
StringCchPrintfEx(mt, size, &mt, &size, 0,
WASABI_API_LNGSTRINGW(IDS_CHANNELS),
currentProgram->nAacChannels);
switch (currentProgram->nChannelMode)
{
case AACPLUSDEC_CHANNELMODE_MONO:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_MONO), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_STEREO:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_STEREO), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_PARAMETRIC_STEREO:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_PARAMETRIC_STEREO), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_DUAL_CHANNEL:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_DUAL_CHANNEL), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_4_CHANNEL_2CPE:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_4_CHANNEL_2_CPE), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_4_CHANNEL_MPEG:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_4_CHANNEL_MPEG), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_5_CHANNEL:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_5_CHANNEL), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_5_1_CHANNEL:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_5_1), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_6_1_CHANNEL:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_6_1), &mt, &size, 0);
break;
case AACPLUSDEC_CHANNELMODE_7_1_CHANNEL:
StringCchCatEx(mt, size, WASABI_API_LNGSTRINGW(IDS_MODE_7_1), &mt, &size, 0);
break;
}
if (streamProperties->nBitrate)
{
StringCchPrintfEx(mt, size, &mt, &size, 0,
WASABI_API_LNGSTRINGW(IDS_BITRATE),
streamProperties->nBitrate);
}
else
{
int avg_bitrate = FindAverageAACBitrate((unsigned char *)buffer, inputRead);
StringCchPrintfEx(mt, size, &mt, &size, 0,
WASABI_API_LNGSTRINGW(IDS_AVERAGE_BITRATE),
avg_bitrate);
}
}
}
}
if (!aacPlus)
#endif
{
char buffer[INFO_READ_SIZE] = {0};
int inputRead = 0;
_file.Read(buffer, INFO_READ_SIZE, &inputRead);
StringCchCopyEx(mt, size, WASABI_API_LNGSTRINGW(IDS_FORMAT_AAC), &mt, &size, 0);
unsigned char *a = (unsigned char *)buffer;
while (inputRead-- >= 8)
{
AACFrame aacFrame;
aacFrame.ReadBuffer(a);
if (aacFrame.OK())
{
int aac_frame_length = aacFrame.frameLength;
int no_rawdb = aacFrame.numDataBlocks;
/*size_t size = 1024;
char *mt = mpeg_description;*/
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW(IDS_HEADER_FOUND_AT_X_BYTES), hdroffs);
StringCchPrintfEx(mt, size, &mt, &size, 0, L"\r\nMPEG-%d AAC", aacFrame.GetMPEGVersion());
int fc_tot = aac_frame_length;
int fc_cnt = no_rawdb + 1;
unsigned char *aa = a + aac_frame_length;
int tt = inputRead - aac_frame_length;
while (tt >= 8)
{
AACFrame nextFrame;
nextFrame.ReadBuffer(aa);
if (!nextFrame.OK()) break; // error
int fcaac_frame_length = nextFrame.frameLength;
int fcno_rawdb = nextFrame.numDataBlocks;
fc_cnt += fcno_rawdb + 1;
fc_tot += fcaac_frame_length;
aa += fcaac_frame_length;
tt -= fcaac_frame_length;
}
{
int avg_framesize = fc_tot / (fc_cnt ? fc_cnt : 1);
int srate = aacFrame.GetSampleRate();
int avg_bitrate = fixAACCBRbitrate(MulDiv(avg_framesize * 8, srate, 1024 * 1000));
int len_s = MulDiv(flen, 1024, avg_framesize * srate);
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW(IDS_LENGTH_X_SECONDS), len_s);
StringCchPrintfEx(mt, size, &mt, &size, 0, L"\r\nCBR %d kbps", avg_bitrate);
}
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW(IDS_PROFILE), aacFrame.GetProfileName());
StringCchPrintfEx(mt, size, &mt, &size, 0, L"\r\n%dHz %s", aacFrame.GetSampleRate(), aacFrame.GetChannelConfigurationName());
StringCchPrintfEx(mt, size, &mt, &size, 0, L"\r\nCRC: %s", WASABI_API_LNGSTRINGW((aacFrame.protection == 0 ? IDS_YES : IDS_NO)));
break;
}
a++;
hdroffs++;
}
}
}
else
{
unsigned char mp3syncbuf[INFO_READ_SIZE] = {0};
int inputRead = 0;
DWORD start = _file.GetCurrentPosition();
// find position of first sync
if (!mp3sync(&_file))
return;
int syncposition = _file.GetCurrentPosition()-start;
// advance to first sync
_file.Peek(mp3syncbuf, INFO_READ_SIZE, &inputRead);
unsigned int padding = 0;
unsigned int encoderDelay = 0;
MPEGFrame frame;
frame.ReadBuffer(mp3syncbuf);
int framelen = frame.FrameSize();
//const CMp3StreamInfo *info = decoder.GetStreamInfo();
//const CMpegHeader *header = decoder.m_Mbs.GetHdr();
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_HEADER_FOUND_AT_X_BYTES, langbuf, 256), _file.GetHeaderOffset() + syncposition);
if (!padding) padding = _file.postpad;
if (!encoderDelay) encoderDelay = _file.prepad;
if (padding || encoderDelay)
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_ENC_DELAY_ZERO_PADDING, langbuf, 256), encoderDelay, padding);
int is_vbr_lens = _file.m_vbr_ms;
int iLen = (is_vbr_lens ? is_vbr_lens/1000 : ((flen * 8) / frame.GetBitrate()));
if(iLen > 0)
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_LENGTH_X_SECONDS, langbuf, 256), iLen);
else
{
float fLen = (is_vbr_lens ? is_vbr_lens/1000.0f : ((flen * 8.0f) / frame.GetBitrate()));
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_LENGTH_X_PART_SECONDS, langbuf, 256), fLen);
}
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_S_LAYER_X, langbuf, 256), GetMPEGVersionString(frame.mpegVersion), frame.GetLayer());
int frames = _file.m_vbr_frames;
int is_vbr = _file.m_vbr_flag || _file.m_vbr_hdr;
if (!is_vbr || _file.encodingMethod == ENCODING_METHOD_CBR)
{
if (frames)
{
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_X_KBIT, langbuf, 256), frame.GetBitrate() / 1000, frames);
}
else
{
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_X_KBIT_APPROX, langbuf, 256), frame.GetBitrate() / 1000, MulDiv(flen, 8, framelen));
}
}
else if (is_vbr && _file.encodingMethod == ENCODING_METHOD_ABR)
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_X_KBIT_ABR, langbuf, 256), _file.GetAvgVBRBitrate(), frames);
else
{
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_X_KBIT_VBR, langbuf, 256), _file.GetAvgVBRBitrate(), _file.m_vbr_hdr?L"I":L"", frames);
}
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_X_HZ_S, langbuf, 256), frame.GetSampleRate(), GetChannelModeString(frame.channelMode));
StringCchPrintfEx(mt, size, &mt, &size, 0, L"\r\nCRC: %s", WASABI_API_LNGSTRINGW_BUF((frame.CRC ? IDS_YES : IDS_NO), langbuf, 256));
wchar_t tmp[16] = {0};
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_COPYRIGHTED, langbuf, 256), WASABI_API_LNGSTRINGW_BUF((frame.copyright ? IDS_YES : IDS_NO),tmp,16));
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_ORIGINAL, langbuf, 256), WASABI_API_LNGSTRINGW_BUF((frame.original ? IDS_YES : IDS_NO),tmp,16));
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_EMPHASIS, langbuf, 256), GetEmphasisString(frame.emphasis));
if (_file.m_vbr_frame_len && !_file.lengthVerified)
StringCchPrintfEx(mt, size, &mt, &size, 0, WASABI_API_LNGSTRINGW_BUF(IDS_MP3_HAS_BEEN_MODIFIED_NOT_ALL_MAY_BE_CORRECT, langbuf, 256));
}
}
void GetAudioInfo(const wchar_t *filename, CGioFile *file, int *len, int *channels, int *bitrate, int *vbr, int *sr)
{
*bitrate=0;
*len=0;
*vbr=0;
*channels=0;
if (file)
{
wchar_t *ext = PathFindExtension(filename);
if (!_wcsicmp(ext, L".aac") || !_wcsicmp(ext, L".vlb"))
{
unsigned char t[INFO_READ_SIZE*2] = {0};
unsigned char *a = t;
int n = 0;
if (file->Read(t, sizeof(t), &n) != NErr_Success)
return;
while (n-- >= 8)
{
AACFrame aacFrame;
aacFrame.ReadBuffer(a);
if (aacFrame.OK())
{
int aac_frame_length = aacFrame.frameLength;
int fc_tot = aac_frame_length;
int fc_cnt = aacFrame.numDataBlocks + 1;
unsigned char *aa = a + aac_frame_length;
int tt = n - aac_frame_length;
while (tt >= 8 && aac_frame_length)
{
AACFrame nextFrame;
nextFrame.ReadBuffer(aa);
if (!nextFrame.OK()) break; // error
int fcaac_frame_length = nextFrame.frameLength;
int fcno_rawdb = nextFrame.numDataBlocks;
fc_cnt += fcno_rawdb + 1;
fc_tot += fcaac_frame_length;
aa += fcaac_frame_length;
tt -= fcaac_frame_length;
}
int avg_framesize = fc_tot / (fc_cnt ? fc_cnt : 1);
int br = MulDiv(avg_framesize * 8, aacFrame.GetSampleRate(), 1024);
*len = MulDiv(file->GetContentLength(), 1024*8, br);
*bitrate = fixAACCBRbitrate(br/1000)*1000;
*sr = aacFrame.GetSampleRate();
*channels = aacFrame.GetNumChannels();
break;
}
a++;
}
}
else
{
if (*bitrate = file->GetAvgVBRBitrate()*1000)
{
*len = file->m_vbr_ms;
*vbr = file->m_vbr_flag || file->m_vbr_hdr;
}
if (!mp3sync(file))
return;
unsigned char t[4] = {0};
int n = 0;
if (file->Peek(t, sizeof(t), &n) != NErr_Success)
return;
MPEGFrame frame;
frame.ReadBuffer(t);
if (frame.IsSync())
{
if (!*bitrate)
{
*bitrate = frame.GetBitrate();
*len = MulDiv(file->GetContentLength(), 1000*8, *bitrate);
}
*channels = frame.GetNumChannels();
*sr = frame.GetSampleRate();
}
}
}
}