mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-09-24 15:54:12 +00:00
327 lines
No EOL
9.1 KiB
C++
327 lines
No EOL
9.1 KiB
C++
//---------------------------------------------------------------------------\
|
|
//
|
|
// (C) copyright Fraunhofer - IIS (2000)
|
|
// All Rights Reserved
|
|
//
|
|
// filename: CVbriHeader.cpp
|
|
// MPEG Layer-3 Audio Decoder
|
|
// author : Martin Weishart martin.weishart@iis.fhg.de
|
|
// date : 2000-02-11
|
|
// contents/description: provides functions to read a VBRI header
|
|
// of a MPEG Layer 3 bitstream encoded
|
|
// with variable bitrate using Fraunhofer
|
|
// variable bitrate format
|
|
//
|
|
//--------------------------------------------------------------------------/
|
|
|
|
#include <windows.h>
|
|
|
|
#include "CVbriHeader.h"
|
|
#include "LAMEInfo.h"
|
|
#include <malloc.h>
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Constructor: set position in buffer to parse and create a
|
|
// VbriHeaderTable
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
CVbriHeader::CVbriHeader(){
|
|
position = 0;
|
|
VbriTable=0;
|
|
VbriStreamFrames=0;
|
|
encoderDelay=0;
|
|
h_id=0;
|
|
SampleRate=0;
|
|
VbriTableSize=0;
|
|
VbriEntryFrames=0;
|
|
VbriStreamBytes=0;
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Destructor: delete a VbriHeaderTable and a VbriHeader
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
CVbriHeader::~CVbriHeader(){
|
|
free(VbriTable);
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Method: checkheader
|
|
// Reads the header to a struct that has to be stored and is
|
|
// used in other functions to determine file offsets
|
|
// Input: buffer containing the first frame
|
|
// Output: fills struct VbriHeader
|
|
// Return: 0 on success; 1 on error
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
int CVbriHeader::readVbriHeader(unsigned char *Hbuffer)
|
|
{
|
|
position=0;
|
|
// MPEG header
|
|
MPEGFrame frame;
|
|
frame.ReadBuffer(Hbuffer);
|
|
if (!frame.IsSync())
|
|
return 0;
|
|
|
|
SampleRate = frame.GetSampleRate();
|
|
h_id = frame.mpegVersion & 1;
|
|
|
|
position += DWORD ;
|
|
|
|
// data indicating silence
|
|
position += (8*DWORD) ;
|
|
|
|
// if a VBRI Header exists read it
|
|
|
|
if ( *(Hbuffer+position ) == 'V' &&
|
|
*(Hbuffer+position+1) == 'B' &&
|
|
*(Hbuffer+position+2) == 'R' &&
|
|
*(Hbuffer+position+3) == 'I'){
|
|
|
|
position += DWORD;
|
|
|
|
//position += WORD;
|
|
/*unsigned int vbriVersion = */readFromBuffer(Hbuffer, WORD); // version
|
|
|
|
encoderDelay = readFromBuffer(Hbuffer, WORD); // delay
|
|
|
|
position += WORD;
|
|
//readFromBuffer(Hbuffer, WORD); // quality
|
|
|
|
VbriStreamBytes = readFromBuffer(Hbuffer, DWORD);
|
|
VbriStreamFrames = readFromBuffer(Hbuffer, DWORD);
|
|
VbriTableSize = readFromBuffer(Hbuffer, WORD);
|
|
unsigned int VbriTableScale = readFromBuffer(Hbuffer, WORD);
|
|
unsigned int VbriEntryBytes = readFromBuffer(Hbuffer, WORD);
|
|
VbriEntryFrames = readFromBuffer(Hbuffer, WORD);
|
|
|
|
if (VbriTableSize > 32768) return 1;
|
|
|
|
VbriTable = (int *)calloc((VbriTableSize + 1), sizeof(int));
|
|
|
|
for (unsigned int i = 0 ; i <= VbriTableSize ; i++){
|
|
VbriTable[i] = readFromBuffer(Hbuffer, VbriEntryBytes*BYTE)
|
|
* VbriTableScale ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
return frame.FrameSize();
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Method: seekPointByTime
|
|
// Returns a point in the file to decode in bytes that is nearest
|
|
// to a given time in seconds
|
|
// Input: time in seconds
|
|
// Output: None
|
|
// Returns: point belonging to the given time value in bytes
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
int CVbriHeader::seekPointByTime(float EntryTimeInMilliSeconds){
|
|
|
|
unsigned int SamplesPerFrame, i=0, SeekPoint = 0 , fraction = 0;
|
|
|
|
float TotalDuration ;
|
|
float DurationPerVbriFrames ;
|
|
float AccumulatedTime = 0.0f ;
|
|
|
|
(SampleRate >= 32000) ? (SamplesPerFrame = 1152) : (SamplesPerFrame = 576) ;
|
|
|
|
TotalDuration = ((float)VbriStreamFrames * (float)SamplesPerFrame)
|
|
/ (float)SampleRate * 1000.0f ;
|
|
DurationPerVbriFrames = (float)TotalDuration / (float)(VbriTableSize+1) ;
|
|
|
|
if ( EntryTimeInMilliSeconds > TotalDuration ) EntryTimeInMilliSeconds = TotalDuration;
|
|
|
|
while ( AccumulatedTime <= EntryTimeInMilliSeconds ){
|
|
|
|
SeekPoint += VbriTable[i] ;
|
|
AccumulatedTime += DurationPerVbriFrames;
|
|
i++;
|
|
|
|
}
|
|
|
|
// Searched too far; correct result
|
|
fraction = ( (int)(((( AccumulatedTime - EntryTimeInMilliSeconds ) / DurationPerVbriFrames )
|
|
+ (1.0f/(2.0f*(float)VbriEntryFrames))) * (float)VbriEntryFrames));
|
|
|
|
|
|
SeekPoint -= (int)((float)VbriTable[i-1] * (float)(fraction)
|
|
/ (float)VbriEntryFrames) ;
|
|
|
|
return SeekPoint ;
|
|
|
|
}
|
|
|
|
int CVbriHeader::getNumMS()
|
|
{
|
|
if (!VbriStreamFrames || !SampleRate) return 0;
|
|
|
|
int nf=VbriStreamFrames;
|
|
int sr=SampleRate;
|
|
if (sr >= 32000) sr/=2;
|
|
//576
|
|
return MulDiv(nf,576*1000,sr);
|
|
}
|
|
|
|
#if 0
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Method: seekTimeByPoint
|
|
// Returns a time in the file to decode in seconds that is
|
|
// nearest to a given point in bytes
|
|
// Input: time in seconds
|
|
// Output: None
|
|
// Returns: point belonging to the given time value in bytes
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
float CVbriHeader::seekTimeByPoint(unsigned int EntryPointInBytes){
|
|
|
|
unsigned int SamplesPerFrame, i=0, AccumulatedBytes = 0, fraction = 0;
|
|
|
|
float SeekTime = 0.0f;
|
|
float TotalDuration ;
|
|
float DurationPerVbriFrames ;
|
|
|
|
(SampleRate >= 32000) ? (SamplesPerFrame = 1152) : (SamplesPerFrame = 576) ;
|
|
|
|
TotalDuration = ((float)VbriStreamFrames * (float)SamplesPerFrame)
|
|
/ (float)SampleRate;
|
|
DurationPerVbriFrames = (float)TotalDuration / (float)(VbriTableSize+1) ;
|
|
|
|
while (AccumulatedBytes <= EntryPointInBytes){
|
|
|
|
AccumulatedBytes += VbriTable[i] ;
|
|
SeekTime += DurationPerVbriFrames;
|
|
i++;
|
|
|
|
}
|
|
|
|
// Searched too far; correct result
|
|
fraction = (int)(((( AccumulatedBytes - EntryPointInBytes ) / (float)VbriTable[i-1])
|
|
+ (1/(2*(float)VbriEntryFrames))) * (float)VbriEntryFrames);
|
|
|
|
SeekTime -= (DurationPerVbriFrames * (float) ((float)(fraction) / (float)VbriEntryFrames)) ;
|
|
|
|
return SeekTime ;
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Method: seekPointByPercent
|
|
// Returns a point in the file to decode in bytes that is
|
|
// nearest to a given percentage of the time of the stream
|
|
// Input: percent of time
|
|
// Output: None
|
|
// Returns: point belonging to the given time percentage value in bytes
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
int CVbriHeader::seekPointByPercent(float percent){
|
|
|
|
int SamplesPerFrame;
|
|
|
|
float TotalDuration ;
|
|
|
|
if (percent >= 100.0f) percent = 100.0f;
|
|
if (percent <= 0.0f) percent = 0.0f;
|
|
|
|
(SampleRate >= 32000) ? (SamplesPerFrame = 1152) : (SamplesPerFrame = 576) ;
|
|
|
|
TotalDuration = ((float)VbriStreamFrames * (float)SamplesPerFrame)
|
|
/ (float)SampleRate;
|
|
|
|
return seekPointByTime( (percent/100.0f) * TotalDuration * 1000.0f );
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Method: GetSampleRate
|
|
// Returns the sampling rate of the file to decode
|
|
// Input: Buffer containing the part of the first frame after the
|
|
// syncword
|
|
// Output: None
|
|
// Return: sampling rate of the file to decode
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
/*int CVbriHeader::getSampleRate(unsigned char * buffer){
|
|
|
|
unsigned char id, idx, mpeg ;
|
|
|
|
id = (0xC0 & (buffer[1] << 3)) >> 4;
|
|
idx = (0xC0 & (buffer[2] << 4)) >> 6;
|
|
|
|
mpeg = id | idx;
|
|
|
|
switch ((int)mpeg){
|
|
|
|
case 0 : return 11025;
|
|
case 1 : return 12000;
|
|
case 2 : return 8000;
|
|
case 8 : return 22050;
|
|
case 9 : return 24000;
|
|
case 10: return 16000;
|
|
case 12: return 44100;
|
|
case 13: return 48000;
|
|
case 14: return 32000;
|
|
default: return 0;
|
|
|
|
}
|
|
}*/
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------\
|
|
//
|
|
// Method: readFromBuffer
|
|
// reads from a buffer a segment to an int value
|
|
// Input: Buffer containig the first frame
|
|
// Output: none
|
|
// Return: number containing int value of buffer segmenet
|
|
// length
|
|
//
|
|
//---------------------------------------------------------------------------/
|
|
|
|
int CVbriHeader::readFromBuffer ( unsigned char * HBuffer, int length ){
|
|
|
|
if (HBuffer)
|
|
{
|
|
int number = 0;
|
|
for(int i = 0; i < length ; i++ )
|
|
{
|
|
int b = length-1-i ;
|
|
number = number | (unsigned int)( HBuffer[position+i] & 0xff ) << ( 8*b );
|
|
}
|
|
position += length ;
|
|
return number;
|
|
}
|
|
else{
|
|
return 0;
|
|
}
|
|
} |