forked from KolibriOS/kolibrios
new folders layout
git-svn-id: svn://kolibrios.org@576 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge)
parent
fdab9ee5c7
commit
268f6d98b7
24
programs/media/ac97snd/ac97snd.sln
Normal file
24
programs/media/ac97snd/ac97snd.sln
Normal file
@ -0,0 +1,24 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 9.00
|
||||
# Visual Studio 2005
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ac97snd", "ac97snd\ac97snd.vcproj", "{5146AAEE-C15C-47C5-A245-64050C820145}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{6BB005B0-3277-4C8C-950F-38E15A4E440C} = {6BB005B0-3277-4C8C-950F-38E15A4E440C}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mpg", "mpg\mpg.vcproj", "{6BB005B0-3277-4C8C-950F-38E15A4E440C}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Release|Win32 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{5146AAEE-C15C-47C5-A245-64050C820145}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{5146AAEE-C15C-47C5-A245-64050C820145}.Release|Win32.Build.0 = Release|Win32
|
||||
{6BB005B0-3277-4C8C-950F-38E15A4E440C}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{6BB005B0-3277-4C8C-950F-38E15A4E440C}.Release|Win32.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
265
programs/media/ac97snd/ac97snd/ac97snd.vcproj
Normal file
265
programs/media/ac97snd/ac97snd/ac97snd.vcproj
Normal file
@ -0,0 +1,265 @@
|
||||
<?xml version="1.0" encoding="windows-1251"?>
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="8,00"
|
||||
Name="ac97snd"
|
||||
ProjectGUID="{5146AAEE-C15C-47C5-A245-64050C820145}"
|
||||
RootNamespace="ac97snd"
|
||||
Keyword="Win32Proj"
|
||||
>
|
||||
<Platforms>
|
||||
<Platform
|
||||
Name="Win32"
|
||||
/>
|
||||
</Platforms>
|
||||
<ToolFiles>
|
||||
<ToolFile
|
||||
RelativePath="../fasm.rules"
|
||||
/>
|
||||
</ToolFiles>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
Name="Debug|Win32"
|
||||
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||
IntermediateDirectory="$(ConfigurationName)"
|
||||
ConfigurationType="1"
|
||||
CharacterSet="2"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="FASM"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="1"
|
||||
OmitFramePointers="true"
|
||||
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
|
||||
MinimalRebuild="false"
|
||||
ExceptionHandling="0"
|
||||
BasicRuntimeChecks="0"
|
||||
RuntimeLibrary="0"
|
||||
StructMemberAlignment="1"
|
||||
BufferSecurityCheck="false"
|
||||
FloatingPointModel="2"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="false"
|
||||
DebugInformationFormat="0"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLinkerTool"
|
||||
AdditionalDependencies="$(OutDir)\mpg.lib $(OutDir)\sound.lib"
|
||||
LinkIncremental="1"
|
||||
GenerateManifest="false"
|
||||
IgnoreAllDefaultLibraries="true"
|
||||
GenerateDebugInformation="false"
|
||||
SubSystem="1"
|
||||
OptimizeReferences="2"
|
||||
EnableCOMDATFolding="2"
|
||||
OptimizeForWindows98="1"
|
||||
EntryPointSymbol="crtStartUp"
|
||||
BaseAddress="0x00000000"
|
||||
MergeSections=".rdata=.text "
|
||||
TargetMachine="1"
|
||||
FixedBaseAddress="2"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManifestTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCAppVerifierTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebDeploymentTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Release|Win32"
|
||||
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||
IntermediateDirectory="$(ConfigurationName)"
|
||||
ConfigurationType="1"
|
||||
CharacterSet="2"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="FASM"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="2"
|
||||
EnableIntrinsicFunctions="true"
|
||||
FavorSizeOrSpeed="1"
|
||||
OmitFramePointers="true"
|
||||
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
|
||||
ExceptionHandling="0"
|
||||
RuntimeLibrary="0"
|
||||
StructMemberAlignment="1"
|
||||
BufferSecurityCheck="false"
|
||||
FloatingPointModel="2"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="false"
|
||||
DebugInformationFormat="0"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLinkerTool"
|
||||
AdditionalDependencies="$(OutDir)\sound.lib $(OutDir)\mpg.lib"
|
||||
LinkIncremental="1"
|
||||
GenerateManifest="false"
|
||||
IgnoreAllDefaultLibraries="true"
|
||||
GenerateDebugInformation="false"
|
||||
SubSystem="1"
|
||||
LargeAddressAware="1"
|
||||
TerminalServerAware="1"
|
||||
Driver="0"
|
||||
OptimizeReferences="2"
|
||||
EnableCOMDATFolding="2"
|
||||
EntryPointSymbol="crtStartUp"
|
||||
BaseAddress="0x00000000"
|
||||
MergeSections=".rdata=.text "
|
||||
TargetMachine="1"
|
||||
FixedBaseAddress="2"
|
||||
Profile="false"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManifestTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCAppVerifierTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebDeploymentTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
<References>
|
||||
</References>
|
||||
<Files>
|
||||
<Filter
|
||||
Name="Source Files"
|
||||
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\ac97wav.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\crt.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\k_lib.asm"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Header Files"
|
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\ac97wav.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\crt.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\kolibri.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\sound.h"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Resource Files"
|
||||
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
|
||||
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
|
||||
>
|
||||
</Filter>
|
||||
</Files>
|
||||
<Globals>
|
||||
</Globals>
|
||||
</VisualStudioProject>
|
||||
@ -13,31 +13,50 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
#include "kolibri.h"
|
||||
#include "../kolibri.h"
|
||||
#include "string.h"
|
||||
#include "ac97wav.h"
|
||||
#include "mpg/mpg123.h"
|
||||
#include "sound.h"
|
||||
#include "../mpg/mpg123.h"
|
||||
#include "../sound.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int sender;
|
||||
int size;
|
||||
int code;
|
||||
char data[1];
|
||||
} IPC;
|
||||
|
||||
int ipc_client = 0;
|
||||
|
||||
#define MP3_ERROR_OUT_OF_BUFFER 5
|
||||
int m_last_error;
|
||||
|
||||
void _stdcall thread_proc(void *param);
|
||||
void _stdcall create_thread(void *proc, void *param, int stack_size);
|
||||
void _stdcall init_ipc(void);
|
||||
void _stdcall send_ipc(int dst, DWORD code);
|
||||
IPC * _stdcall recieve_ipc(void);
|
||||
|
||||
void touch(char *buf, int size);
|
||||
int mp3FindSync(byte* buf, int size, int* sync);
|
||||
int stream_read_raw(struct reader *rd,unsigned char *buf, int size);
|
||||
int stream_read_raw(struct reader *rd,unsigned char *buf, int size);
|
||||
|
||||
char *fname;
|
||||
|
||||
struct reader rd;
|
||||
struct frame fr;
|
||||
|
||||
void draw_window();
|
||||
void draw_progress_bar();
|
||||
void do_ipc();
|
||||
void exit();
|
||||
|
||||
|
||||
DWORD hDrv;
|
||||
DWORD hSound;
|
||||
SNDBUF hBuff;
|
||||
volatile int snd_init=0;
|
||||
|
||||
CTRL_INFO info;
|
||||
|
||||
@ -62,306 +81,108 @@ int outsize;
|
||||
int outremain;
|
||||
int totalout;
|
||||
int done;
|
||||
|
||||
char path[1024];
|
||||
char header[] = "AC97 MP3 player";
|
||||
char buttons_text[]=" Play Stop << >> Vol- Vol+";
|
||||
|
||||
void (*snd_play)();
|
||||
|
||||
void draw_window()
|
||||
{
|
||||
BeginDraw();
|
||||
|
||||
DrawWindow(100,100,299,72,0x404040,3,0,0,0);
|
||||
|
||||
make_button(7,24,45,13, 0x10|BT_NORMAL,0x808080);
|
||||
make_button(56,24,45,13, 0x11|BT_NORMAL,0x808080);
|
||||
make_button(104,24,45,13, 0x12|BT_NORMAL,0x808080);
|
||||
make_button(152,24,45,13, 0x13|BT_NORMAL,0x808080);
|
||||
make_button(200,24,45,13, 0x14|BT_NORMAL,0x808080);
|
||||
make_button(248,24,45,13, 0x15|BT_NORMAL,0x808080);
|
||||
|
||||
make_button(7,41,286,11, 0x30|BT_HIDE|BT_NOFRAME,0x404040);
|
||||
draw_bar(7,41,286,11,0x404040);
|
||||
|
||||
draw_bar(7,55,286,11,0x404040);
|
||||
write_text(12,58,0x004000|FONT0, fname, strlen(fname));
|
||||
write_text(11,57,0x00FF20|FONT0, fname, strlen(fname));
|
||||
|
||||
write_text(8,8,0xFFFFFF|FONT0, header, strlen(header));
|
||||
write_text(12,28,0x404040|FONT0,buttons_text,strlen(buttons_text));
|
||||
write_text(11,27,0xA0FFA0|FONT0,buttons_text,strlen(buttons_text));
|
||||
|
||||
EndDraw();
|
||||
};
|
||||
|
||||
void draw_progress_bar()
|
||||
{ DWORD x;
|
||||
x = 287.0f * (float)(rd.filepos-rd.strremain)/(float)fileinfo.size;
|
||||
if(x==0) return;
|
||||
draw_bar(7,41,x,11,0xA0A0A0);
|
||||
draw_bar(x+7,41,287-x,11,0x404040);
|
||||
};
|
||||
|
||||
void debug_out_str(char* str)
|
||||
{
|
||||
while (*str != 0)
|
||||
{
|
||||
debug_out(*str);
|
||||
str++;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) //int argc, char *argv[])
|
||||
{
|
||||
DWORD fmt;
|
||||
DWORD r_bytes;
|
||||
int retval;
|
||||
int err;
|
||||
int ver;
|
||||
int evnt;
|
||||
int key;
|
||||
int pos;
|
||||
int msg;
|
||||
int cnt;
|
||||
IPC *incom;
|
||||
|
||||
fname = argv[1];
|
||||
debug_out_str("\n\rPlay file ");
|
||||
debug_out_str(fname);
|
||||
debug_out_str("\n\r");
|
||||
|
||||
InitHeap(1024*1024);
|
||||
if(get_fileinfo(fname, &fileinfo)==FILE_NOT_FOUND)
|
||||
{ debug_out_str("\n\rfile not found\n\r");
|
||||
return 0;
|
||||
_asm
|
||||
{
|
||||
mov eax, 40
|
||||
mov ebx, 0x47 ;recieve ipc
|
||||
int 0x40
|
||||
mov eax, 66
|
||||
mov ebx, 1
|
||||
mov ecx, 1
|
||||
int 0x40
|
||||
};
|
||||
|
||||
init_ipc();
|
||||
InitHeap(0);
|
||||
|
||||
if(err = InitSound(&ver))
|
||||
{
|
||||
debug_out_str("Sound service not installed\n\r");
|
||||
{ debug_out_str("Sound service not installed\n\r");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if( (SOUND_VERSION>(ver&0xFFFF)) ||
|
||||
(SOUND_VERSION<(ver >> 16)))
|
||||
{
|
||||
debug_out_str("Sound service version mismatch\n\r");
|
||||
{ debug_out_str("Sound service version mismatch\n\r");
|
||||
return 0;
|
||||
}
|
||||
|
||||
testbuff = UserAlloc(4096);
|
||||
get_fileinfo(fname, &fileinfo);
|
||||
offset = 0;
|
||||
retval=read_file (fname,testbuff,0,2048,&r_bytes);
|
||||
if (retval) return 0;
|
||||
|
||||
inpbuf = UserAlloc(0x10000);
|
||||
touch(inpbuf, 0x10000);
|
||||
|
||||
create_reader(&rd, inpbuf, 0x10000);
|
||||
init_reader(&rd,fname);
|
||||
make_decode_tables(32767);
|
||||
init_layer2();
|
||||
init_layer3(32);
|
||||
fr.single = -1;
|
||||
|
||||
fmt = test_wav((WAVEHEADER*)testbuff);
|
||||
if (fmt != 0)
|
||||
{
|
||||
snd_play = &play_wave;
|
||||
set_reader(&rd, 44);
|
||||
outbuf = UserAlloc(32*1024);
|
||||
touch(outbuf, 32768);
|
||||
}
|
||||
else
|
||||
{ fmt = test_mp3(testbuff);
|
||||
if(fmt ==0) return 0;
|
||||
snd_play = &play_mp3;
|
||||
|
||||
outremain = 0x40000 ;
|
||||
outbuf = UserAlloc(outremain);
|
||||
touch(outbuf, outremain);
|
||||
make_decode_tables(32767);
|
||||
init_layer2();
|
||||
init_layer3(32);
|
||||
fr.single = -1;
|
||||
};
|
||||
|
||||
status = ST_PLAY;
|
||||
|
||||
if (err = CreateBuffer(fmt,0, &hBuff))
|
||||
{
|
||||
debug_out_str("create buffer return error\n\r");
|
||||
; return 0;
|
||||
}
|
||||
|
||||
SetVolume(hBuff,l_vol,r_vol);
|
||||
GetVolume(hBuff,&l_vol,&r_vol);
|
||||
|
||||
create_thread(thread_proc, 0, 4096);
|
||||
|
||||
while(1)
|
||||
{ delay(10);
|
||||
switch(status)
|
||||
{ case ST_PLAY:
|
||||
snd_play();
|
||||
continue;
|
||||
|
||||
case ST_STOP:
|
||||
StopBuffer(hBuff);
|
||||
status = ST_DONE;
|
||||
continue;
|
||||
|
||||
case ST_EXIT:
|
||||
StopBuffer(hBuff);
|
||||
DestroyBuffer(hBuff);
|
||||
return 0;
|
||||
};
|
||||
};
|
||||
return 0;
|
||||
};
|
||||
|
||||
void touch(char *buf, int size)
|
||||
{ int i;
|
||||
char a;
|
||||
for ( i = 0;i < size; i+=4096)
|
||||
a = buf[i];
|
||||
};
|
||||
|
||||
DWORD test_mp3(char *buf)
|
||||
{ unsigned long hdr;
|
||||
WAVEHEADER whdr;
|
||||
outremain = 0x40000 ;
|
||||
if( !(outbuf=UserAlloc(outremain)))
|
||||
return 0;
|
||||
|
||||
while (1)
|
||||
{ if(rd.filepos > 102400)
|
||||
return 0;
|
||||
if(!rd.head_read(&rd,&hdr))
|
||||
return 0;
|
||||
if(!decode_header(&fr,hdr))
|
||||
{ rd.strpos-=3;
|
||||
rd.stream-=3;
|
||||
rd.strremain+=3;
|
||||
continue;
|
||||
};
|
||||
break;
|
||||
};
|
||||
|
||||
first_sync = rd.filepos-rd.strremain-4;
|
||||
|
||||
whdr.riff_id = 0x46464952;
|
||||
whdr.riff_format = 0x45564157;
|
||||
whdr.wFormatTag = 0x01;
|
||||
whdr.nSamplesPerSec = freqs[fr.sampling_frequency];
|
||||
whdr.nChannels = 2; //mpginfo.channels;
|
||||
whdr.wBitsPerSample = 16;
|
||||
|
||||
return test_wav(&whdr);
|
||||
};
|
||||
|
||||
|
||||
void play_mp3()
|
||||
{ char *outPtr;
|
||||
int totalout;
|
||||
int outcount;
|
||||
|
||||
// memset(&fr,0,sizeof(fr));
|
||||
fr.down_sample_sblimit = 32;
|
||||
fr.single = -1;
|
||||
reset_mpg();
|
||||
|
||||
outPtr = outbuf;
|
||||
totalout=0;
|
||||
done = 0;
|
||||
outremain=0x40000;
|
||||
|
||||
memset(outbuf,0,0x40000);
|
||||
set_reader(&rd, 0); //;first_sync);
|
||||
|
||||
while(1)
|
||||
{ if(status!=ST_PLAY)
|
||||
break;
|
||||
|
||||
for(;;)
|
||||
{ outcount = 0;
|
||||
if( !read_frame(&rd, &fr))
|
||||
{ done = 1;
|
||||
break;
|
||||
};
|
||||
fr.do_layer(&fr, outPtr,&outcount);
|
||||
outPtr+= outcount;
|
||||
totalout+=outcount;
|
||||
outremain-=outcount;
|
||||
if(outremain < outcount*2)
|
||||
break;
|
||||
};
|
||||
|
||||
if(done)
|
||||
{ if(totalout < 4096)
|
||||
{ memset(outPtr,0,4096-totalout);
|
||||
totalout = 4096;
|
||||
};
|
||||
}
|
||||
else
|
||||
if(totalout < 8192)
|
||||
continue;
|
||||
outPtr = outbuf;
|
||||
while (totalout >= 4096)
|
||||
{
|
||||
|
||||
WaveOut(hBuff,outPtr,4096);
|
||||
if(status!=ST_PLAY)
|
||||
{ if(status != ST_EXIT)
|
||||
status = ST_STOP;
|
||||
return;
|
||||
};
|
||||
totalout-=4096;
|
||||
outPtr+=4096;
|
||||
outremain+=4096;
|
||||
};
|
||||
if(done)
|
||||
break;
|
||||
touch(outbuf, outremain);
|
||||
|
||||
if ( !(testbuff=UserAlloc(4096)))
|
||||
return 0;
|
||||
|
||||
memmove(outbuf,outPtr, totalout);
|
||||
outPtr = outbuf+totalout;
|
||||
}
|
||||
|
||||
if(status != ST_EXIT)
|
||||
status = ST_STOP;
|
||||
};
|
||||
if (! (inpbuf=UserAlloc(0x10000)))
|
||||
return 0;
|
||||
|
||||
touch(inpbuf, 0x10000);
|
||||
create_reader(&rd, inpbuf, 0x10000);
|
||||
|
||||
void play_wave()
|
||||
{ int retval;
|
||||
|
||||
set_reader(&rd,44);
|
||||
retval = 0;
|
||||
while(1)
|
||||
fname = argv[1];
|
||||
|
||||
if(get_fileinfo(fname, &fileinfo)==FILE_NOT_FOUND)
|
||||
{
|
||||
if(status!=ST_PLAY)
|
||||
break;
|
||||
|
||||
if( !stream_read_raw(&rd,outbuf,32768))
|
||||
{ done = 1;
|
||||
break;
|
||||
};
|
||||
WaveOut(hBuff,outbuf,32768);
|
||||
_asm
|
||||
{
|
||||
mov eax, 23
|
||||
mov ebx, 100
|
||||
int 0x40
|
||||
mov [msg], eax
|
||||
}
|
||||
if (msg != 7)
|
||||
{
|
||||
debug_out_str("\n\rfile not found\n\r");
|
||||
return 0;
|
||||
};
|
||||
incom = recieve_ipc();
|
||||
if(incom->code != 'CNCT')
|
||||
{
|
||||
debug_out_str("\n\rinvalid ipc code\n\r");
|
||||
status = ST_EXIT;
|
||||
return 0;
|
||||
};
|
||||
ipc_client = incom->sender;
|
||||
send_ipc(ipc_client,'CNCT');
|
||||
};
|
||||
|
||||
|
||||
snd_init=0;
|
||||
create_thread(thread_proc, 0, 4096);
|
||||
|
||||
for(snd_init=0,cnt=100; (snd_init==0)&&(cnt!=0); cnt--)
|
||||
delay(10);
|
||||
|
||||
if (!snd_init)
|
||||
return 0;
|
||||
|
||||
draw_window();
|
||||
|
||||
if(status != ST_EXIT)
|
||||
status = ST_STOP;
|
||||
};
|
||||
|
||||
void snd_stop()
|
||||
{
|
||||
StopBuffer(hBuff);
|
||||
};
|
||||
|
||||
void _stdcall thread_proc(void *param)
|
||||
{ int evnt;
|
||||
int pos;
|
||||
int key;
|
||||
|
||||
_asm
|
||||
{
|
||||
mov eax, 66
|
||||
mov ebx, 1
|
||||
mov ecx, 1
|
||||
int 0x40
|
||||
};
|
||||
|
||||
draw_window();
|
||||
|
||||
while(1)
|
||||
while(1)
|
||||
{ if(status==ST_PLAY)
|
||||
{ draw_progress_bar();
|
||||
evnt = wait_for_event(80);
|
||||
@ -464,14 +285,330 @@ void _stdcall thread_proc(void *param)
|
||||
draw_progress_bar();
|
||||
break;
|
||||
};
|
||||
break;
|
||||
case EV_IPC:
|
||||
do_ipc();
|
||||
break;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
return 0;
|
||||
};
|
||||
|
||||
|
||||
void draw_window()
|
||||
{
|
||||
BeginDraw();
|
||||
|
||||
DrawWindow(100,100,299,72,0x404040,3,0,0,0);
|
||||
|
||||
make_button(7,24,45,13, 0x10|BT_NORMAL,0x808080);
|
||||
make_button(56,24,45,13, 0x11|BT_NORMAL,0x808080);
|
||||
make_button(104,24,45,13, 0x12|BT_NORMAL,0x808080);
|
||||
make_button(152,24,45,13, 0x13|BT_NORMAL,0x808080);
|
||||
make_button(200,24,45,13, 0x14|BT_NORMAL,0x808080);
|
||||
make_button(248,24,45,13, 0x15|BT_NORMAL,0x808080);
|
||||
|
||||
make_button(7,41,286,11, 0x30|BT_HIDE|BT_NOFRAME,0x404040);
|
||||
draw_bar(7,41,286,11,0x404040);
|
||||
|
||||
draw_bar(7,55,286,11,0x404040);
|
||||
write_text(12,58,0x004000|FONT0, fname, strlen(fname));
|
||||
write_text(11,57,0x00FF20|FONT0, fname, strlen(fname));
|
||||
|
||||
write_text(8,8,0xFFFFFF|FONT0, header, strlen(header));
|
||||
write_text(12,28,0x404040|FONT0,buttons_text,strlen(buttons_text));
|
||||
write_text(11,27,0xA0FFA0|FONT0,buttons_text,strlen(buttons_text));
|
||||
|
||||
EndDraw();
|
||||
};
|
||||
|
||||
void draw_progress_bar()
|
||||
{ DWORD x;
|
||||
x = 287.0f * (float)(rd.filepos-rd.strremain)/(float)fileinfo.size;
|
||||
if(x==0) return;
|
||||
draw_bar(7,41,x,11,0xA0A0A0);
|
||||
draw_bar(x+7,41,287-x,11,0x404040);
|
||||
};
|
||||
|
||||
void debug_out_str(char* str)
|
||||
{
|
||||
while (*str != 0)
|
||||
{
|
||||
debug_out(*str);
|
||||
str++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void touch(char *buf, int size)
|
||||
{ int i;
|
||||
char a;
|
||||
for ( i = 0;i < size; i+=4096)
|
||||
a = buf[i];
|
||||
};
|
||||
|
||||
DWORD test_mp3(char *buf)
|
||||
{ unsigned long hdr;
|
||||
WAVEHEADER whdr;
|
||||
|
||||
while (1)
|
||||
{ if(rd.filepos > 102400)
|
||||
return 0;
|
||||
if(!rd.head_read(&rd,&hdr))
|
||||
return 0;
|
||||
if(!decode_header(&fr,hdr))
|
||||
{
|
||||
if((hdr & 0xffffff00) == 0x49443300)
|
||||
{
|
||||
int id3length = 0;
|
||||
id3length = parse_new_id3(&rd, hdr);
|
||||
continue;
|
||||
};
|
||||
|
||||
rd.strpos-=3;
|
||||
rd.stream-=3;
|
||||
rd.strremain+=3;
|
||||
continue;
|
||||
};
|
||||
break;
|
||||
};
|
||||
|
||||
first_sync = rd.filepos-rd.strremain-4;
|
||||
|
||||
whdr.riff_id = 0x46464952;
|
||||
whdr.riff_format = 0x45564157;
|
||||
whdr.wFormatTag = 0x01;
|
||||
whdr.nSamplesPerSec = freqs[fr.sampling_frequency];
|
||||
whdr.nChannels = 2; //mpginfo.channels;
|
||||
whdr.wBitsPerSample = 16;
|
||||
|
||||
return test_wav(&whdr);
|
||||
};
|
||||
|
||||
|
||||
void play_mp3()
|
||||
{ char *outPtr;
|
||||
int totalout;
|
||||
int outcount;
|
||||
|
||||
fr.down_sample_sblimit = 32;
|
||||
fr.single = -1;
|
||||
reset_mpg();
|
||||
|
||||
outPtr = outbuf;
|
||||
totalout=0;
|
||||
done = 0;
|
||||
outremain=0x40000;
|
||||
|
||||
memset(outbuf,0,0x40000);
|
||||
set_reader(&rd, 0); //;first_sync);
|
||||
|
||||
while(1)
|
||||
{ if(status!=ST_PLAY)
|
||||
break;
|
||||
|
||||
for(;;)
|
||||
{ outcount = 0;
|
||||
if( !read_frame(&rd, &fr))
|
||||
{ done = 1;
|
||||
break;
|
||||
};
|
||||
fr.do_layer(&fr, outPtr,&outcount);
|
||||
outPtr+= outcount;
|
||||
totalout+=outcount;
|
||||
outremain-=outcount;
|
||||
if(outremain < outcount*2)
|
||||
break;
|
||||
};
|
||||
|
||||
if(done)
|
||||
{ if(totalout < 4096)
|
||||
{ memset(outPtr,0,4096-totalout);
|
||||
totalout = 4096;
|
||||
};
|
||||
}
|
||||
else if(totalout < 8192) continue;
|
||||
|
||||
outPtr = outbuf;
|
||||
while (totalout >= 4096)
|
||||
{
|
||||
WaveOut(hBuff,outPtr,4096);
|
||||
if(status!=ST_PLAY)
|
||||
{ StopBuffer(hBuff);
|
||||
return;
|
||||
};
|
||||
totalout-=4096;
|
||||
outPtr+=4096;
|
||||
outremain+=4096;
|
||||
};
|
||||
|
||||
if(done)
|
||||
{ status = ST_STOP;
|
||||
|
||||
if( ipc_client)
|
||||
send_ipc(ipc_client,'DONE');
|
||||
return;
|
||||
}
|
||||
memmove(outbuf,outPtr, totalout);
|
||||
outPtr = outbuf+totalout;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
int play_track(char *path)
|
||||
{
|
||||
DWORD fmt;
|
||||
DWORD r_bytes;
|
||||
int retval;
|
||||
int err;
|
||||
// int err;
|
||||
|
||||
retval = ST_DONE;
|
||||
|
||||
get_fileinfo(path, &fileinfo);
|
||||
offset = 0;
|
||||
err=read_file (path,testbuff,0,2048,&r_bytes);
|
||||
if (err)
|
||||
return ST_DONE;
|
||||
|
||||
init_reader(&rd,path);
|
||||
|
||||
fmt = test_wav((WAVEHEADER*)testbuff);
|
||||
if (fmt != 0)
|
||||
{
|
||||
snd_play = &play_wave;
|
||||
set_reader(&rd, 44);
|
||||
retval = ST_PLAY;
|
||||
}
|
||||
else
|
||||
{ fmt = test_mp3(testbuff);
|
||||
if(fmt ==0)
|
||||
return ST_DONE;
|
||||
|
||||
snd_play = &play_mp3;
|
||||
outremain = 0x40000;
|
||||
retval = ST_PLAY;
|
||||
};
|
||||
|
||||
SetFormat(hBuff, fmt);
|
||||
return retval;
|
||||
};
|
||||
|
||||
|
||||
void play_wave()
|
||||
{ int retval;
|
||||
|
||||
set_reader(&rd,44);
|
||||
retval = 0;
|
||||
while(1)
|
||||
{
|
||||
if(status!=ST_PLAY)
|
||||
break;
|
||||
|
||||
if( !stream_read_raw(&rd,outbuf,32768))
|
||||
{ done = 1;
|
||||
break;
|
||||
};
|
||||
WaveOut(hBuff,outbuf,32768);
|
||||
};
|
||||
|
||||
if(status != ST_EXIT)
|
||||
status = ST_STOP;
|
||||
};
|
||||
|
||||
void snd_stop()
|
||||
{
|
||||
StopBuffer(hBuff);
|
||||
};
|
||||
|
||||
void do_ipc()
|
||||
{
|
||||
IPC *incom;
|
||||
incom = recieve_ipc();
|
||||
switch(incom->code)
|
||||
{
|
||||
case 'PLAY':
|
||||
fname = incom->data;
|
||||
status = ST_TRACK;
|
||||
return;
|
||||
|
||||
case 'STOP':
|
||||
status = ST_STOP;
|
||||
return;
|
||||
|
||||
case 'EXIT':
|
||||
status = ST_EXIT;
|
||||
exit();
|
||||
};
|
||||
};
|
||||
|
||||
void _stdcall thread_proc(void *param)
|
||||
{
|
||||
int err;
|
||||
|
||||
if (err = CreateBuffer(PCM_ALL|PCM_OUT,0, &hBuff))
|
||||
{
|
||||
debug_out_str("create buffer return error\n\r");
|
||||
exit();
|
||||
};
|
||||
|
||||
SetVolume(hBuff,l_vol,r_vol);
|
||||
GetVolume(hBuff,&l_vol,&r_vol);
|
||||
// debug_out_hex(l_vol);
|
||||
// debug_out_str("\n\r");
|
||||
// debug_out_hex(r_vol);
|
||||
// debug_out_str("\n\r");
|
||||
|
||||
if(fname[0] !='/0')
|
||||
status = play_track(fname);
|
||||
|
||||
debug_out_str("\n\rPlay file ");
|
||||
debug_out_str(fname);
|
||||
debug_out_str("\n\r");
|
||||
|
||||
snd_init = 1;
|
||||
|
||||
while(1)
|
||||
{ delay(10);
|
||||
switch(status)
|
||||
{
|
||||
case ST_TRACK:
|
||||
strcpy(path, fname);
|
||||
status = play_track(fname);
|
||||
if( ipc_client & (status == ST_DONE))
|
||||
{ send_ipc(ipc_client,'DONE');
|
||||
continue;
|
||||
};
|
||||
|
||||
case ST_PLAY:
|
||||
snd_play();
|
||||
continue;
|
||||
|
||||
case ST_STOP:
|
||||
StopBuffer(hBuff);
|
||||
status = ST_DONE;
|
||||
continue;
|
||||
|
||||
case ST_EXIT:
|
||||
StopBuffer(hBuff);
|
||||
DestroyBuffer(hBuff);
|
||||
if (ipc_client)
|
||||
send_ipc(ipc_client,'EXIT');
|
||||
return;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
};
|
||||
|
||||
void delay (int val)
|
||||
{
|
||||
_asm
|
||||
{ mov eax,5
|
||||
{ mov eax,5
|
||||
mov ebx, [val]
|
||||
int 0x40
|
||||
};
|
||||
@ -18,6 +18,7 @@
|
||||
#define ST_PLAY 0x1
|
||||
#define ST_EXIT 0x2
|
||||
#define ST_STOP 0x4
|
||||
#define ST_TRACK 0x5
|
||||
|
||||
|
||||
DWORD test_mp3(char *buf);
|
||||
@ -19,6 +19,9 @@ public _write_text@20
|
||||
public _debug_out@4
|
||||
public _debug_out_hex@4
|
||||
public _create_thread@12
|
||||
public _init_ipc@0
|
||||
public _recieve_ipc@0
|
||||
public _send_ipc@8
|
||||
|
||||
|
||||
public _memset
|
||||
@ -493,3 +496,50 @@ __hexdigits db '0123456789ABCDEF'
|
||||
align 4
|
||||
fileio FILEIO
|
||||
|
||||
|
||||
align 4
|
||||
_init_ipc@0:
|
||||
push ebx
|
||||
mov eax, 60
|
||||
mov ebx, 1
|
||||
mov ecx, ipc_buff
|
||||
mov edx, (5*4+1024)
|
||||
int 0x40
|
||||
pop ebx
|
||||
ret
|
||||
|
||||
align 4
|
||||
_recieve_ipc@0:
|
||||
mov [ipc_buff.size], 8
|
||||
mov eax, ipc_buff.sender
|
||||
ret
|
||||
align 4
|
||||
proc _send_ipc@8 stdcall, dst:dword, code:dword
|
||||
push ebx
|
||||
push esi
|
||||
|
||||
mov eax, 60
|
||||
mov ebx, 2
|
||||
mov ecx, [dst]
|
||||
lea edx, [code]
|
||||
mov esi, 4
|
||||
int 0x40
|
||||
pop esi
|
||||
pop ebx
|
||||
ret
|
||||
endp
|
||||
|
||||
;align 4
|
||||
;ipc_ctrl:
|
||||
; .pid dd ?
|
||||
; .size dd 4
|
||||
; .msg dd ?
|
||||
|
||||
align 4
|
||||
ipc_buff:
|
||||
.lock dd 0
|
||||
.size dd 8
|
||||
.sender dd ?
|
||||
.msg_size dd ?
|
||||
.msg dd ?
|
||||
.data rb 1024
|
||||
220
programs/media/ac97snd/ac97snd/struct.inc
Normal file
220
programs/media/ac97snd/ac97snd/struct.inc
Normal file
@ -0,0 +1,220 @@
|
||||
;*****************************************************************************
|
||||
;*
|
||||
;* Open Watcom Project
|
||||
;*
|
||||
;* Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
|
||||
;*
|
||||
;* ========================================================================
|
||||
;*
|
||||
;* This file contains Original Code and/or Modifications of Original
|
||||
;* Code as defined in and that are subject to the Sybase Open Watcom
|
||||
;* Public License version 1.0 (the 'License'). You may not use this file
|
||||
;* except in compliance with the License. BY USING THIS FILE YOU AGREE TO
|
||||
;* ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
|
||||
;* provided with the Original Code and Modifications, and is also
|
||||
;* available at www.sybase.com/developer/opensource.
|
||||
;*
|
||||
;* The Original Code and all software distributed under the License are
|
||||
;* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
|
||||
;* EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
|
||||
;* ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
|
||||
;* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
|
||||
;* NON-INFRINGEMENT. Please see the License for the specific language
|
||||
;* governing rights and limitations under the License.
|
||||
;*
|
||||
;* ========================================================================
|
||||
;*
|
||||
;* Description: Structured macros for MASM/WASM.
|
||||
;*
|
||||
;*****************************************************************************
|
||||
|
||||
|
||||
__label = 0
|
||||
__depth = 0
|
||||
__inner_loop = 0
|
||||
|
||||
_guess macro name
|
||||
__depth = __depth + 1
|
||||
__label = __label + 1
|
||||
_set __astk,%__depth,__label,<>
|
||||
__label = __label + 1
|
||||
_set __estk,%__depth,__label,<>
|
||||
ifnb <name>
|
||||
name = __label
|
||||
endif
|
||||
endm
|
||||
|
||||
_quif macro cc,name
|
||||
ifnb <name>
|
||||
_set __elbl,,name,<>
|
||||
_j cc,_l,%__elbl
|
||||
else
|
||||
_set __albl,,__astk,%__depth
|
||||
_j cc,_l,%__albl
|
||||
endif
|
||||
endm
|
||||
|
||||
_quit macro name
|
||||
_quif ,name
|
||||
endm
|
||||
|
||||
_admit macro
|
||||
_set __albl,,__astk,%__depth
|
||||
__label = __label + 1
|
||||
_set __astk,%__depth,__label,<>
|
||||
_set __elbl,,__estk,%__depth
|
||||
_j ,_l,%__elbl
|
||||
_label _l,%__albl
|
||||
endm
|
||||
|
||||
_endguess macro
|
||||
_set __albl,,__astk,%__depth
|
||||
_label _l,%__albl
|
||||
_set __elbl,,__estk,%__depth
|
||||
_label _l,%__elbl
|
||||
__depth = __depth - 1
|
||||
endm
|
||||
|
||||
_loop macro name
|
||||
_guess name
|
||||
_set __albl,,__astk,%__depth
|
||||
_label _m,%__albl
|
||||
_set __elbl,,__estk,%__depth
|
||||
_label _m,%__elbl
|
||||
_set __llbl,%__depth,%__inner_loop,<>
|
||||
_set __inner_loop,,%__depth,<>
|
||||
endm
|
||||
|
||||
_loopif macro cc,name
|
||||
ifnb <name>
|
||||
_set __elbl,,name,<>
|
||||
_j cc,_m,%__elbl
|
||||
else
|
||||
_set __albl,,__astk,%__inner_loop
|
||||
_j cc,_m,%__albl
|
||||
endif
|
||||
endm
|
||||
|
||||
_until macro cc
|
||||
_set __albl,,__astk,%__depth
|
||||
_jn cc,_m,%__albl
|
||||
_set __inner_loop,,__llbl,%__depth
|
||||
_endguess
|
||||
endm
|
||||
|
||||
_endloop macro
|
||||
_set __albl,,__astk,%__depth
|
||||
_j ,_m,%__albl
|
||||
_set __inner_loop,,__llbl,%__depth
|
||||
_endguess
|
||||
endm
|
||||
|
||||
_if macro cc
|
||||
_guess
|
||||
_set __albl,,__astk,%__depth
|
||||
_jn cc,_l,%__albl
|
||||
endm
|
||||
|
||||
_else macro
|
||||
_admit
|
||||
endm
|
||||
|
||||
_endif macro
|
||||
_endguess
|
||||
endm
|
||||
|
||||
_set macro base1,ext1,base2,ext2
|
||||
base1&ext1 = base2&ext2
|
||||
endm
|
||||
|
||||
_label macro base,ext
|
||||
base&ext:
|
||||
endm
|
||||
|
||||
_j macro cc,base,ext
|
||||
j&cc base&ext
|
||||
endm
|
||||
|
||||
_jn macro cc,base,ext
|
||||
jn&cc base&ext
|
||||
endm
|
||||
|
||||
jnna macro label
|
||||
ja label
|
||||
endm
|
||||
|
||||
jnnae macro label
|
||||
jae label
|
||||
endm
|
||||
|
||||
jnnb macro label
|
||||
jb label
|
||||
endm
|
||||
|
||||
jnnbe macro label
|
||||
jbe label
|
||||
endm
|
||||
|
||||
jnnc macro label
|
||||
jc label
|
||||
endm
|
||||
|
||||
jnne macro label
|
||||
je label
|
||||
endm
|
||||
|
||||
jnng macro label
|
||||
jg label
|
||||
endm
|
||||
|
||||
jnnge macro label
|
||||
jge label
|
||||
endm
|
||||
|
||||
jnnl macro label
|
||||
jl label
|
||||
endm
|
||||
|
||||
jnnle macro label
|
||||
jle label
|
||||
endm
|
||||
|
||||
jnno macro label
|
||||
jo label
|
||||
endm
|
||||
|
||||
jnnp macro label
|
||||
jp label
|
||||
endm
|
||||
|
||||
jnns macro label
|
||||
js label
|
||||
endm
|
||||
|
||||
jnnz macro label
|
||||
jz label
|
||||
endm
|
||||
|
||||
jnpe macro label
|
||||
jpo label
|
||||
endm
|
||||
|
||||
jnpo macro label
|
||||
jpe label
|
||||
endm
|
||||
|
||||
j macro label
|
||||
jmp label
|
||||
endm
|
||||
|
||||
jn macro label
|
||||
nop
|
||||
endm
|
||||
|
||||
_shl macro reg,count
|
||||
add reg,reg
|
||||
endm
|
||||
|
||||
_rcl macro reg,count
|
||||
adc reg,reg
|
||||
endm
|
||||
19
programs/media/ac97snd/fasm.rules
Normal file
19
programs/media/ac97snd/fasm.rules
Normal file
@ -0,0 +1,19 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<VisualStudioToolFile
|
||||
Name="FASM"
|
||||
Version="8,00"
|
||||
>
|
||||
<Rules>
|
||||
<CustomBuildRule
|
||||
Name="FASM"
|
||||
DisplayName="FASM"
|
||||
CommandLine="fasm.exe $(InputPath) $(ProjectDir)\Release\$(InputName).obj"
|
||||
Outputs="Release\$(InputName).obj"
|
||||
FileExtensions="*.asm"
|
||||
ExecutionDescription="Assembling..."
|
||||
>
|
||||
<Properties>
|
||||
</Properties>
|
||||
</CustomBuildRule>
|
||||
</Rules>
|
||||
</VisualStudioToolFile>
|
||||
@ -2,9 +2,9 @@
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="8,00"
|
||||
Name="mp3dec"
|
||||
ProjectGUID="{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}"
|
||||
RootNamespace="mp3dec"
|
||||
Name="mpg"
|
||||
ProjectGUID="{6BB005B0-3277-4C8C-950F-38E15A4E440C}"
|
||||
RootNamespace="mpg"
|
||||
Keyword="Win32Proj"
|
||||
>
|
||||
<Platforms>
|
||||
@ -13,6 +13,9 @@
|
||||
/>
|
||||
</Platforms>
|
||||
<ToolFiles>
|
||||
<ToolFile
|
||||
RelativePath="../fasm.rules"
|
||||
/>
|
||||
</ToolFiles>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
@ -20,7 +23,8 @@
|
||||
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||
IntermediateDirectory="$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="1"
|
||||
CharacterSet="0"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
@ -28,6 +32,9 @@
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="FASM"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
@ -39,15 +46,18 @@
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
UseUnicodeResponseFiles="false"
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
|
||||
MinimalRebuild="true"
|
||||
MinimalRebuild="false"
|
||||
ExceptionHandling="0"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="3"
|
||||
FloatingPointModel="2"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="true"
|
||||
DebugInformationFormat="4"
|
||||
Detect64BitPortabilityProblems="false"
|
||||
DebugInformationFormat="0"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
@ -60,12 +70,15 @@
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
UseUnicodeResponseFiles="false"
|
||||
IgnoreAllDefaultLibraries="true"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
UseUnicodeResponseFiles="false"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
@ -82,7 +95,7 @@
|
||||
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||
IntermediateDirectory="$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="1"
|
||||
CharacterSet="2"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
@ -91,6 +104,9 @@
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="FASM"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
@ -102,10 +118,9 @@
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="2"
|
||||
InlineFunctionExpansion="2"
|
||||
Optimization="1"
|
||||
EnableIntrinsicFunctions="true"
|
||||
FavorSizeOrSpeed="1"
|
||||
FavorSizeOrSpeed="2"
|
||||
OmitFramePointers="true"
|
||||
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
|
||||
ExceptionHandling="0"
|
||||
@ -115,9 +130,8 @@
|
||||
FloatingPointModel="2"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="true"
|
||||
DebugInformationFormat="3"
|
||||
CompileAs="1"
|
||||
Detect64BitPortabilityProblems="false"
|
||||
DebugInformationFormat="0"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
@ -157,104 +171,67 @@
|
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\bstream.c"
|
||||
RelativePath=".\dct64_i386.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\dct64_i486.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_i386.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_i486.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\e_pow.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\fdct.c"
|
||||
RelativePath=".\getbits.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\imdct.c"
|
||||
RelativePath=".\layer1.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l1dec.c"
|
||||
RelativePath=".\layer2.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l1init.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l2dec.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l2init.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3alias.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3dec.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3huff.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3hybrid.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3init.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3msis.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3quant.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3sf.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l3side.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\mp3dec.c"
|
||||
RelativePath=".\layer3.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\pow.asm"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
CommandLine="e:\fasm\fasm.exe $(InputPath) $(TargetDir)\$(InputName).obj
"
|
||||
Outputs="$(OutDir)\$(InputName).obj"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\sbt.c"
|
||||
RelativePath=".\readers.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\sbtb.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\window.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\windowb.c"
|
||||
RelativePath=".\tabinit.c"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
@ -263,6 +240,30 @@
|
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\getbits.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\huffman.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l2tables.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\layer3.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\math_private.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\mpg123.h"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Resource Files"
|
||||
@ -85,7 +85,8 @@ struct bitstream_info
|
||||
extern struct bitstream_info bsi;
|
||||
|
||||
struct reader
|
||||
{ char *hFile;
|
||||
{
|
||||
char *hFile;
|
||||
unsigned char *buffer;
|
||||
unsigned char *stream;
|
||||
int strpos;
|
||||
@ -96,6 +97,8 @@ struct reader
|
||||
int (*head_read)(struct reader *,unsigned long *newhead);
|
||||
int (*read_frame_body)(struct reader *,unsigned char *,int size);
|
||||
};
|
||||
|
||||
int parse_new_id3(struct reader *rd, unsigned long newhead);
|
||||
|
||||
struct al_table
|
||||
{ short bits;
|
||||
37
programs/media/ac97snd/mpg/pow.asm
Normal file
37
programs/media/ac97snd/mpg/pow.asm
Normal file
@ -0,0 +1,37 @@
|
||||
; ix87 specific implementation of pow function.
|
||||
; Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
|
||||
; This file is part of the GNU C Library.
|
||||
; Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
|
||||
|
||||
; The GNU C Library is free software; you can redistribute it and/or
|
||||
; modify it under the terms of the GNU Library General Public License as
|
||||
; published by the Free Software Foundation; either version 2 of the
|
||||
; License, or (at your option) any later version.
|
||||
|
||||
; The GNU C Library is distributed in the hope that it will be useful,
|
||||
; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
; Library General Public License for more details.
|
||||
|
||||
; You should have received a copy of the GNU Library General Public
|
||||
; License along with the GNU C Library; see the file COPYING.LIB. If not,
|
||||
; write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
; Boston, MA 02111-1307, USA. */
|
||||
|
||||
format MS COFF
|
||||
|
||||
include 'proc32.inc'
|
||||
|
||||
section '.text' code readable executable
|
||||
|
||||
public _scalbn
|
||||
|
||||
align 4
|
||||
proc _scalbn
|
||||
fild dword [esp+12]
|
||||
fld qword [esp+4]
|
||||
fscale
|
||||
fstp st1
|
||||
ret
|
||||
endp
|
||||
|
||||
@ -277,11 +277,18 @@ int read_frame(struct reader *rd, struct frame *fr)
|
||||
|
||||
read_again:
|
||||
|
||||
if(!rd->head_read(rd,&newhead))
|
||||
return FALSE;
|
||||
if(!rd->head_read(rd,&newhead))
|
||||
return FALSE;
|
||||
|
||||
if(!decode_header(fr,newhead))
|
||||
{ rd->strpos-=3;
|
||||
{
|
||||
if((newhead & 0xffffff00) == 0x49443300)
|
||||
{
|
||||
int id3length = 0;
|
||||
id3length = parse_new_id3(rd, newhead);
|
||||
goto read_again;
|
||||
};
|
||||
rd->strpos-=3;
|
||||
rd->stream-=3;
|
||||
rd->strremain+=3;
|
||||
goto read_again;
|
||||
@ -886,4 +893,63 @@ static off_t get_fileinfo(struct reader *rds,char *buf)
|
||||
return len;
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define syncsafe_to_long(buf,res) \
|
||||
( \
|
||||
(((buf)[0]|(buf)[1]|(buf)[2]|(buf)[3]) & 0x80) ? 0 : \
|
||||
(res = (((unsigned long) (buf)[0]) << 27) \
|
||||
| (((unsigned long) (buf)[1]) << 14) \
|
||||
| (((unsigned long) (buf)[2]) << 7) \
|
||||
| ((unsigned long) (buf)[3]) \
|
||||
,1) \
|
||||
)
|
||||
|
||||
int parse_new_id3(struct reader *rd, unsigned long header)
|
||||
{
|
||||
#define UNSYNC_FLAG 128
|
||||
#define EXTHEAD_FLAG 64
|
||||
#define EXP_FLAG 32
|
||||
#define FOOTER_FLAG 16
|
||||
#define UNKNOWN_FLAGS 15 /* 00001111*/
|
||||
unsigned char buf[6];
|
||||
unsigned long length=0;
|
||||
unsigned char flags = 0;
|
||||
int ret = 1;
|
||||
unsigned char* tagdata = NULL;
|
||||
unsigned char major = header & 0xff;
|
||||
|
||||
if(major == 0xff) return -1;
|
||||
|
||||
if (!rd->read_frame_body(rd,buf,6))
|
||||
return 0;
|
||||
if(buf[0] == 0xff) /* major version, will never be 0xff */
|
||||
return -1;
|
||||
|
||||
/* second new byte are some nice flags, if these are invalid skip the whole thing */
|
||||
flags = buf[1];
|
||||
/* use 4 bytes from buf to construct 28bit uint value and return 1; return 0 if bytes are not syncsafe */
|
||||
|
||||
if(!syncsafe_to_long(buf+2,length))
|
||||
return -1;
|
||||
|
||||
|
||||
rd->strpos+=length;
|
||||
rd->stream+=length;
|
||||
rd->strremain-=length;
|
||||
|
||||
#if 0
|
||||
/* skip if unknown version/scary flags, parse otherwise */
|
||||
if((flags & UNKNOWN_FLAGS) || (major > 4))
|
||||
{
|
||||
/* going to skip because there are unknown flags set */
|
||||
if(!rds->skip_bytes(rds,length)) /* will not store data in backbuff! */
|
||||
|
||||
rd->strpos+=length;
|
||||
rd->stream+=length;
|
||||
rd->strremain-=length;
|
||||
ret = 0;
|
||||
};
|
||||
#endif
|
||||
return length;
|
||||
};
|
||||
@ -7,7 +7,7 @@ extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#define SOUND_VERSION 0x0101
|
||||
#define SOUND_VERSION 0x0100
|
||||
#define PCM_ALL 0
|
||||
|
||||
#define PCM_OUT 0x08000000
|
||||
@ -1,44 +0,0 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 9.00
|
||||
# Visual Studio 2005
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pe2kos", "pe2kos\pe2kos.vcproj", "{50E3FB09-4E3A-4998-A824-6830405193AE}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mp3dec", "mp3dec\mp3dec.vcproj", "{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ac97", "ac97\ac97.vcproj", "{1C94A897-DA4F-45B2-B8A6-B97AD837828E}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{CF807B93-2860-41DF-A4D2-5B92B52DFD96} = {CF807B93-2860-41DF-A4D2-5B92B52DFD96}
|
||||
{C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1} = {C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mpg", "mpg\mpg.vcproj", "{CF807B93-2860-41DF-A4D2-5B92B52DFD96}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sound", "sound\sound.vcproj", "{C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Release|Win32 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{50E3FB09-4E3A-4998-A824-6830405193AE}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{50E3FB09-4E3A-4998-A824-6830405193AE}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{50E3FB09-4E3A-4998-A824-6830405193AE}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Release|Win32.Build.0 = Release|Win32
|
||||
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Release|Win32.Build.0 = Release|Win32
|
||||
{CF807B93-2860-41DF-A4D2-5B92B52DFD96}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{CF807B93-2860-41DF-A4D2-5B92B52DFD96}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{CF807B93-2860-41DF-A4D2-5B92B52DFD96}.Release|Win32.Build.0 = Release|Win32
|
||||
{C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{C8D44F9A-B5DF-4A94-AA92-47D9945FD4F1}.Release|Win32.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
@ -1,212 +0,0 @@
|
||||
/* max bits required for any lookup - change if htable changes */
|
||||
/* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */
|
||||
#define MAXBITS 9
|
||||
|
||||
static unsigned int bitbuf;
|
||||
static int bits;
|
||||
static unsigned char *bs_ptr;
|
||||
static unsigned char *bs_ptr0;
|
||||
static unsigned char *bs_ptr_end; // optional for overrun test
|
||||
|
||||
void bitget_init(unsigned char *buf)
|
||||
{
|
||||
bs_ptr0 = bs_ptr = buf;
|
||||
bits = 0;
|
||||
bitbuf = 0;
|
||||
}
|
||||
|
||||
int bitget(int n)
|
||||
{
|
||||
unsigned int x;
|
||||
|
||||
if (bits < n)
|
||||
{ /* refill bit buf if necessary */
|
||||
while (bits <= 24)
|
||||
{
|
||||
bitbuf = (bitbuf << 8) | *bs_ptr++;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
bits -= n;
|
||||
x = bitbuf >> bits;
|
||||
bitbuf -= x << bits;
|
||||
return x;
|
||||
}
|
||||
|
||||
void bitget_skip(int n)
|
||||
{
|
||||
unsigned int k;
|
||||
|
||||
if (bits < n)
|
||||
{
|
||||
n -= bits;
|
||||
k = n >> 3;
|
||||
/*--- bytes = n/8 --*/
|
||||
bs_ptr += k;
|
||||
n -= k << 3;
|
||||
bitbuf = *bs_ptr++;
|
||||
bits = 8;
|
||||
}
|
||||
bits -= n;
|
||||
bitbuf -= (bitbuf >> bits) << bits;
|
||||
}
|
||||
|
||||
void bitget_init_end(unsigned char *buf_end)
|
||||
{
|
||||
bs_ptr_end = buf_end;
|
||||
}
|
||||
|
||||
/*------------- check overrun -------------*/
|
||||
int bitget_overrun()
|
||||
{
|
||||
return bs_ptr > bs_ptr_end;
|
||||
}
|
||||
/*------------- get n bits from bitstream -------------*/
|
||||
int bitget_bits_used()
|
||||
{
|
||||
unsigned int n; /* compute bits used from last init call */
|
||||
|
||||
n = ((bs_ptr - bs_ptr0) << 3) - bits;
|
||||
return n;
|
||||
}
|
||||
/*------------- check for n bits in bitbuf -------------*/
|
||||
void bitget_check(int n)
|
||||
{
|
||||
if (bits < n)
|
||||
{
|
||||
while (bits <= 24)
|
||||
{
|
||||
bitbuf = (bitbuf << 8) | *bs_ptr++;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
/*------------- get 1 bit from bitstream -------------*/
|
||||
int bitget_1bit()
|
||||
{
|
||||
unsigned int x;
|
||||
|
||||
if (bits <= 0)
|
||||
{ /* refill bit buf if necessary */
|
||||
while (bits <= 24)
|
||||
{
|
||||
bitbuf = (bitbuf << 8) | *bs_ptr++;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
bits--;
|
||||
x = bitbuf >> bits;
|
||||
bitbuf -= x << bits;
|
||||
return x;
|
||||
}
|
||||
|
||||
/*------------- get 1 bit from bitstream NO CHECK -------------*/
|
||||
int bitget_1bit()
|
||||
{
|
||||
unsigned int x;
|
||||
|
||||
bits--;
|
||||
x = bitbuf >> bits;
|
||||
bitbuf -= x << bits;
|
||||
return x;
|
||||
}
|
||||
#endif
|
||||
/* only huffman */
|
||||
|
||||
/*----- get n bits - checks for n+2 avail bits (linbits+sign) -----*/
|
||||
int bitget_lb(int n)
|
||||
{
|
||||
unsigned int x;
|
||||
|
||||
if (bits < (n + 2))
|
||||
{ /* refill bit buf if necessary */
|
||||
while (bits <= 24)
|
||||
{
|
||||
bitbuf = (bitbuf << 8) | *bs_ptr++;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
bits -= n;
|
||||
x = bitbuf >> bits;
|
||||
bitbuf -= x << bits;
|
||||
return x;
|
||||
}
|
||||
|
||||
/*------------- get n bits but DO NOT remove from bitstream --*/
|
||||
int bitget2(int n)
|
||||
{
|
||||
unsigned int x;
|
||||
|
||||
if (bits < (MAXBITS + 2))
|
||||
{ /* refill bit buf if necessary */
|
||||
while (bits <= 24)
|
||||
{
|
||||
bitbuf = (bitbuf << 8) | *bs_ptr++;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
x = bitbuf >> (bits - n);
|
||||
return x;
|
||||
}
|
||||
|
||||
/*------------- remove n bits from bitstream ---------*/
|
||||
void bitget_purge(int n)
|
||||
{
|
||||
bits -= n;
|
||||
bitbuf -= (bitbuf >> bits) << bits;
|
||||
}
|
||||
|
||||
void mac_bitget_check(int n)
|
||||
{
|
||||
if( bits < n ) {
|
||||
while( bits <= 24 ) {
|
||||
bitbuf = (bitbuf << 8) | *bs_ptr++;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int mac_bitget(int n)
|
||||
{
|
||||
unsigned int code;
|
||||
|
||||
bits -= n;
|
||||
code = bitbuf >> bits;
|
||||
bitbuf -= code << bits;
|
||||
return code;
|
||||
}
|
||||
|
||||
int mac_bitget2(int n)
|
||||
{
|
||||
return (bitbuf >> (bits-n));
|
||||
}
|
||||
|
||||
int mac_bitget_1bit()
|
||||
{
|
||||
unsigned int code;
|
||||
|
||||
bits--;
|
||||
code = bitbuf >> bits;
|
||||
bitbuf -= code << bits;
|
||||
return code;
|
||||
}
|
||||
|
||||
void mac_bitget_purge(int n)
|
||||
{
|
||||
bits -= n;
|
||||
bitbuf -= (bitbuf >> bits) << bits;
|
||||
}
|
||||
|
||||
/*
|
||||
#define mac_bitget(n) ( bits -= n, \
|
||||
code = bitbuf >> bits, \
|
||||
bitbuf -= code << bits, \
|
||||
code )
|
||||
|
||||
#define mac_bitget_1bit() ( bits--, \
|
||||
code = bitbuf >> bits, \
|
||||
bitbuf -= code << bits, \
|
||||
code )
|
||||
*/
|
||||
@ -1,23 +0,0 @@
|
||||
typedef unsigned char byte;
|
||||
typedef unsigned int uint;
|
||||
|
||||
typedef void (*SBT_PROC) (float *sample, void *pcm, int n);
|
||||
typedef void (*XFORM_PROC) (void *pcm, int igr);
|
||||
|
||||
void bitget_init(unsigned char *buf);
|
||||
void bitget_init_end(unsigned char *buf_end);
|
||||
int bitget_overrun();
|
||||
int bitget_bits_used();
|
||||
void bitget_check(int n);
|
||||
int bitget(int n);
|
||||
void bitget_skip(int n);
|
||||
//int bitget_1bit();
|
||||
|
||||
int bitget_lb(int n);
|
||||
int bitget2(int n);
|
||||
void bitget_purge(int n);
|
||||
void mac_bitget_check(int n);
|
||||
int mac_bitget(int n);
|
||||
int mac_bitget_1bit();
|
||||
int mac_bitget2(int n);
|
||||
void mac_bitget_purge(int n);
|
||||
@ -1,358 +0,0 @@
|
||||
/* @(#)e_pow.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
/* Modified by Naohiko Shimizu/Tokai University, Japan 1997/08/25,
|
||||
for performance improvement on pipelined processors.
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static char rcsid[] = "$NetBSD: e_pow.c,v 1.9 1995/05/12 04:57:32 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* __ieee754_pow(x,y) return x**y
|
||||
*
|
||||
* n
|
||||
* Method: Let x = 2 * (1+f)
|
||||
* 1. Compute and return log2(x) in two pieces:
|
||||
* log2(x) = w1 + w2,
|
||||
* where w1 has 53-24 = 29 bit trailing zeros.
|
||||
* 2. Perform y*log2(x) = n+y' by simulating muti-precision
|
||||
* arithmetic, where |y'|<=0.5.
|
||||
* 3. Return x**y = 2**n*exp(y'*log2)
|
||||
*
|
||||
* Special cases:
|
||||
* 1. (anything) ** 0 is 1
|
||||
* 2. (anything) ** 1 is itself
|
||||
* 3. (anything) ** NAN is NAN
|
||||
* 4. NAN ** (anything except 0) is NAN
|
||||
* 5. +-(|x| > 1) ** +INF is +INF
|
||||
* 6. +-(|x| > 1) ** -INF is +0
|
||||
* 7. +-(|x| < 1) ** +INF is +0
|
||||
* 8. +-(|x| < 1) ** -INF is +INF
|
||||
* 9. +-1 ** +-INF is NAN
|
||||
* 10. +0 ** (+anything except 0, NAN) is +0
|
||||
* 11. -0 ** (+anything except 0, NAN, odd integer) is +0
|
||||
* 12. +0 ** (-anything except 0, NAN) is +INF
|
||||
* 13. -0 ** (-anything except 0, NAN, odd integer) is +INF
|
||||
* 14. -0 ** (odd integer) = -( +0 ** (odd integer) )
|
||||
* 15. +INF ** (+anything except 0,NAN) is +INF
|
||||
* 16. +INF ** (-anything except 0,NAN) is +0
|
||||
* 17. -INF ** (anything) = -0 ** (-anything)
|
||||
* 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
|
||||
* 19. (-anything except 0 and inf) ** (non-integer) is NAN
|
||||
*
|
||||
* Accuracy:
|
||||
* pow(x,y) returns x**y nearly rounded. In particular
|
||||
* pow(integer,integer)
|
||||
* always returns the correct integer provided it is
|
||||
* representable.
|
||||
*
|
||||
* Constants :
|
||||
* The hexadecimal values are the intended ones for the following
|
||||
* constants. The decimal values may be used, provided that the
|
||||
* compiler will convert from decimal to binary accurately enough
|
||||
* to produce the hexadecimal values shown.
|
||||
*/
|
||||
|
||||
#include "math.h"
|
||||
#include "math_private.h"
|
||||
#define zero C[0]
|
||||
#define one C[1]
|
||||
#define two C[2]
|
||||
#define two53 C[3]
|
||||
#define huge C[4]
|
||||
#define tiny C[5]
|
||||
#define L1 C[6]
|
||||
#define L2 C[7]
|
||||
#define L3 C[8]
|
||||
#define L4 C[9]
|
||||
#define L5 C[10]
|
||||
#define L6 C[11]
|
||||
#define P1 C[12]
|
||||
#define P2 C[13]
|
||||
#define P3 C[14]
|
||||
#define P4 C[15]
|
||||
#define P5 C[16]
|
||||
#define lg2 C[17]
|
||||
#define lg2_h C[18]
|
||||
#define lg2_l C[19]
|
||||
#define ovt C[20]
|
||||
#define cp C[21]
|
||||
#define cp_h C[22]
|
||||
#define cp_l C[23]
|
||||
#define ivln2 C[24]
|
||||
#define ivln2_h C[25]
|
||||
#define ivln2_l C[26]
|
||||
|
||||
double scalbn(double,int);
|
||||
|
||||
#define EXTRACT_WORDS(ix0,ix1,d) \
|
||||
do { \
|
||||
ieee_double_shape_type ew_u; \
|
||||
ew_u.value = (d); \
|
||||
(ix0) = ew_u.parts.msw; \
|
||||
(ix1) = ew_u.parts.lsw; \
|
||||
} while (0)
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
bp[] = {1.0, 1.5,},
|
||||
dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
|
||||
dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
|
||||
C[] = {
|
||||
0.0,
|
||||
1.0,
|
||||
2.0,
|
||||
9007199254740992.0 ,
|
||||
1.0e300,
|
||||
1.0e-300,
|
||||
5.99999999999994648725e-01 ,
|
||||
4.28571428578550184252e-01 ,
|
||||
3.33333329818377432918e-01 ,
|
||||
2.72728123808534006489e-01 ,
|
||||
2.30660745775561754067e-01 ,
|
||||
2.06975017800338417784e-01 ,
|
||||
1.66666666666666019037e-01 ,
|
||||
-2.77777777770155933842e-03 ,
|
||||
6.61375632143793436117e-05 ,
|
||||
-1.65339022054652515390e-06 ,
|
||||
4.13813679705723846039e-08 ,
|
||||
6.93147180559945286227e-01 ,
|
||||
6.93147182464599609375e-01 ,
|
||||
-1.90465429995776804525e-09 ,
|
||||
8.0085662595372944372e-0017 ,
|
||||
9.61796693925975554329e-01 ,
|
||||
9.61796700954437255859e-01 ,
|
||||
-7.02846165095275826516e-09 ,
|
||||
1.44269504088896338700e+00 ,
|
||||
1.44269502162933349609e+00 ,
|
||||
1.92596299112661746887e-08 };
|
||||
|
||||
double pow_test(x,y)
|
||||
double x, y;
|
||||
{
|
||||
double z,ax,z_h,z_l,p_h,p_l;
|
||||
double y1,t1,t2,r,s,t,u,v,w, t12,t14,r_1,r_2,r_3;
|
||||
int32_t i,j,k,yisint,n;
|
||||
int32_t hx,hy,ix,iy;
|
||||
u_int32_t lx,ly;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
EXTRACT_WORDS(hy,ly,y);
|
||||
ix = hx&0x7fffffff; iy = hy&0x7fffffff;
|
||||
|
||||
/* y==zero: x**0 = 1 */
|
||||
if((iy|ly)==0) return C[1];
|
||||
|
||||
/* +-NaN return x+y */
|
||||
if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) ||
|
||||
iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0)))
|
||||
return x+y;
|
||||
|
||||
/* determine if y is an odd int when x < 0
|
||||
* yisint = 0 ... y is not an integer
|
||||
* yisint = 1 ... y is an odd int
|
||||
* yisint = 2 ... y is an even int
|
||||
*/
|
||||
yisint = 0;
|
||||
if(hx<0) {
|
||||
if(iy>=0x43400000) yisint = 2; /* even integer y */
|
||||
else if(iy>=0x3ff00000) {
|
||||
k = (iy>>20)-0x3ff; /* exponent */
|
||||
if(k>20) {
|
||||
j = ly>>(52-k);
|
||||
if((u_int32_t)(j<<(52-k))==ly) yisint = 2-(j&1);
|
||||
} else if(ly==0) {
|
||||
j = iy>>(20-k);
|
||||
if((int32_t)(j<<(20-k))==iy) yisint = 2-(j&1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* special value of y */
|
||||
if(ly==0) {
|
||||
if (iy==0x7ff00000) { /* y is +-inf */
|
||||
if(((ix-0x3ff00000)|lx)==0)
|
||||
return y - y; /* inf**+-1 is NaN */
|
||||
else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */
|
||||
return (hy>=0)? y: C[0];
|
||||
else /* (|x|<1)**-,+inf = inf,0 */
|
||||
return (hy<0)?-y: C[0];
|
||||
}
|
||||
if(iy==0x3ff00000) { /* y is +-1 */
|
||||
if(hy<0) return C[1]/x; else return x;
|
||||
}
|
||||
if(hy==0x40000000) return x*x; /* y is 2 */
|
||||
if(hy==0x3fe00000) { /* y is 0.5 */
|
||||
if(hx>=0) /* x >= +0 */
|
||||
return sqrt(x);
|
||||
}
|
||||
}
|
||||
|
||||
ax = fabs(x);
|
||||
/* special value of x */
|
||||
if(lx==0) {
|
||||
if(ix==0x7ff00000||ix==0||ix==0x3ff00000){
|
||||
z = ax; /*x is +-0,+-inf,+-1*/
|
||||
if(hy<0) z = C[1]/z; /* z = (1/|x|) */
|
||||
if(hx<0) {
|
||||
if(((ix-0x3ff00000)|yisint)==0) {
|
||||
z = (z-z)/(z-z); /* (-1)**non-int is NaN */
|
||||
} else if(yisint==1)
|
||||
z = -z; /* (x<0)**odd = -(|x|**odd) */
|
||||
}
|
||||
return z;
|
||||
}
|
||||
}
|
||||
|
||||
/* (x<0)**(non-int) is NaN */
|
||||
if(((((u_int32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x);
|
||||
|
||||
/* |y| is huge */
|
||||
if(iy>0x41e00000) { /* if |y| > 2**31 */
|
||||
if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */
|
||||
if(ix<=0x3fefffff) return (hy<0)? C[4]*C[4]:C[5]*C[5];
|
||||
if(ix>=0x3ff00000) return (hy>0)? C[4]*C[4]:C[5]*C[5];
|
||||
}
|
||||
/* over/underflow if x is not close to one */
|
||||
if(ix<0x3fefffff) return (hy<0)? C[4]*C[4]:C[5]*C[5];
|
||||
if(ix>0x3ff00000) return (hy>0)? C[4]*C[4]:C[5]*C[5];
|
||||
/* now |1-x| is tiny <= 2**-20, suffice to compute
|
||||
log(x) by x-x^2/2+x^3/3-x^4/4 */
|
||||
t = x-1; /* t has 20 trailing zeros */
|
||||
w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25));
|
||||
u = C[25]*t; /* ivln2_h has 21 sig. bits */
|
||||
v = t*C[26]-w*C[24];
|
||||
t1 = u+v;
|
||||
SET_LOW_WORD(t1,0);
|
||||
t2 = v-(t1-u);
|
||||
} else {
|
||||
double s2,s_h,s_l,t_h,t_l,s22,s24,s26,r1,r2,r3;
|
||||
n = 0;
|
||||
/* take care subnormal number */
|
||||
if(ix<0x00100000)
|
||||
{ax *= C[3]; n -= 53; GET_HIGH_WORD(ix,ax); }
|
||||
n += ((ix)>>20)-0x3ff;
|
||||
j = ix&0x000fffff;
|
||||
/* determine interval */
|
||||
ix = j|0x3ff00000; /* normalize ix */
|
||||
if(j<=0x3988E) k=0; /* |x|<sqrt(3/2) */
|
||||
else if(j<0xBB67A) k=1; /* |x|<sqrt(3) */
|
||||
else {k=0;n+=1;ix -= 0x00100000;}
|
||||
SET_HIGH_WORD(ax,ix);
|
||||
|
||||
/* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
|
||||
u = ax-bp[k]; /* bp[0]=1.0, bp[1]=1.5 */
|
||||
v = C[1]/(ax+bp[k]);
|
||||
s = u*v;
|
||||
s_h = s;
|
||||
SET_LOW_WORD(s_h,0);
|
||||
/* t_h=ax+bp[k] High */
|
||||
t_h = C[0];
|
||||
SET_HIGH_WORD(t_h,((ix>>1)|0x20000000)+0x00080000+(k<<18));
|
||||
t_l = ax - (t_h-bp[k]);
|
||||
s_l = v*((u-s_h*t_h)-s_h*t_l);
|
||||
/* compute log(ax) */
|
||||
s2 = s*s;
|
||||
#ifdef DO_NOT_USE_THIS
|
||||
r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
|
||||
#else
|
||||
r1 = C[10]+s2*C[11]; s22=s2*s2;
|
||||
r2 = C[8]+s2*C[9]; s24=s22*s22;
|
||||
r3 = C[6]+s2*C[7]; s26=s24*s22;
|
||||
r = r3*s22 + r2*s24 + r1*s26;
|
||||
#endif
|
||||
r += s_l*(s_h+s);
|
||||
s2 = s_h*s_h;
|
||||
t_h = 3.0+s2+r;
|
||||
SET_LOW_WORD(t_h,0);
|
||||
t_l = r-((t_h-3.0)-s2);
|
||||
/* u+v = s*(1+...) */
|
||||
u = s_h*t_h;
|
||||
v = s_l*t_h+t_l*s;
|
||||
/* 2/(3log2)*(s+...) */
|
||||
p_h = u+v;
|
||||
SET_LOW_WORD(p_h,0);
|
||||
p_l = v-(p_h-u);
|
||||
z_h = C[22]*p_h; /* cp_h+cp_l = 2/(3*log2) */
|
||||
z_l = C[23]*p_h+p_l*C[21]+dp_l[k];
|
||||
/* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */
|
||||
t = (double)n;
|
||||
t1 = (((z_h+z_l)+dp_h[k])+t);
|
||||
SET_LOW_WORD(t1,0);
|
||||
t2 = z_l-(((t1-t)-dp_h[k])-z_h);
|
||||
}
|
||||
|
||||
s = C[1]; /* s (sign of result -ve**odd) = -1 else = 1 */
|
||||
if(((((u_int32_t)hx>>31)-1)|(yisint-1))==0)
|
||||
s = -C[1];/* (-ve)**(odd int) */
|
||||
|
||||
/* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
|
||||
y1 = y;
|
||||
SET_LOW_WORD(y1,0);
|
||||
p_l = (y-y1)*t1+y*t2;
|
||||
p_h = y1*t1;
|
||||
z = p_l+p_h;
|
||||
EXTRACT_WORDS(j,i,z);
|
||||
if (j>=0x40900000) { /* z >= 1024 */
|
||||
if(((j-0x40900000)|i)!=0) /* if z > 1024 */
|
||||
return s*C[4]*C[4]; /* overflow */
|
||||
else {
|
||||
if(p_l+C[20]>z-p_h) return s*C[4]*C[4]; /* overflow */
|
||||
}
|
||||
} else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */
|
||||
if(((j-0xc090cc00)|i)!=0) /* z < -1075 */
|
||||
return s*C[5]*C[5]; /* underflow */
|
||||
else {
|
||||
if(p_l<=z-p_h) return s*C[5]*C[5]; /* underflow */
|
||||
}
|
||||
}
|
||||
/*
|
||||
* compute 2**(p_h+p_l)
|
||||
*/
|
||||
i = j&0x7fffffff;
|
||||
k = (i>>20)-0x3ff;
|
||||
n = 0;
|
||||
if(i>0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */
|
||||
n = j+(0x00100000>>(k+1));
|
||||
k = ((n&0x7fffffff)>>20)-0x3ff; /* new k for n */
|
||||
t = C[0];
|
||||
SET_HIGH_WORD(t,n&~(0x000fffff>>k));
|
||||
n = ((n&0x000fffff)|0x00100000)>>(20-k);
|
||||
if(j<0) n = -n;
|
||||
p_h -= t;
|
||||
}
|
||||
t = p_l+p_h;
|
||||
SET_LOW_WORD(t,0);
|
||||
u = t*C[18];
|
||||
v = (p_l-(t-p_h))*C[17]+t*C[19];
|
||||
z = u+v;
|
||||
w = v-(z-u);
|
||||
t = z*z;
|
||||
#ifdef DO_NOT_USE_THIS
|
||||
t1 = z - t*(C[12]+t*(C[13]+t*(C[14]+t*(C[15]+t*C[16]))));
|
||||
#else
|
||||
r_1 = C[15]+t*C[16]; t12 = t*t;
|
||||
r_2 = C[13]+t*C[14]; t14 = t12*t12;
|
||||
r_3 = t*C[12];
|
||||
t1 = z - r_3 - t12*r_2 - t14*r_1;
|
||||
#endif
|
||||
r = (z*t1)/(t1-C[2])-(w+z*w);
|
||||
z = C[1]-(r-z);
|
||||
GET_HIGH_WORD(j,z);
|
||||
j += (n<<20);
|
||||
if((j>>20)<=0) z = scalbn(z,n); /* subnormal output */
|
||||
else SET_HIGH_WORD(z,j);
|
||||
return s*z;
|
||||
}
|
||||
@ -1,290 +0,0 @@
|
||||
#include <math.h>
|
||||
|
||||
static float coef32[31]; /* 32 pt dct coefs */
|
||||
|
||||
void fdct_init() /* gen coef for N=32 (31 coefs) */
|
||||
{
|
||||
int p, n, i, k;
|
||||
double t, pi;
|
||||
|
||||
pi = 4.0 * atan(1.0);
|
||||
n = 16;
|
||||
k = 0;
|
||||
for (i = 0; i < 5; i++, n = n / 2) {
|
||||
for (p = 0; p < n; p++, k++) {
|
||||
t = (pi / (4 * n)) * (2 * p + 1);
|
||||
coef32[k] = (float) (0.50 / cos(t));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void forward_bf(int m, int n, float x[], float f[], float coef[])
|
||||
{
|
||||
int i, j, n2;
|
||||
int p, q, p0, k;
|
||||
|
||||
p0 = 0;
|
||||
n2 = n >> 1;
|
||||
for (i = 0; i < m; i++, p0 += n) {
|
||||
k = 0;
|
||||
p = p0;
|
||||
q = p + n - 1;
|
||||
for (j = 0; j < n2; j++, p++, q--, k++) {
|
||||
f[p] = x[p] + x[q];
|
||||
f[n2 + p] = coef[k] * (x[p] - x[q]);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
static void back_bf(int m, int n, float x[], float f[])
|
||||
{
|
||||
int i, j, n2, n21;
|
||||
int p, q, p0;
|
||||
|
||||
p0 = 0;
|
||||
n2 = n >> 1;
|
||||
n21 = n2 - 1;
|
||||
for (i = 0; i < m; i++, p0 += n) {
|
||||
p = p0;
|
||||
q = p0;
|
||||
for (j = 0; j < n2; j++, p += 2, q++)
|
||||
f[p] = x[q];
|
||||
p = p0 + 1;
|
||||
for (j = 0; j < n21; j++, p += 2, q++)
|
||||
f[p] = x[q] + x[q + 1];
|
||||
f[p] = x[q];
|
||||
}
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
extern int m_enableEQ;
|
||||
extern float m_equalizer[32];
|
||||
|
||||
void fdct32(float x[], float c[])
|
||||
{
|
||||
float a[32]; /* ping pong buffers */
|
||||
float b[32];
|
||||
int p, q;
|
||||
|
||||
if (m_enableEQ) {
|
||||
for (p = 0; p < 32; p++) x[p] *= m_equalizer[p];
|
||||
}
|
||||
/* special first stage */
|
||||
for (p = 0, q = 31; p < 16; p++, q--) {
|
||||
a[p] = x[p] + x[q];
|
||||
a[16 + p] = coef32[p] * (x[p] - x[q]);
|
||||
}
|
||||
|
||||
forward_bf(2, 16, a, b, coef32 + 16);
|
||||
forward_bf(4, 8, b, a, coef32 + 16 + 8);
|
||||
forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
|
||||
forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(8, 4, a, b);
|
||||
back_bf(4, 8, b, a);
|
||||
back_bf(2, 16, a, b);
|
||||
back_bf(1, 32, b, c);
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
void fdct32_dual(float x[], float c[])
|
||||
{
|
||||
float a[32]; /* ping pong buffers */
|
||||
float b[32];
|
||||
int p, pp, qq;
|
||||
|
||||
if (m_enableEQ) {
|
||||
for (p = 0; p < 32; p++) x[p] *= m_equalizer[p];
|
||||
}
|
||||
|
||||
/* special first stage for dual chan (interleaved x) */
|
||||
pp = 0;
|
||||
qq = 2 * 31;
|
||||
for (p = 0; p < 16; p++, pp += 2, qq -= 2)
|
||||
{
|
||||
a[p] = x[pp] + x[qq];
|
||||
a[16 + p] = coef32[p] * (x[pp] - x[qq]);
|
||||
}
|
||||
forward_bf(2, 16, a, b, coef32 + 16);
|
||||
forward_bf(4, 8, b, a, coef32 + 16 + 8);
|
||||
forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
|
||||
forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(8, 4, a, b);
|
||||
back_bf(4, 8, b, a);
|
||||
back_bf(2, 16, a, b);
|
||||
back_bf(1, 32, b, c);
|
||||
}
|
||||
/*---------------convert dual to mono------------------------------*/
|
||||
void fdct32_dual_mono(float x[], float c[])
|
||||
{
|
||||
float a[32]; /* ping pong buffers */
|
||||
float b[32];
|
||||
float t1, t2;
|
||||
int p, pp, qq;
|
||||
|
||||
/* special first stage */
|
||||
pp = 0;
|
||||
qq = 2 * 31;
|
||||
for (p = 0; p < 16; p++, pp += 2, qq -= 2)
|
||||
{
|
||||
t1 = 0.5F * (x[pp] + x[pp + 1]);
|
||||
t2 = 0.5F * (x[qq] + x[qq + 1]);
|
||||
a[p] = t1 + t2;
|
||||
a[16 + p] = coef32[p] * (t1 - t2);
|
||||
}
|
||||
forward_bf(2, 16, a, b, coef32 + 16);
|
||||
forward_bf(4, 8, b, a, coef32 + 16 + 8);
|
||||
forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
|
||||
forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(8, 4, a, b);
|
||||
back_bf(4, 8, b, a);
|
||||
back_bf(2, 16, a, b);
|
||||
back_bf(1, 32, b, c);
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
/*---------------- 16 pt fdct -------------------------------*/
|
||||
void fdct16(float x[], float c[])
|
||||
{
|
||||
float a[16]; /* ping pong buffers */
|
||||
float b[16];
|
||||
int p, q;
|
||||
|
||||
/* special first stage (drop highest sb) */
|
||||
a[0] = x[0];
|
||||
a[8] = coef32[16] * x[0];
|
||||
for (p = 1, q = 14; p < 8; p++, q--)
|
||||
{
|
||||
a[p] = x[p] + x[q];
|
||||
a[8 + p] = coef32[16 + p] * (x[p] - x[q]);
|
||||
}
|
||||
forward_bf(2, 8, a, b, coef32 + 16 + 8);
|
||||
forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
|
||||
forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(4, 4, b, a);
|
||||
back_bf(2, 8, a, b);
|
||||
back_bf(1, 16, b, c);
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
/*---------------- 16 pt fdct dual chan---------------------*/
|
||||
void fdct16_dual(float x[], float c[])
|
||||
{
|
||||
float a[16]; /* ping pong buffers */
|
||||
float b[16];
|
||||
int p, pp, qq;
|
||||
|
||||
/* special first stage for interleaved input */
|
||||
a[0] = x[0];
|
||||
a[8] = coef32[16] * x[0];
|
||||
pp = 2;
|
||||
qq = 2 * 14;
|
||||
for (p = 1; p < 8; p++, pp += 2, qq -= 2)
|
||||
{
|
||||
a[p] = x[pp] + x[qq];
|
||||
a[8 + p] = coef32[16 + p] * (x[pp] - x[qq]);
|
||||
}
|
||||
forward_bf(2, 8, a, b, coef32 + 16 + 8);
|
||||
forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
|
||||
forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(4, 4, b, a);
|
||||
back_bf(2, 8, a, b);
|
||||
back_bf(1, 16, b, c);
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
/*---------------- 16 pt fdct dual to mono-------------------*/
|
||||
void fdct16_dual_mono(float x[], float c[])
|
||||
{
|
||||
float a[16]; /* ping pong buffers */
|
||||
float b[16];
|
||||
float t1, t2;
|
||||
int p, pp, qq;
|
||||
|
||||
/* special first stage */
|
||||
a[0] = 0.5F * (x[0] + x[1]);
|
||||
a[8] = coef32[16] * a[0];
|
||||
pp = 2;
|
||||
qq = 2 * 14;
|
||||
for (p = 1; p < 8; p++, pp += 2, qq -= 2)
|
||||
{
|
||||
t1 = 0.5F * (x[pp] + x[pp + 1]);
|
||||
t2 = 0.5F * (x[qq] + x[qq + 1]);
|
||||
a[p] = t1 + t2;
|
||||
a[8 + p] = coef32[16 + p] * (t1 - t2);
|
||||
}
|
||||
forward_bf(2, 8, a, b, coef32 + 16 + 8);
|
||||
forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
|
||||
forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(4, 4, b, a);
|
||||
back_bf(2, 8, a, b);
|
||||
back_bf(1, 16, b, c);
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
/*---------------- 8 pt fdct -------------------------------*/
|
||||
void fdct8(float x[], float c[])
|
||||
{
|
||||
float a[8]; /* ping pong buffers */
|
||||
float b[8];
|
||||
int p, q;
|
||||
|
||||
/* special first stage */
|
||||
|
||||
b[0] = x[0] + x[7];
|
||||
b[4] = coef32[16 + 8] * (x[0] - x[7]);
|
||||
for (p = 1, q = 6; p < 4; p++, q--)
|
||||
{
|
||||
b[p] = x[p] + x[q];
|
||||
b[4 + p] = coef32[16 + 8 + p] * (x[p] - x[q]);
|
||||
}
|
||||
|
||||
forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
|
||||
forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(2, 4, b, a);
|
||||
back_bf(1, 8, a, c);
|
||||
}
|
||||
|
||||
/*---------------- 8 pt fdct dual chan---------------------*/
|
||||
void fdct8_dual(float x[], float c[])
|
||||
{
|
||||
float a[8]; /* ping pong buffers */
|
||||
float b[8];
|
||||
int p, pp, qq;
|
||||
|
||||
/* special first stage for interleaved input */
|
||||
b[0] = x[0] + x[14];
|
||||
b[4] = coef32[16 + 8] * (x[0] - x[14]);
|
||||
pp = 2;
|
||||
qq = 2 * 6;
|
||||
for (p = 1; p < 4; p++, pp += 2, qq -= 2)
|
||||
{
|
||||
b[p] = x[pp] + x[qq];
|
||||
b[4 + p] = coef32[16 + 8 + p] * (x[pp] - x[qq]);
|
||||
}
|
||||
forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
|
||||
forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(2, 4, b, a);
|
||||
back_bf(1, 8, a, c);
|
||||
}
|
||||
|
||||
/*---------------- 8 pt fdct dual to mono---------------------*/
|
||||
void fdct8_dual_mono(float x[], float c[])
|
||||
{
|
||||
float a[8]; /* ping pong buffers */
|
||||
float b[8];
|
||||
float t1, t2;
|
||||
int p, pp, qq;
|
||||
|
||||
/* special first stage */
|
||||
t1 = 0.5F * (x[0] + x[1]);
|
||||
t2 = 0.5F * (x[14] + x[15]);
|
||||
b[0] = t1 + t2;
|
||||
b[4] = coef32[16 + 8] * (t1 - t2);
|
||||
pp = 2;
|
||||
qq = 2 * 6;
|
||||
for (p = 1; p < 4; p++, pp += 2, qq -= 2)
|
||||
{
|
||||
t1 = 0.5F * (x[pp] + x[pp + 1]);
|
||||
t2 = 0.5F * (x[qq] + x[qq + 1]);
|
||||
b[p] = t1 + t2;
|
||||
b[4 + p] = coef32[16 + 8 + p] * (t1 - t2);
|
||||
}
|
||||
forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
|
||||
forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
|
||||
back_bf(2, 4, b, a);
|
||||
back_bf(1, 8, a, c);
|
||||
}
|
||||
@ -1,222 +0,0 @@
|
||||
#include <math.h>
|
||||
|
||||
/*------ 18 point xform -------*/
|
||||
static float w[18];
|
||||
static float w2[9];
|
||||
static float coef[9][4];
|
||||
|
||||
static float v[6];
|
||||
static float v2[3];
|
||||
static float coef87;
|
||||
/*
|
||||
typedef struct
|
||||
{
|
||||
float *w;
|
||||
float *w2;
|
||||
void *coef;
|
||||
}
|
||||
IMDCT_INIT_BLOCK;
|
||||
|
||||
static IMDCT_INIT_BLOCK imdct_info_18 =
|
||||
{w, w2, coef};
|
||||
static IMDCT_INIT_BLOCK imdct_info_6 =
|
||||
{v, v2, &coef87};
|
||||
*/
|
||||
/*=============================================================*/
|
||||
void imdct_init()
|
||||
{
|
||||
int k, p, n;
|
||||
double t, pi;
|
||||
// IMDCT_INIT_BLOCK *addr;
|
||||
// float *w, *w2;
|
||||
// float *v, *v2, *coef87;
|
||||
|
||||
/*--- 18 point --*/
|
||||
// addr = imdct_init_addr_18();
|
||||
// w = addr->w;
|
||||
// w2 = addr->w2;
|
||||
// coef = addr->coef;
|
||||
/*----*/
|
||||
n = 18;
|
||||
pi = 4.0 * atan(1.0);
|
||||
t = pi / (4 * n);
|
||||
for (p = 0; p < n; p++)
|
||||
w[p] = (float) (2.0 * cos(t * (2 * p + 1)));
|
||||
for (p = 0; p < 9; p++)
|
||||
w2[p] = (float) (2.0 *cos(2 * t * (2 * p + 1)));
|
||||
|
||||
t = pi / (2 * n);
|
||||
for (k = 0; k < 9; k++)
|
||||
{
|
||||
for (p = 0; p < 4; p++)
|
||||
coef[k][p] = (float) (cos(t * (2 * k) * (2 * p + 1)));
|
||||
}
|
||||
|
||||
/*--- 6 point */
|
||||
// addr = imdct_init_addr_6();
|
||||
// v = addr->w;
|
||||
// v2 = addr->w2;
|
||||
// coef87 = addr->coef;
|
||||
/*----*/
|
||||
n = 6;
|
||||
pi = 4.0 * atan(1.0);
|
||||
t = pi / (4 * n);
|
||||
for (p = 0; p < n; p++)
|
||||
v[p] = (float) (2.0 *cos(t * (2 * p + 1)));
|
||||
|
||||
for (p = 0; p < 3; p++)
|
||||
v2[p] = (float) (2.0 *cos(2 * t * (2 * p + 1)));
|
||||
|
||||
t = pi / (2 * n);
|
||||
k = 1;
|
||||
p = 0;
|
||||
coef87 = (float) (cos(t * (2 * k) * (2 * p + 1)));
|
||||
/* adjust scaling to save a few mults */
|
||||
for (p = 0; p < 6; p++)
|
||||
v[p] = v[p] / 2.0f;
|
||||
coef87 = (float) (2.0 * coef87);
|
||||
}
|
||||
/*--------------------------------------------------------------------*/
|
||||
void imdct18(float f[18]) /* 18 point */
|
||||
{
|
||||
int p;
|
||||
float a[9], b[9];
|
||||
float ap, bp, a8p, b8p;
|
||||
float g1, g2;
|
||||
|
||||
|
||||
for (p = 0; p < 4; p++)
|
||||
{
|
||||
g1 = w[p] * f[p];
|
||||
g2 = w[17 - p] * f[17 - p];
|
||||
ap = g1 + g2; // a[p]
|
||||
|
||||
bp = w2[p] * (g1 - g2); // b[p]
|
||||
|
||||
g1 = w[8 - p] * f[8 - p];
|
||||
g2 = w[9 + p] * f[9 + p];
|
||||
a8p = g1 + g2; // a[8-p]
|
||||
|
||||
b8p = w2[8 - p] * (g1 - g2); // b[8-p]
|
||||
|
||||
a[p] = ap + a8p;
|
||||
a[5 + p] = ap - a8p;
|
||||
b[p] = bp + b8p;
|
||||
b[5 + p] = bp - b8p;
|
||||
}
|
||||
g1 = w[p] * f[p];
|
||||
g2 = w[17 - p] * f[17 - p];
|
||||
a[p] = g1 + g2;
|
||||
b[p] = w2[p] * (g1 - g2);
|
||||
|
||||
|
||||
f[0] = 0.5f * (a[0] + a[1] + a[2] + a[3] + a[4]);
|
||||
f[1] = 0.5f * (b[0] + b[1] + b[2] + b[3] + b[4]);
|
||||
|
||||
f[2] = coef[1][0] * a[5] + coef[1][1] * a[6] + coef[1][2] * a[7]
|
||||
+ coef[1][3] * a[8];
|
||||
f[3] = coef[1][0] * b[5] + coef[1][1] * b[6] + coef[1][2] * b[7]
|
||||
+ coef[1][3] * b[8] - f[1];
|
||||
f[1] = f[1] - f[0];
|
||||
f[2] = f[2] - f[1];
|
||||
|
||||
f[4] = coef[2][0] * a[0] + coef[2][1] * a[1] + coef[2][2] * a[2]
|
||||
+ coef[2][3] * a[3] - a[4];
|
||||
f[5] = coef[2][0] * b[0] + coef[2][1] * b[1] + coef[2][2] * b[2]
|
||||
+ coef[2][3] * b[3] - b[4] - f[3];
|
||||
f[3] = f[3] - f[2];
|
||||
f[4] = f[4] - f[3];
|
||||
|
||||
f[6] = coef[3][0] * (a[5] - a[7] - a[8]);
|
||||
f[7] = coef[3][0] * (b[5] - b[7] - b[8]) - f[5];
|
||||
f[5] = f[5] - f[4];
|
||||
f[6] = f[6] - f[5];
|
||||
|
||||
f[8] = coef[4][0] * a[0] + coef[4][1] * a[1] + coef[4][2] * a[2]
|
||||
+ coef[4][3] * a[3] + a[4];
|
||||
f[9] = coef[4][0] * b[0] + coef[4][1] * b[1] + coef[4][2] * b[2]
|
||||
+ coef[4][3] * b[3] + b[4] - f[7];
|
||||
f[7] = f[7] - f[6];
|
||||
f[8] = f[8] - f[7];
|
||||
|
||||
f[10] = coef[5][0] * a[5] + coef[5][1] * a[6] + coef[5][2] * a[7]
|
||||
+ coef[5][3] * a[8];
|
||||
f[11] = coef[5][0] * b[5] + coef[5][1] * b[6] + coef[5][2] * b[7]
|
||||
+ coef[5][3] * b[8] - f[9];
|
||||
f[9] = f[9] - f[8];
|
||||
f[10] = f[10] - f[9];
|
||||
|
||||
f[12] = 0.5f * (a[0] + a[2] + a[3]) - a[1] - a[4];
|
||||
f[13] = 0.5f * (b[0] + b[2] + b[3]) - b[1] - b[4] - f[11];
|
||||
f[11] = f[11] - f[10];
|
||||
f[12] = f[12] - f[11];
|
||||
|
||||
f[14] = coef[7][0] * a[5] + coef[7][1] * a[6] + coef[7][2] * a[7]
|
||||
+ coef[7][3] * a[8];
|
||||
f[15] = coef[7][0] * b[5] + coef[7][1] * b[6] + coef[7][2] * b[7]
|
||||
+ coef[7][3] * b[8] - f[13];
|
||||
f[13] = f[13] - f[12];
|
||||
f[14] = f[14] - f[13];
|
||||
|
||||
f[16] = coef[8][0] * a[0] + coef[8][1] * a[1] + coef[8][2] * a[2]
|
||||
+ coef[8][3] * a[3] + a[4];
|
||||
f[17] = coef[8][0] * b[0] + coef[8][1] * b[1] + coef[8][2] * b[2]
|
||||
+ coef[8][3] * b[3] + b[4] - f[15];
|
||||
f[15] = f[15] - f[14];
|
||||
f[16] = f[16] - f[15];
|
||||
f[17] = f[17] - f[16];
|
||||
}
|
||||
/*--------------------------------------------------------------------*/
|
||||
/* does 3, 6 pt dct. changes order from f[i][window] c[window][i] */
|
||||
void imdct6_3(float f[]) /* 6 point */
|
||||
{
|
||||
int w;
|
||||
float buf[18];
|
||||
float *a, *c; // b[i] = a[3+i]
|
||||
|
||||
float g1, g2;
|
||||
float a02, b02;
|
||||
|
||||
c = f;
|
||||
a = buf;
|
||||
for (w = 0; w < 3; w++)
|
||||
{
|
||||
g1 = v[0] * f[3 * 0];
|
||||
g2 = v[5] * f[3 * 5];
|
||||
a[0] = g1 + g2;
|
||||
a[3 + 0] = v2[0] * (g1 - g2);
|
||||
|
||||
g1 = v[1] * f[3 * 1];
|
||||
g2 = v[4] * f[3 * 4];
|
||||
a[1] = g1 + g2;
|
||||
a[3 + 1] = v2[1] * (g1 - g2);
|
||||
|
||||
g1 = v[2] * f[3 * 2];
|
||||
g2 = v[3] * f[3 * 3];
|
||||
a[2] = g1 + g2;
|
||||
a[3 + 2] = v2[2] * (g1 - g2);
|
||||
|
||||
a += 6;
|
||||
f++;
|
||||
}
|
||||
|
||||
a = buf;
|
||||
for (w = 0; w < 3; w++)
|
||||
{
|
||||
a02 = (a[0] + a[2]);
|
||||
b02 = (a[3 + 0] + a[3 + 2]);
|
||||
c[0] = a02 + a[1];
|
||||
c[1] = b02 + a[3 + 1];
|
||||
c[2] = coef87 * (a[0] - a[2]);
|
||||
c[3] = coef87 * (a[3 + 0] - a[3 + 2]) - c[1];
|
||||
c[1] = c[1] - c[0];
|
||||
c[2] = c[2] - c[1];
|
||||
c[4] = a02 - a[1] - a[1];
|
||||
c[5] = b02 - a[3 + 1] - a[3 + 1] - c[3];
|
||||
c[3] = c[3] - c[2];
|
||||
c[4] = c[4] - c[3];
|
||||
c[5] = c[5] - c[4];
|
||||
a += 6;
|
||||
c += 6;
|
||||
}
|
||||
}
|
||||
@ -1,202 +0,0 @@
|
||||
#include "bstream.h"
|
||||
#include "mp3dec.h"
|
||||
|
||||
extern MPEG_DECODE_OPTION m_option;
|
||||
|
||||
extern float m_sample[2304];
|
||||
extern int m_nsb_limit;
|
||||
extern SBT_PROC m_sbt_proc;
|
||||
|
||||
extern int m_max_sb;
|
||||
extern int m_stereo_sb;
|
||||
extern int m_bat[4][16];
|
||||
extern int m_ballo[64];
|
||||
extern unsigned int m_samp_dispatch[66];
|
||||
extern float m_c_value[64];
|
||||
extern unsigned int m_sf_dispatch[66];
|
||||
extern float m_sf_table[64];
|
||||
extern float m_cs_factor[3][64];
|
||||
|
||||
float m_look_c_valueL1[18];
|
||||
float *m_cs_factorL1 = m_cs_factor[0];
|
||||
int m_nbatL1;
|
||||
|
||||
int m_bit_skip;
|
||||
|
||||
static const int look_joint[16] =
|
||||
{ /* lookup stereo sb's by mode+ext */
|
||||
64, 64, 64, 64, /* stereo */
|
||||
2 * 4, 2 * 8, 2 * 12, 2 * 16, /* joint */
|
||||
64, 64, 64, 64, /* dual */
|
||||
32, 32, 32, 32, /* mono */
|
||||
};
|
||||
|
||||
static const int bat_bit_masterL1[] =
|
||||
{
|
||||
0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
|
||||
};
|
||||
|
||||
void unpack_baL1();
|
||||
void unpack_sfL1();
|
||||
void unpack_sampL1();
|
||||
|
||||
void L1decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
|
||||
{
|
||||
int crc_size;
|
||||
|
||||
crc_size = (h->error_prot) ? 2 : 0;
|
||||
bitget_init(mpeg + 4 + crc_size);
|
||||
|
||||
m_stereo_sb = look_joint[(h->mode << 2) + h->mode_ext];
|
||||
unpack_baL1(); /* unpack bit allocation */
|
||||
unpack_sfL1(); /* unpack scale factor */
|
||||
unpack_sampL1(); /* unpack samples */
|
||||
|
||||
m_sbt_proc(m_sample, pcm, 12);
|
||||
}
|
||||
|
||||
void unpack_baL1()
|
||||
{
|
||||
int j;
|
||||
int nstereo;
|
||||
|
||||
m_bit_skip = 0;
|
||||
nstereo = m_stereo_sb;
|
||||
|
||||
for (j = 0; j < m_nbatL1; j++)
|
||||
{
|
||||
bitget_check(4);
|
||||
m_ballo[j] = m_samp_dispatch[j] = mac_bitget(4);
|
||||
if (j >= m_nsb_limit)
|
||||
m_bit_skip += bat_bit_masterL1[m_samp_dispatch[j]];
|
||||
m_c_value[j] = m_look_c_valueL1[m_samp_dispatch[j]];
|
||||
if (--nstereo < 0)
|
||||
{
|
||||
m_ballo[j + 1] = m_ballo[j];
|
||||
// flag as joint
|
||||
m_samp_dispatch[j] += 15;
|
||||
// flag for sf
|
||||
m_samp_dispatch[j + 1] = m_samp_dispatch[j];
|
||||
m_c_value[j + 1] = m_c_value[j];
|
||||
j++;
|
||||
}
|
||||
}
|
||||
// terminate with bit skip and end
|
||||
m_samp_dispatch[m_nsb_limit] = 31;
|
||||
m_samp_dispatch[j] = 30;
|
||||
}
|
||||
|
||||
// unpack scale factor
|
||||
// combine dequant and scale factors
|
||||
void unpack_sfL1()
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < m_nbatL1; i++)
|
||||
{
|
||||
if (m_ballo[i])
|
||||
{
|
||||
bitget_check(6);
|
||||
m_cs_factorL1[i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// unpack samples
|
||||
#define UNPACKL1_N(n) \
|
||||
s[k] = m_cs_factorL1[k]*(bitget(n)-((1 << n-1) -1)); \
|
||||
goto dispatch;
|
||||
#define UNPACKL1J_N(n) \
|
||||
tmp = (bitget(n)-((1 << n-1) -1)); \
|
||||
s[k] = m_cs_factorL1[k]*tmp; \
|
||||
s[k+1] = m_cs_factorL1[k+1]*tmp; \
|
||||
k++; \
|
||||
goto dispatch;
|
||||
|
||||
void unpack_sampL1()
|
||||
{
|
||||
int j, k;
|
||||
float *s;
|
||||
long tmp;
|
||||
|
||||
s = m_sample;
|
||||
for (j = 0; j < 12; j++)
|
||||
{
|
||||
k = -1;
|
||||
dispatch:
|
||||
switch (m_samp_dispatch[++k])
|
||||
{
|
||||
case 0:
|
||||
s[k] = 0.0F;
|
||||
goto dispatch;
|
||||
case 1:
|
||||
UNPACKL1_N(2) /* 3 levels */
|
||||
case 2:
|
||||
UNPACKL1_N(3) /* 7 levels */
|
||||
case 3:
|
||||
UNPACKL1_N(4) /* 15 levels */
|
||||
case 4:
|
||||
UNPACKL1_N(5) /* 31 levels */
|
||||
case 5:
|
||||
UNPACKL1_N(6) /* 63 levels */
|
||||
case 6:
|
||||
UNPACKL1_N(7) /* 127 levels */
|
||||
case 7:
|
||||
UNPACKL1_N(8) /* 255 levels */
|
||||
case 8:
|
||||
UNPACKL1_N(9) /* 511 levels */
|
||||
case 9:
|
||||
UNPACKL1_N(10) /* 1023 levels */
|
||||
case 10:
|
||||
UNPACKL1_N(11) /* 2047 levels */
|
||||
case 11:
|
||||
UNPACKL1_N(12) /* 4095 levels */
|
||||
case 12:
|
||||
UNPACKL1_N(13) /* 8191 levels */
|
||||
case 13:
|
||||
UNPACKL1_N(14) /* 16383 levels */
|
||||
case 14:
|
||||
UNPACKL1_N(15) /* 32767 levels */
|
||||
/* -- joint ---- */
|
||||
case 15 + 0:
|
||||
s[k + 1] = s[k] = 0.0F;
|
||||
k++; /* skip right chan dispatch */
|
||||
goto dispatch;
|
||||
/* -- joint ---- */
|
||||
case 15 + 1:
|
||||
UNPACKL1J_N(2) /* 3 levels */
|
||||
case 15 + 2:
|
||||
UNPACKL1J_N(3) /* 7 levels */
|
||||
case 15 + 3:
|
||||
UNPACKL1J_N(4) /* 15 levels */
|
||||
case 15 + 4:
|
||||
UNPACKL1J_N(5) /* 31 levels */
|
||||
case 15 + 5:
|
||||
UNPACKL1J_N(6) /* 63 levels */
|
||||
case 15 + 6:
|
||||
UNPACKL1J_N(7) /* 127 levels */
|
||||
case 15 + 7:
|
||||
UNPACKL1J_N(8) /* 255 levels */
|
||||
case 15 + 8:
|
||||
UNPACKL1J_N(9) /* 511 levels */
|
||||
case 15 + 9:
|
||||
UNPACKL1J_N(10) /* 1023 levels */
|
||||
case 15 + 10:
|
||||
UNPACKL1J_N(11) /* 2047 levels */
|
||||
case 15 + 11:
|
||||
UNPACKL1J_N(12) /* 4095 levels */
|
||||
case 15 + 12:
|
||||
UNPACKL1J_N(13) /* 8191 levels */
|
||||
case 15 + 13:
|
||||
UNPACKL1J_N(14) /* 16383 levels */
|
||||
case 15 + 14:
|
||||
UNPACKL1J_N(15) /* 32767 levels */
|
||||
|
||||
/* -- end of dispatch -- */
|
||||
case 31:
|
||||
bitget_skip(m_bit_skip);
|
||||
case 30:
|
||||
s += 64;
|
||||
} /* end switch */
|
||||
} /* end j loop */
|
||||
}
|
||||
@ -1,87 +0,0 @@
|
||||
#include "bstream.h"
|
||||
#include "mp3dec.h"
|
||||
#include <math.h>
|
||||
|
||||
extern MPEG_DECODE_OPTION m_option;
|
||||
extern int m_frequency;
|
||||
|
||||
extern float m_sample[2304];
|
||||
extern int m_nsb_limit;
|
||||
extern int m_max_sb;
|
||||
extern int m_stereo_sb;
|
||||
extern SBT_PROC m_sbt_proc;
|
||||
|
||||
extern float m_look_c_valueL1[18];
|
||||
extern int m_nbatL1;
|
||||
|
||||
//extern "sbt.c"
|
||||
void sbt_mono(float *sample, signed short *pcm, int ch);
|
||||
void sbt_dual(float *sample, signed short *pcm, int ch);
|
||||
void sbt16_mono(float *sample, signed short *pcm, int ch);
|
||||
void sbt16_dual(float *sample, signed short *pcm, int ch);
|
||||
void sbt8_mono(float *sample, signed short *pcm, int ch);
|
||||
void sbt8_dual(float *sample, signed short *pcm, int ch);
|
||||
void sbtB_mono(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB_dual(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB16_mono(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB16_dual(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB8_mono(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB8_dual(float *sample, unsigned char *pcm, int ch);
|
||||
|
||||
static const SBT_PROC sbt_table[2][3][2] =
|
||||
{
|
||||
sbt_mono,
|
||||
sbt_dual,
|
||||
sbt16_mono,
|
||||
sbt16_dual,
|
||||
sbt8_mono,
|
||||
sbt8_dual,
|
||||
sbtB_mono,
|
||||
sbtB_dual,
|
||||
sbtB16_mono,
|
||||
sbtB16_dual,
|
||||
sbtB8_mono,
|
||||
sbtB8_dual,
|
||||
};
|
||||
|
||||
void L1table_init()
|
||||
{
|
||||
int i, stepL1;
|
||||
|
||||
for (stepL1 = 4, i = 1; i < 16; i++, stepL1 <<= 1) {
|
||||
m_look_c_valueL1[i] = (float) (2.0 / (stepL1 - 1));
|
||||
}
|
||||
}
|
||||
|
||||
int L1decode_start(MPEG_HEADER* h)
|
||||
{
|
||||
int i, k, bit_code, limit;
|
||||
|
||||
/*- caller limit -*/
|
||||
m_nbatL1 = 32;
|
||||
m_max_sb = m_nbatL1;
|
||||
m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
|
||||
/*---- limit = 0.94*(32>>reduction_code); ----*/
|
||||
limit = (32 >> m_option.reduction);
|
||||
if (limit > 8)
|
||||
limit--;
|
||||
if (m_nsb_limit > limit)
|
||||
m_nsb_limit = limit;
|
||||
if (m_nsb_limit > m_max_sb)
|
||||
m_nsb_limit = m_max_sb;
|
||||
|
||||
if (h->mode != 3) { /* adjust for 2 channel modes */
|
||||
m_nbatL1 *= 2;
|
||||
m_max_sb *= 2;
|
||||
m_nsb_limit *= 2;
|
||||
}
|
||||
/* set sbt function */
|
||||
bit_code = (m_option.convert & 8) ? 1 : 0;
|
||||
k = (h->mode == 3) ? 0 : (1 + m_option.convert);
|
||||
m_sbt_proc = sbt_table[bit_code][m_option.reduction][k];//[2][3][2]
|
||||
|
||||
for (i = 0; i < 768; i++)
|
||||
m_sample[i] = 0.0F;
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -1,306 +0,0 @@
|
||||
#include "bstream.h"
|
||||
#include "mp3dec.h"
|
||||
|
||||
extern float m_sample[2304];
|
||||
extern int m_nsb_limit;
|
||||
int m_stereo_sb;
|
||||
int m_max_sb;
|
||||
|
||||
SBT_PROC m_sbt_proc;
|
||||
float m_sf_table[64];
|
||||
float m_look_c_valueL2[18];
|
||||
char m_group3_table[32][3];
|
||||
char m_group5_table[128][3];
|
||||
short m_group9_table[1024][3];
|
||||
int m_nbat[4];// = {3, 8, 12, 7};
|
||||
int m_bat[4][16];
|
||||
|
||||
int m_ballo[64];
|
||||
uint m_samp_dispatch[66];
|
||||
float m_c_value[64];
|
||||
uint m_sf_dispatch[66];
|
||||
float m_cs_factor[3][64];
|
||||
|
||||
int m_bit_skip;
|
||||
|
||||
static const int look_joint[16] =
|
||||
{ /* lookup stereo sb's by mode+ext */
|
||||
64, 64, 64, 64, /* stereo */
|
||||
2 * 4, 2 * 8, 2 * 12, 2 * 16, /* joint */
|
||||
64, 64, 64, 64, /* dual */
|
||||
32, 32, 32, 32, /* mono */
|
||||
};
|
||||
|
||||
static const int bat_bit_masterL2[] =
|
||||
{
|
||||
0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48
|
||||
};
|
||||
|
||||
void unpack_ba();
|
||||
void unpack_sfs();
|
||||
void unpack_sf();
|
||||
void unpack_samp();
|
||||
|
||||
void L2decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
|
||||
{
|
||||
int crc_size;
|
||||
|
||||
crc_size = (h->error_prot) ? 2 : 0;
|
||||
bitget_init(mpeg + 4 + crc_size);
|
||||
|
||||
m_stereo_sb = look_joint[(h->mode << 2) + h->mode_ext];
|
||||
unpack_ba(); // unpack bit allocation
|
||||
unpack_sfs(); // unpack scale factor selectors
|
||||
unpack_sf(); // unpack scale factor
|
||||
unpack_samp(); // unpack samples
|
||||
|
||||
m_sbt_proc(m_sample, pcm, 36);
|
||||
}
|
||||
|
||||
void unpack_ba()
|
||||
{
|
||||
int i, j, k;
|
||||
int nstereo;
|
||||
int nbit[4] = {4, 4, 3, 2};
|
||||
|
||||
m_bit_skip = 0;
|
||||
nstereo = m_stereo_sb;
|
||||
k = 0;
|
||||
for (i = 0; i < 4; i++) {
|
||||
for (j = 0; j < m_nbat[i]; j++, k++) {
|
||||
bitget_check(4);
|
||||
m_ballo[k] = m_samp_dispatch[k] = m_bat[i][mac_bitget(nbit[i])];
|
||||
if (k >= m_nsb_limit)
|
||||
m_bit_skip += bat_bit_masterL2[m_samp_dispatch[k]];
|
||||
m_c_value[k] = m_look_c_valueL2[m_samp_dispatch[k]];
|
||||
if (--nstereo < 0) {
|
||||
m_ballo[k + 1] = m_ballo[k];
|
||||
m_samp_dispatch[k] += 18; /* flag as joint */
|
||||
m_samp_dispatch[k + 1] = m_samp_dispatch[k]; /* flag for sf */
|
||||
m_c_value[k + 1] = m_c_value[k];
|
||||
k++;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
}
|
||||
m_samp_dispatch[m_nsb_limit] = 37; /* terminate the dispatcher with skip */
|
||||
m_samp_dispatch[k] = 36; /* terminate the dispatcher */
|
||||
}
|
||||
|
||||
void unpack_sfs() /* unpack scale factor selectors */
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < m_max_sb; i++) {
|
||||
bitget_check(2);
|
||||
if (m_ballo[i])
|
||||
m_sf_dispatch[i] = mac_bitget(2);
|
||||
else
|
||||
m_sf_dispatch[i] = 4; /* no allo */
|
||||
}
|
||||
m_sf_dispatch[i] = 5; /* terminate dispatcher */
|
||||
}
|
||||
|
||||
void unpack_sf() /* unpack scale factor */
|
||||
{ /* combine dequant and scale factors */
|
||||
int i;
|
||||
|
||||
i = -1;
|
||||
dispatch:switch (m_sf_dispatch[++i])
|
||||
{
|
||||
case 0: /* 3 factors 012 */
|
||||
bitget_check(18);
|
||||
m_cs_factor[0][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
m_cs_factor[1][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
m_cs_factor[2][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
goto dispatch;
|
||||
case 1: /* 2 factors 002 */
|
||||
bitget_check(12);
|
||||
m_cs_factor[1][i] = m_cs_factor[0][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
m_cs_factor[2][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
goto dispatch;
|
||||
case 2: /* 1 factor 000 */
|
||||
bitget_check(6);
|
||||
m_cs_factor[2][i] = m_cs_factor[1][i] = m_cs_factor[0][i] =
|
||||
m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
goto dispatch;
|
||||
case 3: /* 2 factors 022 */
|
||||
bitget_check(12);
|
||||
m_cs_factor[0][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
m_cs_factor[2][i] = m_cs_factor[1][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
|
||||
goto dispatch;
|
||||
case 4: /* no allo */
|
||||
/*-- m_cs_factor[2][i] = m_cs_factor[1][i] = m_cs_factor[0][i] = 0.0; --*/
|
||||
goto dispatch;
|
||||
case 5: /* all done */
|
||||
;
|
||||
} /* end switch */
|
||||
}
|
||||
/*-------------------------------------------------------------------------*/
|
||||
#define UNPACK_N(n) s[k] = m_cs_factor[i][k]*(bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+64] = m_cs_factor[i][k]*(bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+128] = m_cs_factor[i][k]*(bitget(n)-((1 << n-1) -1)); \
|
||||
goto dispatch;
|
||||
#define UNPACK_N2(n) bitget_check(3*n); \
|
||||
s[k] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+64] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+128] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
|
||||
goto dispatch;
|
||||
#define UNPACK_N3(n) bitget_check(2*n); \
|
||||
s[k] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+64] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
|
||||
bitget_check(n); \
|
||||
s[k+128] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
|
||||
goto dispatch;
|
||||
#define UNPACKJ_N(n) tmp = (bitget(n)-((1 << n-1) -1)); \
|
||||
s[k] = m_cs_factor[i][k]*tmp; \
|
||||
s[k+1] = m_cs_factor[i][k+1]*tmp; \
|
||||
tmp = (bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+64] = m_cs_factor[i][k]*tmp; \
|
||||
s[k+64+1] = m_cs_factor[i][k+1]*tmp; \
|
||||
tmp = (bitget(n)-((1 << n-1) -1)); \
|
||||
s[k+128] = m_cs_factor[i][k]*tmp; \
|
||||
s[k+128+1] = m_cs_factor[i][k+1]*tmp; \
|
||||
k++; /* skip right chan dispatch */ \
|
||||
goto dispatch;
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
void unpack_samp() /* unpack samples */
|
||||
{
|
||||
int i, j, k;
|
||||
float *s;
|
||||
int n;
|
||||
long tmp;
|
||||
|
||||
s = m_sample;
|
||||
for (i = 0; i < 3; i++)
|
||||
{ /* 3 groups of scale factors */
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
k = -1;
|
||||
dispatch:switch (m_samp_dispatch[++k])
|
||||
{
|
||||
case 0:
|
||||
s[k + 128] = s[k + 64] = s[k] = 0.0F;
|
||||
goto dispatch;
|
||||
case 1: /* 3 levels grouped 5 bits */
|
||||
bitget_check(5);
|
||||
n = mac_bitget(5);
|
||||
s[k] = m_cs_factor[i][k] * m_group3_table[n][0];
|
||||
s[k + 64] = m_cs_factor[i][k] * m_group3_table[n][1];
|
||||
s[k + 128] = m_cs_factor[i][k] * m_group3_table[n][2];
|
||||
goto dispatch;
|
||||
case 2: /* 5 levels grouped 7 bits */
|
||||
bitget_check(7);
|
||||
n = mac_bitget(7);
|
||||
s[k] = m_cs_factor[i][k] * m_group5_table[n][0];
|
||||
s[k + 64] = m_cs_factor[i][k] * m_group5_table[n][1];
|
||||
s[k + 128] = m_cs_factor[i][k] * m_group5_table[n][2];
|
||||
goto dispatch;
|
||||
case 3:
|
||||
UNPACK_N2(3) /* 7 levels */
|
||||
case 4: /* 9 levels grouped 10 bits */
|
||||
bitget_check(10);
|
||||
n = mac_bitget(10);
|
||||
s[k] = m_cs_factor[i][k] * m_group9_table[n][0];
|
||||
s[k + 64] = m_cs_factor[i][k] * m_group9_table[n][1];
|
||||
s[k + 128] = m_cs_factor[i][k] * m_group9_table[n][2];
|
||||
goto dispatch;
|
||||
case 5:
|
||||
UNPACK_N2(4) /* 15 levels */
|
||||
case 6:
|
||||
UNPACK_N2(5) /* 31 levels */
|
||||
case 7:
|
||||
UNPACK_N2(6) /* 63 levels */
|
||||
case 8:
|
||||
UNPACK_N2(7) /* 127 levels */
|
||||
case 9:
|
||||
UNPACK_N2(8) /* 255 levels */
|
||||
case 10:
|
||||
UNPACK_N3(9) /* 511 levels */
|
||||
case 11:
|
||||
UNPACK_N3(10) /* 1023 levels */
|
||||
case 12:
|
||||
UNPACK_N3(11) /* 2047 levels */
|
||||
case 13:
|
||||
UNPACK_N3(12) /* 4095 levels */
|
||||
case 14:
|
||||
UNPACK_N(13) /* 8191 levels */
|
||||
case 15:
|
||||
UNPACK_N(14) /* 16383 levels */
|
||||
case 16:
|
||||
UNPACK_N(15) /* 32767 levels */
|
||||
case 17:
|
||||
UNPACK_N(16) /* 65535 levels */
|
||||
/* -- joint ---- */
|
||||
case 18 + 0:
|
||||
s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0.0F;
|
||||
k++; /* skip right chan dispatch */
|
||||
goto dispatch;
|
||||
case 18 + 1: /* 3 levels grouped 5 bits */
|
||||
n = bitget(5);
|
||||
s[k] = m_cs_factor[i][k] * m_group3_table[n][0];
|
||||
s[k + 1] = m_cs_factor[i][k + 1] * m_group3_table[n][0];
|
||||
s[k + 64] = m_cs_factor[i][k] * m_group3_table[n][1];
|
||||
s[k + 64 + 1] = m_cs_factor[i][k + 1] * m_group3_table[n][1];
|
||||
s[k + 128] = m_cs_factor[i][k] * m_group3_table[n][2];
|
||||
s[k + 128 + 1] = m_cs_factor[i][k + 1] * m_group3_table[n][2];
|
||||
k++; /* skip right chan dispatch */
|
||||
goto dispatch;
|
||||
case 18 + 2: /* 5 levels grouped 7 bits */
|
||||
n = bitget(7);
|
||||
s[k] = m_cs_factor[i][k] * m_group5_table[n][0];
|
||||
s[k + 1] = m_cs_factor[i][k + 1] * m_group5_table[n][0];
|
||||
s[k + 64] = m_cs_factor[i][k] * m_group5_table[n][1];
|
||||
s[k + 64 + 1] = m_cs_factor[i][k + 1] * m_group5_table[n][1];
|
||||
s[k + 128] = m_cs_factor[i][k] * m_group5_table[n][2];
|
||||
s[k + 128 + 1] = m_cs_factor[i][k + 1] * m_group5_table[n][2];
|
||||
k++; /* skip right chan dispatch */
|
||||
goto dispatch;
|
||||
case 18 + 3:
|
||||
UNPACKJ_N(3) /* 7 levels */
|
||||
case 18 + 4: /* 9 levels grouped 10 bits */
|
||||
n = bitget(10);
|
||||
s[k] = m_cs_factor[i][k] * m_group9_table[n][0];
|
||||
s[k + 1] = m_cs_factor[i][k + 1] * m_group9_table[n][0];
|
||||
s[k + 64] = m_cs_factor[i][k] * m_group9_table[n][1];
|
||||
s[k + 64 + 1] = m_cs_factor[i][k + 1] * m_group9_table[n][1];
|
||||
s[k + 128] = m_cs_factor[i][k] * m_group9_table[n][2];
|
||||
s[k + 128 + 1] = m_cs_factor[i][k + 1] * m_group9_table[n][2];
|
||||
k++; /* skip right chan dispatch */
|
||||
goto dispatch;
|
||||
case 18 + 5:
|
||||
UNPACKJ_N(4) /* 15 levels */
|
||||
case 18 + 6:
|
||||
UNPACKJ_N(5) /* 31 levels */
|
||||
case 18 + 7:
|
||||
UNPACKJ_N(6) /* 63 levels */
|
||||
case 18 + 8:
|
||||
UNPACKJ_N(7) /* 127 levels */
|
||||
case 18 + 9:
|
||||
UNPACKJ_N(8) /* 255 levels */
|
||||
case 18 + 10:
|
||||
UNPACKJ_N(9) /* 511 levels */
|
||||
case 18 + 11:
|
||||
UNPACKJ_N(10) /* 1023 levels */
|
||||
case 18 + 12:
|
||||
UNPACKJ_N(11) /* 2047 levels */
|
||||
case 18 + 13:
|
||||
UNPACKJ_N(12) /* 4095 levels */
|
||||
case 18 + 14:
|
||||
UNPACKJ_N(13) /* 8191 levels */
|
||||
case 18 + 15:
|
||||
UNPACKJ_N(14) /* 16383 levels */
|
||||
case 18 + 16:
|
||||
UNPACKJ_N(15) /* 32767 levels */
|
||||
case 18 + 17:
|
||||
UNPACKJ_N(16) /* 65535 levels */
|
||||
/* -- end of dispatch -- */
|
||||
case 37:
|
||||
bitget_skip(m_bit_skip);
|
||||
case 36:
|
||||
s += 3 * 64;
|
||||
} /* end switch */
|
||||
} /* end j loop */
|
||||
} /* end i loop */
|
||||
}
|
||||
@ -1,205 +0,0 @@
|
||||
#include "bstream.h"
|
||||
#include "mp3dec.h"
|
||||
#include <math.h>
|
||||
|
||||
extern MPEG_DECODE_OPTION m_option;
|
||||
extern int m_frequency;
|
||||
|
||||
extern float m_sample[2304];
|
||||
extern int m_nsb_limit;
|
||||
extern int m_max_sb;
|
||||
extern SBT_PROC m_sbt_proc;
|
||||
|
||||
extern float m_sf_table[64];
|
||||
extern float m_look_c_valueL2[18];
|
||||
extern char m_group3_table[32][3];
|
||||
extern char m_group5_table[128][3];
|
||||
extern short m_group9_table[1024][3];
|
||||
extern int m_nbat[4];// = {3, 8, 12, 7};
|
||||
extern int m_bat[4][16];
|
||||
|
||||
/* ABCD_INDEX = lookqt[mode][sr_index][br_index] */
|
||||
/* -1 = invalid */
|
||||
static const char lookqt[4][3][16] =
|
||||
{
|
||||
1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 44ks stereo */
|
||||
0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, /* 48ks */
|
||||
1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 32ks */
|
||||
1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 44ks joint stereo */
|
||||
0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, /* 48ks */
|
||||
1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 32ks */
|
||||
1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 44ks dual chan */
|
||||
0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, /* 48ks */
|
||||
1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 32ks */
|
||||
// mono extended beyond legal br index
|
||||
// 1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1, /* 44ks single chan */
|
||||
// 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1, /* 48ks */
|
||||
// 1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1, /* 32ks */
|
||||
// legal mono
|
||||
1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* 44ks single chan */
|
||||
0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, /* 48ks */
|
||||
1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* 32ks */
|
||||
};
|
||||
|
||||
/* bit allocation table look up */
|
||||
/* table per mpeg spec tables 3b2a/b/c/d /e is mpeg2 */
|
||||
/* look_bat[abcd_index][4][16] */
|
||||
static const unsigned char look_bat[5][4][16] =
|
||||
{
|
||||
/* LOOK_BATA */
|
||||
0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17,
|
||||
0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/* LOOK_BATB */
|
||||
0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17,
|
||||
0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/* LOOK_BATC */
|
||||
0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/* LOOK_BATD */
|
||||
0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/* LOOK_BATE */
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
|
||||
/* look_nbat[abcd_index]][4] */
|
||||
static const unsigned char look_nbat[5][4] =
|
||||
{
|
||||
3, 8, 12, 4,
|
||||
3, 8, 12, 7,
|
||||
2, 0, 6, 0,
|
||||
2, 0, 10, 0,
|
||||
4, 0, 7, 19,
|
||||
};
|
||||
|
||||
//extern "sbt.c"
|
||||
void sbt_mono(float *sample, signed short *pcm, int ch);
|
||||
void sbt_dual(float *sample, signed short *pcm, int ch);
|
||||
void sbt16_mono(float *sample, signed short *pcm, int ch);
|
||||
void sbt16_dual(float *sample, signed short *pcm, int ch);
|
||||
void sbt8_mono(float *sample, signed short *pcm, int ch);
|
||||
void sbt8_dual(float *sample, signed short *pcm, int ch);
|
||||
void sbtB_mono(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB_dual(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB16_mono(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB16_dual(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB8_mono(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB8_dual(float *sample, unsigned char *pcm, int ch);
|
||||
|
||||
static const SBT_PROC sbt_table[2][3][2] =
|
||||
{
|
||||
sbt_mono,
|
||||
sbt_dual,
|
||||
sbt16_mono,
|
||||
sbt16_dual,
|
||||
sbt8_mono,
|
||||
sbt8_dual,
|
||||
sbtB_mono,
|
||||
sbtB_dual,
|
||||
sbtB16_mono,
|
||||
sbtB16_dual,
|
||||
sbtB8_mono,
|
||||
sbtB8_dual,
|
||||
};
|
||||
|
||||
void L2table_init()
|
||||
{
|
||||
int i, j, code;
|
||||
long stepL2[18] = {
|
||||
0, 3, 5, 7, 9, 15, 31, 63, 127,
|
||||
255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535
|
||||
};
|
||||
//c_values (dequant)
|
||||
for (i = 1; i < 18; i++) {
|
||||
m_look_c_valueL2[i] = 2.0F / stepL2[i];
|
||||
}
|
||||
//scale factor table, scale by 32768 for 16 pcm output
|
||||
for (i = 0; i < 64; i++) {
|
||||
m_sf_table[i] = (float) (32768.0 * 2.0 * pow_test(2.0, -i / 3.0));
|
||||
}
|
||||
//grouped 3 level lookup table 5 bit token
|
||||
for (i = 0; i < 32; i++) {
|
||||
code = i;
|
||||
for (j = 0; j < 3; j++) {
|
||||
m_group3_table[i][j] = (char) ((code % 3) - 1);
|
||||
code /= 3;
|
||||
}
|
||||
}
|
||||
//grouped 5 level lookup table 7 bit token
|
||||
for (i = 0; i < 128; i++) {
|
||||
code = i;
|
||||
for (j = 0; j < 3; j++) {
|
||||
m_group5_table[i][j] = (char) ((code % 5) - 2);
|
||||
code /= 5;
|
||||
}
|
||||
}
|
||||
//grouped 9 level lookup table 10 bit token
|
||||
for (i = 0; i < 1024; i++) {
|
||||
code = i;
|
||||
for (j = 0; j < 3; j++) {
|
||||
m_group9_table[i][j] = (short) ((code % 9) - 4);
|
||||
code /= 9;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int L2decode_start(MPEG_HEADER* h)
|
||||
{
|
||||
int i, j, k, bit_code, limit;
|
||||
int abcd_index;
|
||||
|
||||
// compute abcd index for bit allo table selection
|
||||
if (h->version == 1) // MPEG-1
|
||||
abcd_index = lookqt[h->mode][h->fr_index][h->br_index];
|
||||
else
|
||||
abcd_index = 4; // MPEG-2, MPEG-2.5
|
||||
if (abcd_index < 0)
|
||||
return 0; // fail invalid Layer II bit rate index
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
m_nbat[i] = look_nbat[abcd_index][i];
|
||||
for (j = 0; j < 16; j++) {
|
||||
m_bat[i][j] = look_bat[abcd_index][i][j];
|
||||
}
|
||||
}
|
||||
m_max_sb = m_nbat[0] + m_nbat[1] + m_nbat[2] + m_nbat[3];
|
||||
// compute nsb_limit
|
||||
m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
|
||||
// caller limit
|
||||
// limit = 0.94*(32>>reduction_code);
|
||||
limit = (32 >> m_option.reduction);
|
||||
if (limit > 8)
|
||||
limit--;
|
||||
if (m_nsb_limit > limit)
|
||||
m_nsb_limit = limit;
|
||||
if (m_nsb_limit > m_max_sb)
|
||||
m_nsb_limit = m_max_sb;
|
||||
|
||||
if (h->mode != 3) {
|
||||
// adjust for 2 channel modes
|
||||
for (i = 0; i < 4; i++)
|
||||
m_nbat[i] *= 2;
|
||||
m_max_sb *= 2;
|
||||
m_nsb_limit *= 2;
|
||||
}
|
||||
|
||||
// set sbt function
|
||||
bit_code = (m_option.convert & 8) ? 1 : 0;
|
||||
k = (h->mode == 3) ? 0 : (1 + m_option.convert);
|
||||
m_sbt_proc = sbt_table[bit_code][m_option.reduction][k];//[2][3][2]
|
||||
// clear sample buffer, unused sub bands must be 0
|
||||
for (i = 0; i < 2304; i++)
|
||||
m_sample[i] = 0.0F;
|
||||
return 1;
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
#include <math.h> //sqrt
|
||||
|
||||
static float csa[8][2]; /* antialias */
|
||||
|
||||
void alias_init()
|
||||
{
|
||||
float Ci[8] =
|
||||
{
|
||||
-0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f
|
||||
};
|
||||
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
csa[i][0] = (float) (1.0 / sqrt(1.0 + Ci[i] * Ci[i]));
|
||||
csa[i][1] = (float) (Ci[i] / sqrt(1.0 + Ci[i] * Ci[i]));
|
||||
}
|
||||
}
|
||||
|
||||
void antialias(float x[], int n)
|
||||
{
|
||||
int i, k;
|
||||
float a, b;
|
||||
|
||||
for (k = 0; k < n; k++)
|
||||
{
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
a = x[17 - i];
|
||||
b = x[18 + i];
|
||||
x[17 - i] = a * csa[i][0] - b * csa[i][1];
|
||||
x[18 + i] = b * csa[i][0] + a * csa[i][1];
|
||||
}
|
||||
x += 18;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,350 +0,0 @@
|
||||
#include "layer3.h"
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#ifndef min
|
||||
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
extern int m_frame_size, m_pcm_size;
|
||||
|
||||
// shared
|
||||
SAMPLE m_sample[2][2][576];//- sample union of int/float sample[ch][gr][576]
|
||||
int m_nsb_limit;
|
||||
SBT_PROC m_sbt_proc;
|
||||
|
||||
XFORM_PROC m_xform_proc;
|
||||
int m_channels; //(mode == 3) ? 1 : 2
|
||||
int m_ms_mode, m_is_mode;
|
||||
int m_sfBandIndex[2][22];// [long/short][cb]
|
||||
int m_nBand[2][22];
|
||||
int m_band_limit;
|
||||
int m_band_limit21; // limit for sf band 21
|
||||
int m_band_limit12; // limit for sf band 12 short
|
||||
int m_band_limit_nsb;
|
||||
int m_ncbl_mixed;
|
||||
|
||||
SIDE_INFO m_side_info;
|
||||
SCALE_FACTOR m_scale_fac[2][2]; // [gr][ch]
|
||||
CB_INFO m_cb_info[2][2]; // [gr][ch]
|
||||
IS_SF_INFO m_is_sf_info;
|
||||
|
||||
#define NBUF (8*1024)
|
||||
#define BUF_TRIGGER (NBUF-1500)
|
||||
|
||||
int m_gr;
|
||||
int m_main_pos_bit;
|
||||
byte m_buf[NBUF];
|
||||
int m_buf_ptr0, m_buf_ptr1;
|
||||
int m_nsamp[2][2]; // must start = 0, for m_nsamp[igr_prev]
|
||||
float m_yout[576]; // hybrid out, sbt in
|
||||
|
||||
//extern "l3side.c"
|
||||
int L3get_side_info1();
|
||||
int L3get_side_info2(int gr);
|
||||
|
||||
//extern "l3sf.c"
|
||||
void L3get_scale_factor1(int gr, int ch);
|
||||
void L3get_scale_factor2(int gr, int ch);
|
||||
|
||||
void huffman(void *xy, int n, int ntable);
|
||||
int huffman_quad(void *vwxy, int n, int nbits, int ntable);
|
||||
void dequant(SAMPLE sample[], int gr, int ch);
|
||||
void antialias(void *x, int n);
|
||||
void ms_process(void *x, int n);
|
||||
void is_process1(void *x, SCALE_FACTOR* sf,
|
||||
CB_INFO cb_info[2], int nsamp);
|
||||
void is_process2(void *x, SCALE_FACTOR * sf,
|
||||
CB_INFO cb_info[2], int nsamp);
|
||||
|
||||
//extern "l3hybrid.c"
|
||||
int hybrid(void *xin, void *xprev, float *y,
|
||||
int btype, int nlong, int ntot, int nprev);
|
||||
int hybrid_sum(void *xin, void *xin_left, float *y,
|
||||
int btype, int nlong, int ntot);
|
||||
void sum_f_bands(void *a, void *b, int n);
|
||||
void freq_invert(float *y, int n); /* xform, */
|
||||
|
||||
void L3decode_main(MPEG_HEADER* h, byte *pcm, int gr);
|
||||
|
||||
void L3decode_reset()
|
||||
{
|
||||
m_buf_ptr0 = m_buf_ptr1 = 0;
|
||||
}
|
||||
|
||||
void L3decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
|
||||
{
|
||||
int crc_size, side_size;
|
||||
int copy_size;
|
||||
|
||||
if (h->mode == 1) {
|
||||
m_ms_mode = h->mode_ext >> 1;
|
||||
m_is_mode = h->mode_ext & 1;
|
||||
}
|
||||
else {
|
||||
m_ms_mode = 0;
|
||||
m_is_mode = 0;
|
||||
}
|
||||
|
||||
crc_size = (h->error_prot) ? 2 : 0;
|
||||
bitget_init(mpeg + 4 + crc_size);
|
||||
if (h->version == 1)
|
||||
side_size = L3get_side_info1();
|
||||
else
|
||||
side_size = L3get_side_info2(m_gr);
|
||||
|
||||
m_buf_ptr0 = m_buf_ptr1 - m_side_info.main_data_begin;/* decode start point */
|
||||
if (m_buf_ptr1 > BUF_TRIGGER) { /* shift buffer */
|
||||
memmove(m_buf, m_buf + m_buf_ptr0, m_side_info.main_data_begin);
|
||||
m_buf_ptr0 = 0;
|
||||
m_buf_ptr1 = m_side_info.main_data_begin;
|
||||
}
|
||||
copy_size = m_frame_size - (4 + crc_size + side_size);
|
||||
//24/02/02 X-MaD
|
||||
if (copy_size < 0) { copy_size = copy_size * -1; }
|
||||
//if (copy_size < 0) { copy_size = 0; }
|
||||
//__try {
|
||||
memmove(m_buf + m_buf_ptr1, mpeg + (4 + crc_size + side_size), copy_size);
|
||||
//} __except(0){
|
||||
// m_buf_ptr1 = 0;
|
||||
//}
|
||||
m_buf_ptr1 += copy_size;
|
||||
//24/02/02 X-MaD
|
||||
|
||||
if (m_buf_ptr0 >= 0) {
|
||||
m_main_pos_bit = m_buf_ptr0 << 3;
|
||||
if (h->version == 1) {
|
||||
L3decode_main(h, pcm, 0);
|
||||
L3decode_main(h, pcm + (m_pcm_size / 2), 1);
|
||||
}
|
||||
else {
|
||||
L3decode_main(h, pcm, m_gr);
|
||||
m_gr = m_gr ^ 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void L3decode_main(MPEG_HEADER* h, byte *pcm, int gr)
|
||||
{
|
||||
int ch;
|
||||
int n1, n2, n3, n4, nn2, nn3, nn4;
|
||||
int bit0, qbits, m0;
|
||||
|
||||
for (ch = 0; ch < m_channels; ch ++) {
|
||||
bitget_init(m_buf + (m_main_pos_bit >> 3));
|
||||
bit0 = (m_main_pos_bit & 7);
|
||||
if (bit0) bitget(bit0);
|
||||
m_main_pos_bit += m_side_info.gr[gr][ch].part2_3_length;
|
||||
bitget_init_end(m_buf + ((m_main_pos_bit + 39) >> 3));
|
||||
// scale factors
|
||||
if (h->version == 1)
|
||||
L3get_scale_factor1(gr, ch);
|
||||
else
|
||||
L3get_scale_factor2(gr, ch);
|
||||
// huff data
|
||||
n1 = m_sfBandIndex[0][m_side_info.gr[gr][ch].region0_count];
|
||||
n2 = m_sfBandIndex[0][m_side_info.gr[gr][ch].region0_count
|
||||
+ m_side_info.gr[gr][ch].region1_count + 1];
|
||||
n3 = m_side_info.gr[gr][ch].big_values;
|
||||
n3 = n3 + n3;
|
||||
|
||||
if (n3 > m_band_limit) n3 = m_band_limit;
|
||||
if (n2 > n3) n2 = n3;
|
||||
if (n1 > n3) n1 = n3;
|
||||
nn3 = n3 - n2;
|
||||
nn2 = n2 - n1;
|
||||
huffman(m_sample[ch][gr], n1, m_side_info.gr[gr][ch].table_select[0]);
|
||||
huffman(m_sample[ch][gr] + n1, nn2, m_side_info.gr[gr][ch].table_select[1]);
|
||||
huffman(m_sample[ch][gr] + n2, nn3, m_side_info.gr[gr][ch].table_select[2]);
|
||||
qbits = m_side_info.gr[gr][ch].part2_3_length - (bitget_bits_used() - bit0);
|
||||
nn4 = huffman_quad(m_sample[ch][gr] + n3, m_band_limit - n3, qbits,
|
||||
m_side_info.gr[gr][ch].count1table_select);
|
||||
n4 = n3 + nn4;
|
||||
m_nsamp[gr][ch] = n4;
|
||||
// limit n4 or allow deqaunt to sf band 22
|
||||
if (m_side_info.gr[gr][ch].block_type == 2)
|
||||
n4 = min(n4, m_band_limit12);
|
||||
else
|
||||
n4 = min(n4, m_band_limit21);
|
||||
if (n4 < 576)
|
||||
memset(m_sample[ch][gr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
|
||||
if (bitget_overrun())
|
||||
memset(m_sample[ch][gr], 0, sizeof(SAMPLE) * (576));
|
||||
}
|
||||
// dequant
|
||||
for (ch = 0; ch < m_channels; ch++) {
|
||||
dequant(m_sample[ch][gr], gr, ch);
|
||||
}
|
||||
// ms stereo processing
|
||||
if (m_ms_mode) {
|
||||
if (m_is_mode == 0) {
|
||||
m0 = m_nsamp[gr][0]; // process to longer of left/right
|
||||
if (m0 < m_nsamp[gr][1])
|
||||
m0 = m_nsamp[gr][1];
|
||||
}
|
||||
else {// process to last cb in right
|
||||
m0 = m_sfBandIndex[m_cb_info[gr][1].cbtype][m_cb_info[gr][1].cbmax];
|
||||
}
|
||||
ms_process(m_sample[0][gr], m0);
|
||||
}
|
||||
// is stereo processing
|
||||
if (m_is_mode) {
|
||||
if (h->version == 1)
|
||||
is_process1(m_sample[0][gr], &m_scale_fac[gr][1],
|
||||
m_cb_info[gr], m_nsamp[gr][0]);
|
||||
else
|
||||
is_process2(m_sample[0][gr], &m_scale_fac[gr][1],
|
||||
m_cb_info[gr], m_nsamp[gr][0]);
|
||||
}
|
||||
// adjust ms and is modes to max of left/right
|
||||
if (m_ms_mode || m_is_mode) {
|
||||
if (m_nsamp[gr][0] < m_nsamp[gr][1])
|
||||
m_nsamp[gr][0] = m_nsamp[gr][1];
|
||||
else
|
||||
m_nsamp[gr][1] = m_nsamp[gr][0];
|
||||
}
|
||||
|
||||
// antialias
|
||||
for (ch = 0; ch < m_channels; ch ++) {
|
||||
if (m_cb_info[gr][ch].ncbl == 0)
|
||||
continue; // have no long blocks
|
||||
if (m_side_info.gr[gr][ch].mixed_block_flag)
|
||||
n1 = 1; // 1 -> 36 samples
|
||||
else
|
||||
n1 = (m_nsamp[gr][ch] + 7) / 18;
|
||||
if (n1 > 31)
|
||||
n1 = 31;
|
||||
antialias(m_sample[ch][gr], n1);
|
||||
n1 = 18 * n1 + 8; // update number of samples
|
||||
if (n1 > m_nsamp[gr][ch])
|
||||
m_nsamp[gr][ch] = n1;
|
||||
}
|
||||
// hybrid + sbt
|
||||
m_xform_proc(pcm, gr);
|
||||
}
|
||||
|
||||
void xform_mono(void *pcm, int igr)
|
||||
{
|
||||
int igr_prev, n1, n2;
|
||||
|
||||
// hybrid + sbt
|
||||
n1 = n2 = m_nsamp[igr][0]; // total number bands
|
||||
if (m_side_info.gr[igr][0].block_type == 2) { // long bands
|
||||
if (m_side_info.gr[igr][0].mixed_block_flag)
|
||||
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
|
||||
else
|
||||
n1 = 0;
|
||||
}
|
||||
if (n1 > m_band_limit)
|
||||
n1 = m_band_limit;
|
||||
if (n2 > m_band_limit)
|
||||
n2 = m_band_limit;
|
||||
igr_prev = igr ^ 1;
|
||||
|
||||
m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
|
||||
m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
|
||||
freq_invert(m_yout, m_nsamp[igr][0]);
|
||||
m_sbt_proc(m_yout, pcm, 0);
|
||||
}
|
||||
|
||||
void xform_dual_right(void *pcm, int igr)
|
||||
{
|
||||
int igr_prev, n1, n2;
|
||||
|
||||
// hybrid + sbt
|
||||
n1 = n2 = m_nsamp[igr][1]; // total number bands
|
||||
if (m_side_info.gr[igr][1].block_type == 2) { // long bands
|
||||
if (m_side_info.gr[igr][1].mixed_block_flag)
|
||||
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
|
||||
else
|
||||
n1 = 0;
|
||||
}
|
||||
if (n1 > m_band_limit)
|
||||
n1 = m_band_limit;
|
||||
if (n2 > m_band_limit)
|
||||
n2 = m_band_limit;
|
||||
igr_prev = igr ^ 1;
|
||||
m_nsamp[igr][1] = hybrid(m_sample[1][igr], m_sample[1][igr_prev],
|
||||
m_yout, m_side_info.gr[igr][1].block_type, n1, n2, m_nsamp[igr_prev][1]);
|
||||
freq_invert(m_yout, m_nsamp[igr][1]);
|
||||
m_sbt_proc(m_yout, pcm, 0);
|
||||
}
|
||||
|
||||
void xform_dual(void *pcm, int igr)
|
||||
{
|
||||
int ch;
|
||||
int igr_prev, n1, n2;
|
||||
|
||||
// hybrid + sbt
|
||||
igr_prev = igr ^ 1;
|
||||
for (ch = 0; ch < m_channels; ch++) {
|
||||
n1 = n2 = m_nsamp[igr][ch]; // total number bands
|
||||
if (m_side_info.gr[igr][ch].block_type == 2) { // long bands
|
||||
if (m_side_info.gr[igr][ch].mixed_block_flag)
|
||||
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
|
||||
else
|
||||
n1 = 0;
|
||||
}
|
||||
if (n1 > m_band_limit)
|
||||
n1 = m_band_limit;
|
||||
if (n2 > m_band_limit)
|
||||
n2 = m_band_limit;
|
||||
m_nsamp[igr][ch] = hybrid(m_sample[ch][igr], m_sample[ch][igr_prev],
|
||||
m_yout, m_side_info.gr[igr][ch].block_type, n1, n2, m_nsamp[igr_prev][ch]);
|
||||
freq_invert(m_yout, m_nsamp[igr][ch]);
|
||||
m_sbt_proc(m_yout, pcm, ch);
|
||||
}
|
||||
}
|
||||
|
||||
void xform_dual_mono(void *pcm, int igr)
|
||||
{
|
||||
int igr_prev, n1, n2, n3;
|
||||
|
||||
// hybrid + sbt
|
||||
igr_prev = igr ^ 1;
|
||||
if ((m_side_info.gr[igr][0].block_type == m_side_info.gr[igr][1].block_type)
|
||||
&& (m_side_info.gr[igr][0].mixed_block_flag == 0)
|
||||
&& (m_side_info.gr[igr][1].mixed_block_flag == 0)) {
|
||||
n2 = m_nsamp[igr][0]; // total number bands max of L R
|
||||
if (n2 < m_nsamp[igr][1])
|
||||
n2 = m_nsamp[igr][1];
|
||||
if (n2 > m_band_limit)
|
||||
n2 = m_band_limit;
|
||||
if (m_side_info.gr[igr][0].block_type == 2)
|
||||
n1 = 0;
|
||||
else
|
||||
n1 = n2; // n1 = number long bands
|
||||
sum_f_bands(m_sample[0][igr], m_sample[1][igr], n2);
|
||||
n3 = m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
|
||||
m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
|
||||
}
|
||||
else { // transform and then sum (not tested - never happens in test)
|
||||
// left chan
|
||||
n1 = n2 = m_nsamp[igr][0]; // total number bands
|
||||
if (m_side_info.gr[igr][0].block_type == 2) { // long bands
|
||||
if (m_side_info.gr[igr][0].mixed_block_flag)
|
||||
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
|
||||
else
|
||||
n1 = 0;
|
||||
}
|
||||
n3 = m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
|
||||
m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
|
||||
// right chan
|
||||
n1 = n2 = m_nsamp[igr][1]; // total number bands
|
||||
if (m_side_info.gr[igr][1].block_type == 2) { // long bands
|
||||
if (m_side_info.gr[igr][1].mixed_block_flag)
|
||||
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
|
||||
else
|
||||
n1 = 0;
|
||||
}
|
||||
m_nsamp[igr][1] = hybrid_sum(m_sample[1][igr], m_sample[0][igr],
|
||||
m_yout, m_side_info.gr[igr][1].block_type, n1, n2);
|
||||
if (n3 < m_nsamp[igr][1])
|
||||
n1 = m_nsamp[igr][1];
|
||||
}
|
||||
|
||||
freq_invert(m_yout, n3);
|
||||
m_sbt_proc(m_yout, pcm, 0);
|
||||
}
|
||||
|
||||
@ -1,359 +0,0 @@
|
||||
#include "layer3.h"
|
||||
#include "l3huff.h"
|
||||
|
||||
//#ifdef _MSC_VER
|
||||
//#pragma warning(disable: 4505)
|
||||
//#endif
|
||||
|
||||
/*===============================================================*/
|
||||
|
||||
/* max bits required for any lookup - change if htable changes */
|
||||
/* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */
|
||||
#define MAXBITS 9
|
||||
|
||||
static HUFF_ELEMENT huff_table_0[] =
|
||||
{0, 0, 0, 64}; /* dummy must not use */
|
||||
|
||||
/*-- 6 bit lookup (purgebits, value) --*/
|
||||
static unsigned char quad_table_a[][2] =
|
||||
{
|
||||
6, 11, 6, 15, 6, 13, 6, 14, 6, 7, 6, 5, 5, 9,
|
||||
5, 9, 5, 6, 5, 6, 5, 3, 5, 3, 5, 10, 5, 10,
|
||||
5, 12, 5, 12, 4, 2, 4, 2, 4, 2, 4, 2, 4, 1,
|
||||
4, 1, 4, 1, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 8, 4, 8, 4, 8, 4, 8, 1, 0, 1, 0, 1, 0,
|
||||
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
|
||||
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
|
||||
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
|
||||
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
|
||||
1, 0,
|
||||
};
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
HUFF_ELEMENT *table;
|
||||
int linbits;
|
||||
int ncase;
|
||||
}
|
||||
HUFF_SETUP;
|
||||
|
||||
#define no_bits 0
|
||||
#define one_shot 1
|
||||
#define no_linbits 2
|
||||
#define have_linbits 3
|
||||
#define quad_a 4
|
||||
#define quad_b 5
|
||||
|
||||
|
||||
static HUFF_SETUP table_look[] =
|
||||
{
|
||||
huff_table_0, 0, no_bits,
|
||||
huff_table_1, 0, one_shot,
|
||||
huff_table_2, 0, one_shot,
|
||||
huff_table_3, 0, one_shot,
|
||||
huff_table_0, 0, no_bits,
|
||||
huff_table_5, 0, one_shot,
|
||||
huff_table_6, 0, one_shot,
|
||||
huff_table_7, 0, no_linbits,
|
||||
huff_table_8, 0, no_linbits,
|
||||
huff_table_9, 0, no_linbits,
|
||||
huff_table_10, 0, no_linbits,
|
||||
huff_table_11, 0, no_linbits,
|
||||
huff_table_12, 0, no_linbits,
|
||||
huff_table_13, 0, no_linbits,
|
||||
huff_table_0, 0, no_bits,
|
||||
huff_table_15, 0, no_linbits,
|
||||
huff_table_16, 1, have_linbits,
|
||||
huff_table_16, 2, have_linbits,
|
||||
huff_table_16, 3, have_linbits,
|
||||
huff_table_16, 4, have_linbits,
|
||||
huff_table_16, 6, have_linbits,
|
||||
huff_table_16, 8, have_linbits,
|
||||
huff_table_16, 10, have_linbits,
|
||||
huff_table_16, 13, have_linbits,
|
||||
huff_table_24, 4, have_linbits,
|
||||
huff_table_24, 5, have_linbits,
|
||||
huff_table_24, 6, have_linbits,
|
||||
huff_table_24, 7, have_linbits,
|
||||
huff_table_24, 8, have_linbits,
|
||||
huff_table_24, 9, have_linbits,
|
||||
huff_table_24, 11, have_linbits,
|
||||
huff_table_24, 13, have_linbits,
|
||||
huff_table_0, 0, quad_a,
|
||||
huff_table_0, 0, quad_b,
|
||||
};
|
||||
|
||||
/*========================================================*/
|
||||
void huffman(int xy[][2], int n, int ntable)
|
||||
{
|
||||
int i;
|
||||
HUFF_ELEMENT *t;
|
||||
HUFF_ELEMENT *t0;
|
||||
int linbits;
|
||||
int bits;
|
||||
int code;
|
||||
int x, y;
|
||||
|
||||
if (n <= 0)
|
||||
return;
|
||||
n = n >> 1; /* huff in pairs */
|
||||
/*-------------*/
|
||||
t0 = table_look[ntable].table;
|
||||
linbits = table_look[ntable].linbits;
|
||||
switch (table_look[ntable].ncase)
|
||||
{
|
||||
default:
|
||||
/*------------------------------------------*/
|
||||
case no_bits:
|
||||
/*- table 0, no data, x=y=0--*/
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
xy[i][0] = 0;
|
||||
xy[i][1] = 0;
|
||||
}
|
||||
return;
|
||||
/*------------------------------------------*/
|
||||
case one_shot:
|
||||
/*- single lookup, no escapes -*/
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
mac_bitget_check((MAXBITS + 2));
|
||||
bits = t0[0].b.signbits;
|
||||
code = mac_bitget2(bits);
|
||||
mac_bitget_purge(t0[1 + code].b.purgebits);
|
||||
x = t0[1 + code].b.x;
|
||||
y = t0[1 + code].b.y;
|
||||
if (x)
|
||||
if (mac_bitget_1bit())
|
||||
x = -x;
|
||||
if (y)
|
||||
if (mac_bitget_1bit())
|
||||
y = -y;
|
||||
xy[i][0] = x;
|
||||
xy[i][1] = y;
|
||||
if (bitget_overrun())
|
||||
break; // bad data protect
|
||||
|
||||
}
|
||||
return;
|
||||
/*------------------------------------------*/
|
||||
case no_linbits:
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
t = t0;
|
||||
for (;;)
|
||||
{
|
||||
mac_bitget_check((MAXBITS + 2));
|
||||
bits = t[0].b.signbits;
|
||||
code = mac_bitget2(bits);
|
||||
if (t[1 + code].b.purgebits)
|
||||
break;
|
||||
t += t[1 + code].ptr; /* ptr include 1+code */
|
||||
mac_bitget_purge(bits);
|
||||
}
|
||||
mac_bitget_purge(t[1 + code].b.purgebits);
|
||||
x = t[1 + code].b.x;
|
||||
y = t[1 + code].b.y;
|
||||
if (x)
|
||||
if (mac_bitget_1bit())
|
||||
x = -x;
|
||||
if (y)
|
||||
if (mac_bitget_1bit())
|
||||
y = -y;
|
||||
xy[i][0] = x;
|
||||
xy[i][1] = y;
|
||||
if (bitget_overrun())
|
||||
break; // bad data protect
|
||||
|
||||
}
|
||||
return;
|
||||
/*------------------------------------------*/
|
||||
case have_linbits:
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
t = t0;
|
||||
for (;;)
|
||||
{
|
||||
bits = t[0].b.signbits;
|
||||
code = bitget2(bits);
|
||||
if (t[1 + code].b.purgebits)
|
||||
break;
|
||||
t += t[1 + code].ptr; /* ptr includes 1+code */
|
||||
mac_bitget_purge(bits);
|
||||
}
|
||||
mac_bitget_purge(t[1 + code].b.purgebits);
|
||||
x = t[1 + code].b.x;
|
||||
y = t[1 + code].b.y;
|
||||
if (x == 15)
|
||||
x += bitget_lb(linbits);
|
||||
if (x)
|
||||
if (mac_bitget_1bit())
|
||||
x = -x;
|
||||
if (y == 15)
|
||||
y += bitget_lb(linbits);
|
||||
if (y)
|
||||
if (mac_bitget_1bit())
|
||||
y = -y;
|
||||
xy[i][0] = x;
|
||||
xy[i][1] = y;
|
||||
if (bitget_overrun())
|
||||
break; // bad data protect
|
||||
|
||||
}
|
||||
return;
|
||||
}
|
||||
/*--- end switch ---*/
|
||||
|
||||
}
|
||||
|
||||
int huffman_quad(int vwxy[][4], int n, int nbits, int ntable)
|
||||
{
|
||||
int i;
|
||||
int code;
|
||||
int x, y, v, w;
|
||||
int tmp;
|
||||
int i_non_zero, tmp_nz;
|
||||
|
||||
tmp_nz = 15;
|
||||
i_non_zero = -1;
|
||||
|
||||
n = n >> 2; /* huff in quads */
|
||||
|
||||
if (ntable)
|
||||
goto case_quad_b;
|
||||
|
||||
/* case_quad_a: */
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
if (nbits <= 0)
|
||||
break;
|
||||
mac_bitget_check(10);
|
||||
code = mac_bitget2(6);
|
||||
nbits -= quad_table_a[code][0];
|
||||
mac_bitget_purge(quad_table_a[code][0]);
|
||||
tmp = quad_table_a[code][1];
|
||||
if (tmp)
|
||||
{
|
||||
i_non_zero = i;
|
||||
tmp_nz = tmp;
|
||||
}
|
||||
v = (tmp >> 3) & 1;
|
||||
w = (tmp >> 2) & 1;
|
||||
x = (tmp >> 1) & 1;
|
||||
y = tmp & 1;
|
||||
if (v)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
v = -v;
|
||||
nbits--;
|
||||
}
|
||||
if (w)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
w = -w;
|
||||
nbits--;
|
||||
}
|
||||
if (x)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
x = -x;
|
||||
nbits--;
|
||||
}
|
||||
if (y)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
y = -y;
|
||||
nbits--;
|
||||
}
|
||||
vwxy[i][0] = v;
|
||||
vwxy[i][1] = w;
|
||||
vwxy[i][2] = x;
|
||||
vwxy[i][3] = y;
|
||||
if (bitget_overrun())
|
||||
break; // bad data protect
|
||||
|
||||
}
|
||||
if (nbits < 0)
|
||||
{
|
||||
i--;
|
||||
vwxy[i][0] = 0;
|
||||
vwxy[i][1] = 0;
|
||||
vwxy[i][2] = 0;
|
||||
vwxy[i][3] = 0;
|
||||
}
|
||||
|
||||
i_non_zero = (i_non_zero + 1) << 2;
|
||||
|
||||
if ((tmp_nz & 3) == 0)
|
||||
i_non_zero -= 2;
|
||||
|
||||
return i_non_zero;
|
||||
|
||||
/*--------------------*/
|
||||
case_quad_b:
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
if (nbits < 4)
|
||||
break;
|
||||
nbits -= 4;
|
||||
mac_bitget_check(8);
|
||||
tmp = mac_bitget(4) ^ 15; /* one's complement of bitstream */
|
||||
if (tmp)
|
||||
{
|
||||
i_non_zero = i;
|
||||
tmp_nz = tmp;
|
||||
}
|
||||
v = (tmp >> 3) & 1;
|
||||
w = (tmp >> 2) & 1;
|
||||
x = (tmp >> 1) & 1;
|
||||
y = tmp & 1;
|
||||
if (v)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
v = -v;
|
||||
nbits--;
|
||||
}
|
||||
if (w)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
w = -w;
|
||||
nbits--;
|
||||
}
|
||||
if (x)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
x = -x;
|
||||
nbits--;
|
||||
}
|
||||
if (y)
|
||||
{
|
||||
if (mac_bitget_1bit())
|
||||
y = -y;
|
||||
nbits--;
|
||||
}
|
||||
vwxy[i][0] = v;
|
||||
vwxy[i][1] = w;
|
||||
vwxy[i][2] = x;
|
||||
vwxy[i][3] = y;
|
||||
if (bitget_overrun())
|
||||
break; // bad data protect
|
||||
|
||||
}
|
||||
if (nbits < 0)
|
||||
{
|
||||
i--;
|
||||
vwxy[i][0] = 0;
|
||||
vwxy[i][1] = 0;
|
||||
vwxy[i][2] = 0;
|
||||
vwxy[i][3] = 0;
|
||||
}
|
||||
|
||||
i_non_zero = (i_non_zero + 1) << 2;
|
||||
|
||||
if ((tmp_nz & 3) == 0)
|
||||
i_non_zero -= 2;
|
||||
|
||||
return i_non_zero; /* return non-zero sample (to nearest pair) */
|
||||
|
||||
}
|
||||
@ -1,973 +0,0 @@
|
||||
typedef union
|
||||
{
|
||||
int ptr;
|
||||
struct
|
||||
{
|
||||
unsigned char signbits;
|
||||
unsigned char x;
|
||||
unsigned char y;
|
||||
unsigned char purgebits; // 0 = esc
|
||||
|
||||
}
|
||||
b;
|
||||
}
|
||||
HUFF_ELEMENT;
|
||||
|
||||
/* TABLE 1 4 entries maxbits 3 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_1[] =
|
||||
{
|
||||
0xFF000003, 0x03010102, 0x03010001, 0x02000101, 0x02000101, /* 4 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000,};
|
||||
|
||||
/* max table bits 3 */
|
||||
|
||||
/* TABLE 2 9 entries maxbits 6 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_2[] =
|
||||
{
|
||||
0xFF000006, 0x06020202, 0x06020001, 0x05020102, 0x05020102, /* 4 */
|
||||
0x05010202, 0x05010202, 0x05000201, 0x05000201, 0x03010102, /* 9 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 14 */
|
||||
0x03010102, 0x03010102, 0x03010001, 0x03010001, 0x03010001, /* 19 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 24 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 29 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x01000000, 0x01000000, /* 34 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 39 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 44 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 49 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 54 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 59 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 64 */ };
|
||||
|
||||
/* max table bits 6 */
|
||||
|
||||
/* TABLE 3 9 entries maxbits 6 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_3[] =
|
||||
{
|
||||
0xFF000006, 0x06020202, 0x06020001, 0x05020102, 0x05020102, /* 4 */
|
||||
0x05010202, 0x05010202, 0x05000201, 0x05000201, 0x03000101, /* 9 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 14 */
|
||||
0x03000101, 0x03000101, 0x02010102, 0x02010102, 0x02010102, /* 19 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 24 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 29 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010001, 0x02010001, /* 34 */
|
||||
0x02010001, 0x02010001, 0x02010001, 0x02010001, 0x02010001, /* 39 */
|
||||
0x02010001, 0x02010001, 0x02010001, 0x02010001, 0x02010001, /* 44 */
|
||||
0x02010001, 0x02010001, 0x02010001, 0x02010001, 0x02000000, /* 49 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 54 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 59 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 64 */ };
|
||||
|
||||
/* max table bits 6 */
|
||||
/* NO XING TABLE 4 */
|
||||
|
||||
/* TABLE 5 16 entries maxbits 8 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_5[] =
|
||||
{
|
||||
0xFF000008, 0x08030302, 0x08030202, 0x07020302, 0x07020302, /* 4 */
|
||||
0x06010302, 0x06010302, 0x06010302, 0x06010302, 0x07030102, /* 9 */
|
||||
0x07030102, 0x07030001, 0x07030001, 0x07000301, 0x07000301, /* 14 */
|
||||
0x07020202, 0x07020202, 0x06020102, 0x06020102, 0x06020102, /* 19 */
|
||||
0x06020102, 0x06010202, 0x06010202, 0x06010202, 0x06010202, /* 24 */
|
||||
0x06020001, 0x06020001, 0x06020001, 0x06020001, 0x06000201, /* 29 */
|
||||
0x06000201, 0x06000201, 0x06000201, 0x03010102, 0x03010102, /* 34 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 39 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 44 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 49 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 54 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 59 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 64 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 69 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 74 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 79 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 84 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 89 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 94 */
|
||||
0x03010001, 0x03010001, 0x03000101, 0x03000101, 0x03000101, /* 99 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 114 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x01000000, /* 129 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 134 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 139 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 144 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 149 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 154 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 159 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 164 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 169 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 174 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 179 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 184 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 189 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 194 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 199 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 204 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 209 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 214 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 219 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 224 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 229 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 234 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 239 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 244 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 249 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 254 */
|
||||
0x01000000, 0x01000000,};
|
||||
|
||||
/* max table bits 8 */
|
||||
|
||||
/* TABLE 6 16 entries maxbits 7 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_6[] =
|
||||
{
|
||||
0xFF000007, 0x07030302, 0x07030001, 0x06030202, 0x06030202, /* 4 */
|
||||
0x06020302, 0x06020302, 0x06000301, 0x06000301, 0x05030102, /* 9 */
|
||||
0x05030102, 0x05030102, 0x05030102, 0x05010302, 0x05010302, /* 14 */
|
||||
0x05010302, 0x05010302, 0x05020202, 0x05020202, 0x05020202, /* 19 */
|
||||
0x05020202, 0x05020001, 0x05020001, 0x05020001, 0x05020001, /* 24 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 29 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04010202, 0x04010202, /* 34 */
|
||||
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 39 */
|
||||
0x04010202, 0x04000201, 0x04000201, 0x04000201, 0x04000201, /* 44 */
|
||||
0x04000201, 0x04000201, 0x04000201, 0x04000201, 0x03010001, /* 49 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 54 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 59 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 64 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 69 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 74 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 79 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 84 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 89 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 94 */
|
||||
0x02010102, 0x02010102, 0x03000101, 0x03000101, 0x03000101, /* 99 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000000, 0x03000000, /* 114 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 119 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 124 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000,};
|
||||
|
||||
/* max table bits 7 */
|
||||
|
||||
/* TABLE 7 36 entries maxbits 10 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_7[] =
|
||||
{
|
||||
0xFF000006, 0x00000041, 0x00000052, 0x0000005B, 0x00000060, /* 4 */
|
||||
0x00000063, 0x00000068, 0x0000006B, 0x06020102, 0x05010202, /* 9 */
|
||||
0x05010202, 0x06020001, 0x06000201, 0x04010102, 0x04010102, /* 14 */
|
||||
0x04010102, 0x04010102, 0x03010001, 0x03010001, 0x03010001, /* 19 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 24 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 29 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x01000000, 0x01000000, /* 34 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 39 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 44 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 49 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 54 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 59 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 64 */
|
||||
0xFF000004, 0x04050502, 0x04050402, 0x04040502, 0x04030502, /* 69 */
|
||||
0x03050302, 0x03050302, 0x03040402, 0x03040402, 0x03050202, /* 74 */
|
||||
0x03050202, 0x03020502, 0x03020502, 0x02050102, 0x02050102, /* 79 */
|
||||
0x02050102, 0x02050102, 0xFF000003, 0x02010502, 0x02010502, /* 84 */
|
||||
0x03050001, 0x03040302, 0x02000501, 0x02000501, 0x03030402, /* 89 */
|
||||
0x03030302, 0xFF000002, 0x02040202, 0x02020402, 0x01040102, /* 94 */
|
||||
0x01040102, 0xFF000001, 0x01010402, 0x01000401, 0xFF000002, /* 99 */
|
||||
0x02040001, 0x02030202, 0x02020302, 0x02030001, 0xFF000001, /* 104 */
|
||||
0x01030102, 0x01010302, 0xFF000001, 0x01000301, 0x01020202, /* 109 */ };
|
||||
|
||||
/* max table bits 6 */
|
||||
|
||||
/* TABLE 8 36 entries maxbits 11 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_8[] =
|
||||
{
|
||||
0xFF000008, 0x00000101, 0x0000010A, 0x0000010F, 0x08050102, /* 4 */
|
||||
0x08010502, 0x00000112, 0x00000115, 0x08040202, 0x08020402, /* 9 */
|
||||
0x08040102, 0x07010402, 0x07010402, 0x08040001, 0x08000401, /* 14 */
|
||||
0x08030202, 0x08020302, 0x08030102, 0x08010302, 0x08030001, /* 19 */
|
||||
0x08000301, 0x06020202, 0x06020202, 0x06020202, 0x06020202, /* 24 */
|
||||
0x06020001, 0x06020001, 0x06020001, 0x06020001, 0x06000201, /* 29 */
|
||||
0x06000201, 0x06000201, 0x06000201, 0x04020102, 0x04020102, /* 34 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 39 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 44 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04010202, /* 49 */
|
||||
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 54 */
|
||||
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 59 */
|
||||
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 64 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 69 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 74 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 79 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 84 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 89 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 94 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 99 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 104 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 109 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 114 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 119 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 124 */
|
||||
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x03010001, /* 129 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 134 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 139 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 144 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 149 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 154 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 159 */
|
||||
0x03010001, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 164 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 169 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 174 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 179 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 184 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 189 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x02000000, 0x02000000, /* 194 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 199 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 204 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 209 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 214 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 219 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 224 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 229 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 234 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 239 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 244 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 249 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 254 */
|
||||
0x02000000, 0x02000000, 0xFF000003, 0x03050502, 0x03040502, /* 259 */
|
||||
0x02050402, 0x02050402, 0x01030502, 0x01030502, 0x01030502, /* 264 */
|
||||
0x01030502, 0xFF000002, 0x02050302, 0x02040402, 0x01050202, /* 269 */
|
||||
0x01050202, 0xFF000001, 0x01020502, 0x01050001, 0xFF000001, /* 274 */
|
||||
0x01040302, 0x01030402, 0xFF000001, 0x01000501, 0x01030302, /* 279 */ };
|
||||
|
||||
/* max table bits 8 */
|
||||
|
||||
/* TABLE 9 36 entries maxbits 9 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_9[] =
|
||||
{
|
||||
0xFF000006, 0x00000041, 0x0000004A, 0x0000004F, 0x00000052, /* 4 */
|
||||
0x00000057, 0x0000005A, 0x06040102, 0x06010402, 0x06030202, /* 9 */
|
||||
0x06020302, 0x05030102, 0x05030102, 0x05010302, 0x05010302, /* 14 */
|
||||
0x06030001, 0x06000301, 0x05020202, 0x05020202, 0x05020001, /* 19 */
|
||||
0x05020001, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 24 */
|
||||
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04000201, /* 29 */
|
||||
0x04000201, 0x04000201, 0x04000201, 0x03010102, 0x03010102, /* 34 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 39 */
|
||||
0x03010102, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 44 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03000101, /* 49 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 54 */
|
||||
0x03000101, 0x03000101, 0x03000000, 0x03000000, 0x03000000, /* 59 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 64 */
|
||||
0xFF000003, 0x03050502, 0x03050402, 0x02050302, 0x02050302, /* 69 */
|
||||
0x02030502, 0x02030502, 0x03040502, 0x03050001, 0xFF000002, /* 74 */
|
||||
0x02040402, 0x02050202, 0x02020502, 0x02050102, 0xFF000001, /* 79 */
|
||||
0x01010502, 0x01040302, 0xFF000002, 0x01030402, 0x01030402, /* 84 */
|
||||
0x02000501, 0x02040001, 0xFF000001, 0x01040202, 0x01020402, /* 89 */
|
||||
0xFF000001, 0x01030302, 0x01000401,};
|
||||
|
||||
/* max table bits 6 */
|
||||
|
||||
/* TABLE 10 64 entries maxbits 11 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_10[] =
|
||||
{
|
||||
0xFF000008, 0x00000101, 0x0000010A, 0x0000010F, 0x00000118, /* 4 */
|
||||
0x0000011B, 0x00000120, 0x00000125, 0x08070102, 0x08010702, /* 9 */
|
||||
0x0000012A, 0x0000012D, 0x00000132, 0x08060102, 0x08010602, /* 14 */
|
||||
0x08000601, 0x00000137, 0x0000013A, 0x0000013D, 0x08040102, /* 19 */
|
||||
0x08010402, 0x08000401, 0x08030202, 0x08020302, 0x08030001, /* 24 */
|
||||
0x07030102, 0x07030102, 0x07010302, 0x07010302, 0x07000301, /* 29 */
|
||||
0x07000301, 0x07020202, 0x07020202, 0x06020102, 0x06020102, /* 34 */
|
||||
0x06020102, 0x06020102, 0x06010202, 0x06010202, 0x06010202, /* 39 */
|
||||
0x06010202, 0x06020001, 0x06020001, 0x06020001, 0x06020001, /* 44 */
|
||||
0x06000201, 0x06000201, 0x06000201, 0x06000201, 0x04010102, /* 49 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 54 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 59 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 64 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 69 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 74 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 79 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 84 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 89 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 94 */
|
||||
0x03010001, 0x03010001, 0x03000101, 0x03000101, 0x03000101, /* 99 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 114 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x01000000, /* 129 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 134 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 139 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 144 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 149 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 154 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 159 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 164 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 169 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 174 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 179 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 184 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 189 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 194 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 199 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 204 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 209 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 214 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 219 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 224 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 229 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 234 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 239 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 244 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 249 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 254 */
|
||||
0x01000000, 0x01000000, 0xFF000003, 0x03070702, 0x03070602, /* 259 */
|
||||
0x03060702, 0x03070502, 0x03050702, 0x03060602, 0x02070402, /* 264 */
|
||||
0x02070402, 0xFF000002, 0x02040702, 0x02060502, 0x02050602, /* 269 */
|
||||
0x02070302, 0xFF000003, 0x02030702, 0x02030702, 0x02060402, /* 274 */
|
||||
0x02060402, 0x03050502, 0x03040502, 0x02030602, 0x02030602, /* 279 */
|
||||
0xFF000001, 0x01070202, 0x01020702, 0xFF000002, 0x02040602, /* 284 */
|
||||
0x02070001, 0x01000701, 0x01000701, 0xFF000002, 0x01020602, /* 289 */
|
||||
0x01020602, 0x02050402, 0x02050302, 0xFF000002, 0x01060001, /* 294 */
|
||||
0x01060001, 0x02030502, 0x02040402, 0xFF000001, 0x01060302, /* 299 */
|
||||
0x01060202, 0xFF000002, 0x02050202, 0x02020502, 0x01050102, /* 304 */
|
||||
0x01050102, 0xFF000002, 0x01010502, 0x01010502, 0x02040302, /* 309 */
|
||||
0x02030402, 0xFF000001, 0x01050001, 0x01000501, 0xFF000001, /* 314 */
|
||||
0x01040202, 0x01020402, 0xFF000001, 0x01030302, 0x01040001, /* 319 */ };
|
||||
|
||||
/* max table bits 8 */
|
||||
|
||||
/* TABLE 11 64 entries maxbits 11 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_11[] =
|
||||
{
|
||||
0xFF000008, 0x00000101, 0x00000106, 0x0000010F, 0x00000114, /* 4 */
|
||||
0x00000117, 0x08070202, 0x08020702, 0x0000011C, 0x07010702, /* 9 */
|
||||
0x07010702, 0x08070102, 0x08000701, 0x08060302, 0x08030602, /* 14 */
|
||||
0x08000601, 0x0000011F, 0x00000122, 0x08050102, 0x07020602, /* 19 */
|
||||
0x07020602, 0x08060202, 0x08060001, 0x07060102, 0x07060102, /* 24 */
|
||||
0x07010602, 0x07010602, 0x08010502, 0x08040302, 0x08000501, /* 29 */
|
||||
0x00000125, 0x08040202, 0x08020402, 0x08040102, 0x08010402, /* 34 */
|
||||
0x08040001, 0x08000401, 0x07030202, 0x07030202, 0x07020302, /* 39 */
|
||||
0x07020302, 0x06030102, 0x06030102, 0x06030102, 0x06030102, /* 44 */
|
||||
0x06010302, 0x06010302, 0x06010302, 0x06010302, 0x07030001, /* 49 */
|
||||
0x07030001, 0x07000301, 0x07000301, 0x06020202, 0x06020202, /* 54 */
|
||||
0x06020202, 0x06020202, 0x05010202, 0x05010202, 0x05010202, /* 59 */
|
||||
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 64 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 69 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 74 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 79 */
|
||||
0x04020102, 0x05020001, 0x05020001, 0x05020001, 0x05020001, /* 84 */
|
||||
0x05020001, 0x05020001, 0x05020001, 0x05020001, 0x05000201, /* 89 */
|
||||
0x05000201, 0x05000201, 0x05000201, 0x05000201, 0x05000201, /* 94 */
|
||||
0x05000201, 0x05000201, 0x03010102, 0x03010102, 0x03010102, /* 99 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 104 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 109 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 114 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 119 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 124 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010001, /* 129 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 134 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 139 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 144 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 149 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 154 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 159 */
|
||||
0x03010001, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 164 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 169 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 174 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 179 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 184 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 189 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x02000000, 0x02000000, /* 194 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 199 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 204 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 209 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 214 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 219 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 224 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 229 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 234 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 239 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 244 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 249 */
|
||||
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 254 */
|
||||
0x02000000, 0x02000000, 0xFF000002, 0x02070702, 0x02070602, /* 259 */
|
||||
0x02060702, 0x02050702, 0xFF000003, 0x02060602, 0x02060602, /* 264 */
|
||||
0x02070402, 0x02070402, 0x02040702, 0x02040702, 0x03070502, /* 269 */
|
||||
0x03050502, 0xFF000002, 0x02060502, 0x02050602, 0x01070302, /* 274 */
|
||||
0x01070302, 0xFF000001, 0x01030702, 0x01060402, 0xFF000002, /* 279 */
|
||||
0x02050402, 0x02040502, 0x02050302, 0x02030502, 0xFF000001, /* 284 */
|
||||
0x01040602, 0x01070001, 0xFF000001, 0x01040402, 0x01050202, /* 289 */
|
||||
0xFF000001, 0x01020502, 0x01050001, 0xFF000001, 0x01030402, /* 294 */
|
||||
0x01030302,};
|
||||
|
||||
/* max table bits 8 */
|
||||
|
||||
/* TABLE 12 64 entries maxbits 10 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_12[] =
|
||||
{
|
||||
0xFF000007, 0x00000081, 0x0000008A, 0x0000008F, 0x00000092, /* 4 */
|
||||
0x00000097, 0x0000009A, 0x0000009D, 0x000000A2, 0x000000A5, /* 9 */
|
||||
0x000000A8, 0x07060202, 0x07020602, 0x07010602, 0x000000AD, /* 14 */
|
||||
0x000000B0, 0x000000B3, 0x07050102, 0x07010502, 0x07040302, /* 19 */
|
||||
0x07030402, 0x000000B6, 0x07040202, 0x07020402, 0x07040102, /* 24 */
|
||||
0x06030302, 0x06030302, 0x06010402, 0x06010402, 0x06030202, /* 29 */
|
||||
0x06030202, 0x06020302, 0x06020302, 0x07000401, 0x07030001, /* 34 */
|
||||
0x06000301, 0x06000301, 0x05030102, 0x05030102, 0x05030102, /* 39 */
|
||||
0x05030102, 0x05010302, 0x05010302, 0x05010302, 0x05010302, /* 44 */
|
||||
0x05020202, 0x05020202, 0x05020202, 0x05020202, 0x04020102, /* 49 */
|
||||
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 54 */
|
||||
0x04020102, 0x04020102, 0x04010202, 0x04010202, 0x04010202, /* 59 */
|
||||
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 64 */
|
||||
0x05020001, 0x05020001, 0x05020001, 0x05020001, 0x05000201, /* 69 */
|
||||
0x05000201, 0x05000201, 0x05000201, 0x04000000, 0x04000000, /* 74 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 79 */
|
||||
0x04000000, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 84 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 89 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 94 */
|
||||
0x03010102, 0x03010102, 0x03010001, 0x03010001, 0x03010001, /* 99 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 104 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 109 */
|
||||
0x03010001, 0x03010001, 0x03010001, 0x03000101, 0x03000101, /* 114 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0xFF000003, /* 129 */
|
||||
0x03070702, 0x03070602, 0x02060702, 0x02060702, 0x02070502, /* 134 */
|
||||
0x02070502, 0x02050702, 0x02050702, 0xFF000002, 0x02060602, /* 139 */
|
||||
0x02070402, 0x02040702, 0x02050602, 0xFF000001, 0x01060502, /* 144 */
|
||||
0x01070302, 0xFF000002, 0x02030702, 0x02050502, 0x01070202, /* 149 */
|
||||
0x01070202, 0xFF000001, 0x01020702, 0x01060402, 0xFF000001, /* 154 */
|
||||
0x01040602, 0x01070102, 0xFF000002, 0x01010702, 0x01010702, /* 159 */
|
||||
0x02070001, 0x02000701, 0xFF000001, 0x01060302, 0x01030602, /* 164 */
|
||||
0xFF000001, 0x01050402, 0x01040502, 0xFF000002, 0x01040402, /* 169 */
|
||||
0x01040402, 0x02060001, 0x02050001, 0xFF000001, 0x01060102, /* 174 */
|
||||
0x01000601, 0xFF000001, 0x01050302, 0x01030502, 0xFF000001, /* 179 */
|
||||
0x01050202, 0x01020502, 0xFF000001, 0x01000501, 0x01040001, /* 184 */ };
|
||||
|
||||
/* max table bits 7 */
|
||||
|
||||
/* TABLE 13 256 entries maxbits 19 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_13[] =
|
||||
{
|
||||
0xFF000006, 0x00000041, 0x00000082, 0x000000C3, 0x000000E4, /* 4 */
|
||||
0x00000105, 0x00000116, 0x0000011F, 0x00000130, 0x00000139, /* 9 */
|
||||
0x0000013E, 0x00000143, 0x00000146, 0x06020102, 0x06010202, /* 14 */
|
||||
0x06020001, 0x06000201, 0x04010102, 0x04010102, 0x04010102, /* 19 */
|
||||
0x04010102, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 24 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 29 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x01000000, 0x01000000, /* 34 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 39 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 44 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 49 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 54 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 59 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 64 */
|
||||
0xFF000006, 0x00000108, 0x00000111, 0x0000011A, 0x00000123, /* 69 */
|
||||
0x0000012C, 0x00000131, 0x00000136, 0x0000013F, 0x00000144, /* 74 */
|
||||
0x00000147, 0x0000014C, 0x00000151, 0x00000156, 0x0000015B, /* 79 */
|
||||
0x060F0102, 0x06010F02, 0x06000F01, 0x00000160, 0x00000163, /* 84 */
|
||||
0x00000166, 0x06020E02, 0x00000169, 0x060E0102, 0x06010E02, /* 89 */
|
||||
0x0000016C, 0x0000016F, 0x00000172, 0x00000175, 0x00000178, /* 94 */
|
||||
0x0000017B, 0x06060C02, 0x060D0302, 0x0000017E, 0x060D0202, /* 99 */
|
||||
0x06020D02, 0x060D0102, 0x06070B02, 0x00000181, 0x00000184, /* 104 */
|
||||
0x06030C02, 0x00000187, 0x060B0402, 0x05010D02, 0x05010D02, /* 109 */
|
||||
0x060D0001, 0x06000D01, 0x060A0802, 0x06080A02, 0x060C0402, /* 114 */
|
||||
0x06040C02, 0x060B0602, 0x06060B02, 0x050C0302, 0x050C0302, /* 119 */
|
||||
0x050C0202, 0x050C0202, 0x05020C02, 0x05020C02, 0x050B0502, /* 124 */
|
||||
0x050B0502, 0x06050B02, 0x06090802, 0x050C0102, 0x050C0102, /* 129 */
|
||||
0xFF000006, 0x05010C02, 0x05010C02, 0x06080902, 0x060C0001, /* 134 */
|
||||
0x05000C01, 0x05000C01, 0x06040B02, 0x060A0602, 0x06060A02, /* 139 */
|
||||
0x06090702, 0x050B0302, 0x050B0302, 0x05030B02, 0x05030B02, /* 144 */
|
||||
0x06080802, 0x060A0502, 0x050B0202, 0x050B0202, 0x06050A02, /* 149 */
|
||||
0x06090602, 0x05040A02, 0x05040A02, 0x06080702, 0x06070802, /* 154 */
|
||||
0x05040902, 0x05040902, 0x06070702, 0x06060702, 0x04020B02, /* 159 */
|
||||
0x04020B02, 0x04020B02, 0x04020B02, 0x040B0102, 0x040B0102, /* 164 */
|
||||
0x040B0102, 0x040B0102, 0x04010B02, 0x04010B02, 0x04010B02, /* 169 */
|
||||
0x04010B02, 0x050B0001, 0x050B0001, 0x05000B01, 0x05000B01, /* 174 */
|
||||
0x05060902, 0x05060902, 0x050A0402, 0x050A0402, 0x050A0302, /* 179 */
|
||||
0x050A0302, 0x05030A02, 0x05030A02, 0x05090502, 0x05090502, /* 184 */
|
||||
0x05050902, 0x05050902, 0x040A0202, 0x040A0202, 0x040A0202, /* 189 */
|
||||
0x040A0202, 0x04020A02, 0x04020A02, 0x04020A02, 0x04020A02, /* 194 */
|
||||
0xFF000005, 0x040A0102, 0x040A0102, 0x04010A02, 0x04010A02, /* 199 */
|
||||
0x050A0001, 0x05080602, 0x04000A01, 0x04000A01, 0x05060802, /* 204 */
|
||||
0x05090402, 0x04030902, 0x04030902, 0x05090302, 0x05080502, /* 209 */
|
||||
0x05050802, 0x05070602, 0x04090202, 0x04090202, 0x04020902, /* 214 */
|
||||
0x04020902, 0x05070502, 0x05050702, 0x04080302, 0x04080302, /* 219 */
|
||||
0x04030802, 0x04030802, 0x05060602, 0x05070402, 0x05040702, /* 224 */
|
||||
0x05060502, 0x05050602, 0x05030702, 0xFF000005, 0x03090102, /* 229 */
|
||||
0x03090102, 0x03090102, 0x03090102, 0x03010902, 0x03010902, /* 234 */
|
||||
0x03010902, 0x03010902, 0x04090001, 0x04090001, 0x04000901, /* 239 */
|
||||
0x04000901, 0x04080402, 0x04080402, 0x04040802, 0x04040802, /* 244 */
|
||||
0x04020702, 0x04020702, 0x05060402, 0x05040602, 0x03080202, /* 249 */
|
||||
0x03080202, 0x03080202, 0x03080202, 0x03020802, 0x03020802, /* 254 */
|
||||
0x03020802, 0x03020802, 0x03080102, 0x03080102, 0x03080102, /* 259 */
|
||||
0x03080102, 0xFF000004, 0x04070302, 0x04070202, 0x03070102, /* 264 */
|
||||
0x03070102, 0x03010702, 0x03010702, 0x04050502, 0x04070001, /* 269 */
|
||||
0x04000701, 0x04060302, 0x04030602, 0x04050402, 0x04040502, /* 274 */
|
||||
0x04060202, 0x04020602, 0x04050302, 0xFF000003, 0x02010802, /* 279 */
|
||||
0x02010802, 0x03080001, 0x03000801, 0x03060102, 0x03010602, /* 284 */
|
||||
0x03060001, 0x03000601, 0xFF000004, 0x04030502, 0x04040402, /* 289 */
|
||||
0x03050202, 0x03050202, 0x03020502, 0x03020502, 0x03050001, /* 294 */
|
||||
0x03050001, 0x02050102, 0x02050102, 0x02050102, 0x02050102, /* 299 */
|
||||
0x02010502, 0x02010502, 0x02010502, 0x02010502, 0xFF000003, /* 304 */
|
||||
0x03040302, 0x03030402, 0x03000501, 0x03040202, 0x03020402, /* 309 */
|
||||
0x03030302, 0x02040102, 0x02040102, 0xFF000002, 0x01010402, /* 314 */
|
||||
0x01010402, 0x02040001, 0x02000401, 0xFF000002, 0x02030202, /* 319 */
|
||||
0x02020302, 0x01030102, 0x01030102, 0xFF000001, 0x01010302, /* 324 */
|
||||
0x01030001, 0xFF000001, 0x01000301, 0x01020202, 0xFF000003, /* 329 */
|
||||
0x00000082, 0x0000008B, 0x0000008E, 0x00000091, 0x00000094, /* 334 */
|
||||
0x00000097, 0x030C0E02, 0x030D0D02, 0xFF000003, 0x00000093, /* 339 */
|
||||
0x030E0B02, 0x030B0E02, 0x030F0902, 0x03090F02, 0x030A0E02, /* 344 */
|
||||
0x030D0B02, 0x030B0D02, 0xFF000003, 0x030F0802, 0x03080F02, /* 349 */
|
||||
0x030C0C02, 0x0000008D, 0x030E0802, 0x00000090, 0x02070F02, /* 354 */
|
||||
0x02070F02, 0xFF000003, 0x020A0D02, 0x020A0D02, 0x030D0A02, /* 359 */
|
||||
0x030C0B02, 0x030B0C02, 0x03060F02, 0x020F0602, 0x020F0602, /* 364 */
|
||||
0xFF000002, 0x02080E02, 0x020F0502, 0x020D0902, 0x02090D02, /* 369 */
|
||||
0xFF000002, 0x02050F02, 0x02070E02, 0x020C0A02, 0x020B0B02, /* 374 */
|
||||
0xFF000003, 0x020F0402, 0x020F0402, 0x02040F02, 0x02040F02, /* 379 */
|
||||
0x030A0C02, 0x03060E02, 0x02030F02, 0x02030F02, 0xFF000002, /* 384 */
|
||||
0x010F0302, 0x010F0302, 0x020D0802, 0x02080D02, 0xFF000001, /* 389 */
|
||||
0x010F0202, 0x01020F02, 0xFF000002, 0x020E0602, 0x020C0902, /* 394 */
|
||||
0x010F0001, 0x010F0001, 0xFF000002, 0x02090C02, 0x020E0502, /* 399 */
|
||||
0x010B0A02, 0x010B0A02, 0xFF000002, 0x020D0702, 0x02070D02, /* 404 */
|
||||
0x010E0402, 0x010E0402, 0xFF000002, 0x02080C02, 0x02060D02, /* 409 */
|
||||
0x010E0302, 0x010E0302, 0xFF000002, 0x01090B02, 0x01090B02, /* 414 */
|
||||
0x020B0902, 0x020A0A02, 0xFF000001, 0x010A0B02, 0x01050E02, /* 419 */
|
||||
0xFF000001, 0x01040E02, 0x010C0802, 0xFF000001, 0x010D0602, /* 424 */
|
||||
0x01030E02, 0xFF000001, 0x010E0202, 0x010E0001, 0xFF000001, /* 429 */
|
||||
0x01000E01, 0x010D0502, 0xFF000001, 0x01050D02, 0x010C0702, /* 434 */
|
||||
0xFF000001, 0x01070C02, 0x010D0402, 0xFF000001, 0x010B0802, /* 439 */
|
||||
0x01080B02, 0xFF000001, 0x01040D02, 0x010A0902, 0xFF000001, /* 444 */
|
||||
0x01090A02, 0x010C0602, 0xFF000001, 0x01030D02, 0x010B0702, /* 449 */
|
||||
0xFF000001, 0x010C0502, 0x01050C02, 0xFF000001, 0x01090902, /* 454 */
|
||||
0x010A0702, 0xFF000001, 0x01070A02, 0x01070902, 0xFF000003, /* 459 */
|
||||
0x00000023, 0x030D0F02, 0x020D0E02, 0x020D0E02, 0x010F0F02, /* 464 */
|
||||
0x010F0F02, 0x010F0F02, 0x010F0F02, 0xFF000001, 0x010F0E02, /* 469 */
|
||||
0x010F0D02, 0xFF000001, 0x010E0E02, 0x010F0C02, 0xFF000001, /* 474 */
|
||||
0x010E0D02, 0x010F0B02, 0xFF000001, 0x010B0F02, 0x010E0C02, /* 479 */
|
||||
0xFF000002, 0x010C0D02, 0x010C0D02, 0x020F0A02, 0x02090E02, /* 484 */
|
||||
0xFF000001, 0x010A0F02, 0x010D0C02, 0xFF000001, 0x010E0A02, /* 489 */
|
||||
0x010E0902, 0xFF000001, 0x010F0702, 0x010E0702, 0xFF000001, /* 494 */
|
||||
0x010E0F02, 0x010C0F02,};
|
||||
|
||||
/* max table bits 6 */
|
||||
/* NO XING TABLE 14 */
|
||||
|
||||
/* TABLE 15 256 entries maxbits 13 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_15[] =
|
||||
{
|
||||
0xFF000008, 0x00000101, 0x00000122, 0x00000143, 0x00000154, /* 4 */
|
||||
0x00000165, 0x00000176, 0x0000017F, 0x00000188, 0x00000199, /* 9 */
|
||||
0x000001A2, 0x000001AB, 0x000001B4, 0x000001BD, 0x000001C2, /* 14 */
|
||||
0x000001CB, 0x000001D4, 0x000001D9, 0x000001DE, 0x000001E3, /* 19 */
|
||||
0x000001E8, 0x000001ED, 0x000001F2, 0x000001F7, 0x000001FC, /* 24 */
|
||||
0x00000201, 0x00000204, 0x00000207, 0x0000020A, 0x0000020F, /* 29 */
|
||||
0x00000212, 0x00000215, 0x0000021A, 0x0000021D, 0x00000220, /* 34 */
|
||||
0x08010902, 0x00000223, 0x00000226, 0x00000229, 0x0000022C, /* 39 */
|
||||
0x0000022F, 0x08080202, 0x08020802, 0x08080102, 0x08010802, /* 44 */
|
||||
0x00000232, 0x00000235, 0x00000238, 0x0000023B, 0x08070202, /* 49 */
|
||||
0x08020702, 0x08040602, 0x08070102, 0x08050502, 0x08010702, /* 54 */
|
||||
0x0000023E, 0x08060302, 0x08030602, 0x08050402, 0x08040502, /* 59 */
|
||||
0x08060202, 0x08020602, 0x08060102, 0x00000241, 0x08050302, /* 64 */
|
||||
0x07010602, 0x07010602, 0x08030502, 0x08040402, 0x07050202, /* 69 */
|
||||
0x07050202, 0x07020502, 0x07020502, 0x07050102, 0x07050102, /* 74 */
|
||||
0x07010502, 0x07010502, 0x08050001, 0x08000501, 0x07040302, /* 79 */
|
||||
0x07040302, 0x07030402, 0x07030402, 0x07040202, 0x07040202, /* 84 */
|
||||
0x07020402, 0x07020402, 0x07030302, 0x07030302, 0x06010402, /* 89 */
|
||||
0x06010402, 0x06010402, 0x06010402, 0x07040102, 0x07040102, /* 94 */
|
||||
0x07040001, 0x07040001, 0x06030202, 0x06030202, 0x06030202, /* 99 */
|
||||
0x06030202, 0x06020302, 0x06020302, 0x06020302, 0x06020302, /* 104 */
|
||||
0x07000401, 0x07000401, 0x07030001, 0x07030001, 0x06030102, /* 109 */
|
||||
0x06030102, 0x06030102, 0x06030102, 0x06010302, 0x06010302, /* 114 */
|
||||
0x06010302, 0x06010302, 0x06000301, 0x06000301, 0x06000301, /* 119 */
|
||||
0x06000301, 0x05020202, 0x05020202, 0x05020202, 0x05020202, /* 124 */
|
||||
0x05020202, 0x05020202, 0x05020202, 0x05020202, 0x05020102, /* 129 */
|
||||
0x05020102, 0x05020102, 0x05020102, 0x05020102, 0x05020102, /* 134 */
|
||||
0x05020102, 0x05020102, 0x05010202, 0x05010202, 0x05010202, /* 139 */
|
||||
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 144 */
|
||||
0x05020001, 0x05020001, 0x05020001, 0x05020001, 0x05020001, /* 149 */
|
||||
0x05020001, 0x05020001, 0x05020001, 0x05000201, 0x05000201, /* 154 */
|
||||
0x05000201, 0x05000201, 0x05000201, 0x05000201, 0x05000201, /* 159 */
|
||||
0x05000201, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 164 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 169 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 174 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 179 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 184 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 189 */
|
||||
0x03010102, 0x03010102, 0x03010102, 0x04010001, 0x04010001, /* 194 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 199 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 204 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04000101, /* 209 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 214 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 219 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 224 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 229 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 234 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 239 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 244 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 249 */
|
||||
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 254 */
|
||||
0x03000000, 0x03000000, 0xFF000005, 0x050F0F02, 0x050F0E02, /* 259 */
|
||||
0x050E0F02, 0x050F0D02, 0x040E0E02, 0x040E0E02, 0x050D0F02, /* 264 */
|
||||
0x050F0C02, 0x050C0F02, 0x050E0D02, 0x050D0E02, 0x050F0B02, /* 269 */
|
||||
0x040B0F02, 0x040B0F02, 0x050E0C02, 0x050C0E02, 0x040D0D02, /* 274 */
|
||||
0x040D0D02, 0x040F0A02, 0x040F0A02, 0x040A0F02, 0x040A0F02, /* 279 */
|
||||
0x040E0B02, 0x040E0B02, 0x040B0E02, 0x040B0E02, 0x040D0C02, /* 284 */
|
||||
0x040D0C02, 0x040C0D02, 0x040C0D02, 0x040F0902, 0x040F0902, /* 289 */
|
||||
0xFF000005, 0x04090F02, 0x04090F02, 0x040A0E02, 0x040A0E02, /* 294 */
|
||||
0x040D0B02, 0x040D0B02, 0x040B0D02, 0x040B0D02, 0x040F0802, /* 299 */
|
||||
0x040F0802, 0x04080F02, 0x04080F02, 0x040C0C02, 0x040C0C02, /* 304 */
|
||||
0x040E0902, 0x040E0902, 0x04090E02, 0x04090E02, 0x040F0702, /* 309 */
|
||||
0x040F0702, 0x04070F02, 0x04070F02, 0x040D0A02, 0x040D0A02, /* 314 */
|
||||
0x040A0D02, 0x040A0D02, 0x040C0B02, 0x040C0B02, 0x040F0602, /* 319 */
|
||||
0x040F0602, 0x050E0A02, 0x050F0001, 0xFF000004, 0x030B0C02, /* 324 */
|
||||
0x030B0C02, 0x03060F02, 0x03060F02, 0x040E0802, 0x04080E02, /* 329 */
|
||||
0x040F0502, 0x040D0902, 0x03050F02, 0x03050F02, 0x030E0702, /* 334 */
|
||||
0x030E0702, 0x03070E02, 0x03070E02, 0x030C0A02, 0x030C0A02, /* 339 */
|
||||
0xFF000004, 0x030A0C02, 0x030A0C02, 0x030B0B02, 0x030B0B02, /* 344 */
|
||||
0x04090D02, 0x040D0802, 0x030F0402, 0x030F0402, 0x03040F02, /* 349 */
|
||||
0x03040F02, 0x030F0302, 0x030F0302, 0x03030F02, 0x03030F02, /* 354 */
|
||||
0x03080D02, 0x03080D02, 0xFF000004, 0x03060E02, 0x03060E02, /* 359 */
|
||||
0x030F0202, 0x030F0202, 0x03020F02, 0x03020F02, 0x040E0602, /* 364 */
|
||||
0x04000F01, 0x030F0102, 0x030F0102, 0x03010F02, 0x03010F02, /* 369 */
|
||||
0x030C0902, 0x030C0902, 0x03090C02, 0x03090C02, 0xFF000003, /* 374 */
|
||||
0x030E0502, 0x030B0A02, 0x030A0B02, 0x03050E02, 0x030D0702, /* 379 */
|
||||
0x03070D02, 0x030E0402, 0x03040E02, 0xFF000003, 0x030C0802, /* 384 */
|
||||
0x03080C02, 0x030E0302, 0x030D0602, 0x03060D02, 0x03030E02, /* 389 */
|
||||
0x030B0902, 0x03090B02, 0xFF000004, 0x030E0202, 0x030E0202, /* 394 */
|
||||
0x030A0A02, 0x030A0A02, 0x03020E02, 0x03020E02, 0x030E0102, /* 399 */
|
||||
0x030E0102, 0x03010E02, 0x03010E02, 0x040E0001, 0x04000E01, /* 404 */
|
||||
0x030D0502, 0x030D0502, 0x03050D02, 0x03050D02, 0xFF000003, /* 409 */
|
||||
0x030C0702, 0x03070C02, 0x030D0402, 0x030B0802, 0x02040D02, /* 414 */
|
||||
0x02040D02, 0x03080B02, 0x030A0902, 0xFF000003, 0x03090A02, /* 419 */
|
||||
0x030C0602, 0x03060C02, 0x030D0302, 0x02030D02, 0x02030D02, /* 424 */
|
||||
0x02020D02, 0x02020D02, 0xFF000003, 0x030D0202, 0x030D0001, /* 429 */
|
||||
0x020D0102, 0x020D0102, 0x020B0702, 0x020B0702, 0x02070B02, /* 434 */
|
||||
0x02070B02, 0xFF000003, 0x02010D02, 0x02010D02, 0x030C0502, /* 439 */
|
||||
0x03000D01, 0x02050C02, 0x02050C02, 0x020A0802, 0x020A0802, /* 444 */
|
||||
0xFF000002, 0x02080A02, 0x020C0402, 0x02040C02, 0x020B0602, /* 449 */
|
||||
0xFF000003, 0x02060B02, 0x02060B02, 0x03090902, 0x030C0001, /* 454 */
|
||||
0x020C0302, 0x020C0302, 0x02030C02, 0x02030C02, 0xFF000003, /* 459 */
|
||||
0x020A0702, 0x020A0702, 0x02070A02, 0x02070A02, 0x02060A02, /* 464 */
|
||||
0x02060A02, 0x03000C01, 0x030B0001, 0xFF000002, 0x01020C02, /* 469 */
|
||||
0x01020C02, 0x020C0202, 0x020B0502, 0xFF000002, 0x02050B02, /* 474 */
|
||||
0x020C0102, 0x02090802, 0x02080902, 0xFF000002, 0x02010C02, /* 479 */
|
||||
0x020B0402, 0x02040B02, 0x020A0602, 0xFF000002, 0x020B0302, /* 484 */
|
||||
0x02090702, 0x01030B02, 0x01030B02, 0xFF000002, 0x02070902, /* 489 */
|
||||
0x02080802, 0x020B0202, 0x020A0502, 0xFF000002, 0x01020B02, /* 494 */
|
||||
0x01020B02, 0x02050A02, 0x020B0102, 0xFF000002, 0x01010B02, /* 499 */
|
||||
0x01010B02, 0x02000B01, 0x02090602, 0xFF000002, 0x02060902, /* 504 */
|
||||
0x020A0402, 0x02040A02, 0x02080702, 0xFF000002, 0x02070802, /* 509 */
|
||||
0x020A0302, 0x01030A02, 0x01030A02, 0xFF000001, 0x01090502, /* 514 */
|
||||
0x01050902, 0xFF000001, 0x010A0202, 0x01020A02, 0xFF000001, /* 519 */
|
||||
0x010A0102, 0x01010A02, 0xFF000002, 0x020A0001, 0x02000A01, /* 524 */
|
||||
0x01080602, 0x01080602, 0xFF000001, 0x01060802, 0x01090402, /* 529 */
|
||||
0xFF000001, 0x01040902, 0x01090302, 0xFF000002, 0x01030902, /* 534 */
|
||||
0x01030902, 0x02070702, 0x02090001, 0xFF000001, 0x01080502, /* 539 */
|
||||
0x01050802, 0xFF000001, 0x01090202, 0x01070602, 0xFF000001, /* 544 */
|
||||
0x01060702, 0x01020902, 0xFF000001, 0x01090102, 0x01000901, /* 549 */
|
||||
0xFF000001, 0x01080402, 0x01040802, 0xFF000001, 0x01070502, /* 554 */
|
||||
0x01050702, 0xFF000001, 0x01080302, 0x01030802, 0xFF000001, /* 559 */
|
||||
0x01060602, 0x01070402, 0xFF000001, 0x01040702, 0x01080001, /* 564 */
|
||||
0xFF000001, 0x01000801, 0x01060502, 0xFF000001, 0x01050602, /* 569 */
|
||||
0x01070302, 0xFF000001, 0x01030702, 0x01060402, 0xFF000001, /* 574 */
|
||||
0x01070001, 0x01000701, 0xFF000001, 0x01060001, 0x01000601, /* 579 */ };
|
||||
|
||||
/* max table bits 8 */
|
||||
|
||||
/* TABLE 16 256 entries maxbits 17 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_16[] =
|
||||
{
|
||||
0xFF000008, 0x00000101, 0x0000010A, 0x00000113, 0x080F0F02, /* 4 */
|
||||
0x00000118, 0x0000011D, 0x00000120, 0x08020F02, 0x00000131, /* 9 */
|
||||
0x080F0102, 0x08010F02, 0x00000134, 0x00000145, 0x00000156, /* 14 */
|
||||
0x00000167, 0x00000178, 0x00000189, 0x0000019A, 0x000001A3, /* 19 */
|
||||
0x000001AC, 0x000001B5, 0x000001BE, 0x000001C7, 0x000001D0, /* 24 */
|
||||
0x000001D9, 0x000001DE, 0x000001E3, 0x000001E6, 0x000001EB, /* 29 */
|
||||
0x000001F0, 0x08010502, 0x000001F3, 0x000001F6, 0x000001F9, /* 34 */
|
||||
0x000001FC, 0x08040102, 0x08010402, 0x000001FF, 0x08030202, /* 39 */
|
||||
0x08020302, 0x07030102, 0x07030102, 0x07010302, 0x07010302, /* 44 */
|
||||
0x08030001, 0x08000301, 0x07020202, 0x07020202, 0x06020102, /* 49 */
|
||||
0x06020102, 0x06020102, 0x06020102, 0x06010202, 0x06010202, /* 54 */
|
||||
0x06010202, 0x06010202, 0x06020001, 0x06020001, 0x06020001, /* 59 */
|
||||
0x06020001, 0x06000201, 0x06000201, 0x06000201, 0x06000201, /* 64 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 69 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 74 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 79 */
|
||||
0x04010102, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 84 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 89 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 94 */
|
||||
0x04010001, 0x04010001, 0x03000101, 0x03000101, 0x03000101, /* 99 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 114 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
|
||||
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x01000000, /* 129 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 134 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 139 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 144 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 149 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 154 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 159 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 164 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 169 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 174 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 179 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 184 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 189 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 194 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 199 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 204 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 209 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 214 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 219 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 224 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 229 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 234 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 239 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 244 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 249 */
|
||||
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 254 */
|
||||
0x01000000, 0x01000000, 0xFF000003, 0x030F0E02, 0x030E0F02, /* 259 */
|
||||
0x030F0D02, 0x030D0F02, 0x030F0C02, 0x030C0F02, 0x030F0B02, /* 264 */
|
||||
0x030B0F02, 0xFF000003, 0x020F0A02, 0x020F0A02, 0x030A0F02, /* 269 */
|
||||
0x030F0902, 0x03090F02, 0x03080F02, 0x020F0802, 0x020F0802, /* 274 */
|
||||
0xFF000002, 0x020F0702, 0x02070F02, 0x020F0602, 0x02060F02, /* 279 */
|
||||
0xFF000002, 0x020F0502, 0x02050F02, 0x010F0402, 0x010F0402, /* 284 */
|
||||
0xFF000001, 0x01040F02, 0x01030F02, 0xFF000004, 0x01000F01, /* 289 */
|
||||
0x01000F01, 0x01000F01, 0x01000F01, 0x01000F01, 0x01000F01, /* 294 */
|
||||
0x01000F01, 0x01000F01, 0x020F0302, 0x020F0302, 0x020F0302, /* 299 */
|
||||
0x020F0302, 0x000000E2, 0x000000F3, 0x000000FC, 0x00000105, /* 304 */
|
||||
0xFF000001, 0x010F0202, 0x010F0001, 0xFF000004, 0x000000FA, /* 309 */
|
||||
0x000000FF, 0x00000104, 0x00000109, 0x0000010C, 0x00000111, /* 314 */
|
||||
0x00000116, 0x00000119, 0x0000011E, 0x00000123, 0x00000128, /* 319 */
|
||||
0x04030E02, 0x0000012D, 0x00000130, 0x00000133, 0x00000136, /* 324 */
|
||||
0xFF000004, 0x00000128, 0x0000012B, 0x0000012E, 0x040D0001, /* 329 */
|
||||
0x00000131, 0x00000134, 0x00000137, 0x040C0302, 0x0000013A, /* 334 */
|
||||
0x040C0102, 0x04000C01, 0x0000013D, 0x03020E02, 0x03020E02, /* 339 */
|
||||
0x040E0202, 0x040E0102, 0xFF000004, 0x04030D02, 0x040D0202, /* 344 */
|
||||
0x04020D02, 0x04010D02, 0x040B0302, 0x0000012F, 0x030D0102, /* 349 */
|
||||
0x030D0102, 0x04040C02, 0x040B0602, 0x04030C02, 0x04070A02, /* 354 */
|
||||
0x030C0202, 0x030C0202, 0x04020C02, 0x04050B02, 0xFF000004, /* 359 */
|
||||
0x04010C02, 0x040C0001, 0x040B0402, 0x04040B02, 0x040A0602, /* 364 */
|
||||
0x04060A02, 0x03030B02, 0x03030B02, 0x040A0502, 0x04050A02, /* 369 */
|
||||
0x030B0202, 0x030B0202, 0x03020B02, 0x03020B02, 0x030B0102, /* 374 */
|
||||
0x030B0102, 0xFF000004, 0x03010B02, 0x03010B02, 0x040B0001, /* 379 */
|
||||
0x04000B01, 0x04090602, 0x04060902, 0x040A0402, 0x04040A02, /* 384 */
|
||||
0x04080702, 0x04070802, 0x03030A02, 0x03030A02, 0x040A0302, /* 389 */
|
||||
0x04090502, 0x030A0202, 0x030A0202, 0xFF000004, 0x04050902, /* 394 */
|
||||
0x04080602, 0x03010A02, 0x03010A02, 0x04060802, 0x04070702, /* 399 */
|
||||
0x03040902, 0x03040902, 0x04090402, 0x04070502, 0x03070602, /* 404 */
|
||||
0x03070602, 0x02020A02, 0x02020A02, 0x02020A02, 0x02020A02, /* 409 */
|
||||
0xFF000003, 0x020A0102, 0x020A0102, 0x030A0001, 0x03000A01, /* 414 */
|
||||
0x03090302, 0x03030902, 0x03080502, 0x03050802, 0xFF000003, /* 419 */
|
||||
0x02090202, 0x02090202, 0x02020902, 0x02020902, 0x03060702, /* 424 */
|
||||
0x03090001, 0x02090102, 0x02090102, 0xFF000003, 0x02010902, /* 429 */
|
||||
0x02010902, 0x03000901, 0x03080402, 0x03040802, 0x03050702, /* 434 */
|
||||
0x03080302, 0x03030802, 0xFF000003, 0x03060602, 0x03080202, /* 439 */
|
||||
0x02020802, 0x02020802, 0x03070402, 0x03040702, 0x02080102, /* 444 */
|
||||
0x02080102, 0xFF000003, 0x02010802, 0x02010802, 0x02000801, /* 449 */
|
||||
0x02000801, 0x03080001, 0x03060502, 0x02070302, 0x02070302, /* 454 */
|
||||
0xFF000003, 0x02030702, 0x02030702, 0x03050602, 0x03060402, /* 459 */
|
||||
0x02070202, 0x02070202, 0x02020702, 0x02020702, 0xFF000003, /* 464 */
|
||||
0x03040602, 0x03050502, 0x02070001, 0x02070001, 0x01070102, /* 469 */
|
||||
0x01070102, 0x01070102, 0x01070102, 0xFF000002, 0x01010702, /* 474 */
|
||||
0x01010702, 0x02000701, 0x02060302, 0xFF000002, 0x02030602, /* 479 */
|
||||
0x02050402, 0x02040502, 0x02060202, 0xFF000001, 0x01020602, /* 484 */
|
||||
0x01060102, 0xFF000002, 0x01010602, 0x01010602, 0x02060001, /* 489 */
|
||||
0x02000601, 0xFF000002, 0x01030502, 0x01030502, 0x02050302, /* 494 */
|
||||
0x02040402, 0xFF000001, 0x01050202, 0x01020502, 0xFF000001, /* 499 */
|
||||
0x01050102, 0x01050001, 0xFF000001, 0x01040302, 0x01030402, /* 504 */
|
||||
0xFF000001, 0x01000501, 0x01040202, 0xFF000001, 0x01020402, /* 509 */
|
||||
0x01030302, 0xFF000001, 0x01040001, 0x01000401, 0xFF000004, /* 514 */
|
||||
0x040E0C02, 0x00000086, 0x030E0D02, 0x030E0D02, 0x03090E02, /* 519 */
|
||||
0x03090E02, 0x040A0E02, 0x04090D02, 0x020E0E02, 0x020E0E02, /* 524 */
|
||||
0x020E0E02, 0x020E0E02, 0x030D0E02, 0x030D0E02, 0x030B0E02, /* 529 */
|
||||
0x030B0E02, 0xFF000003, 0x020E0B02, 0x020E0B02, 0x020D0C02, /* 534 */
|
||||
0x020D0C02, 0x030C0D02, 0x030B0D02, 0x020E0A02, 0x020E0A02, /* 539 */
|
||||
0xFF000003, 0x020C0C02, 0x020C0C02, 0x030D0A02, 0x030A0D02, /* 544 */
|
||||
0x030E0702, 0x030C0A02, 0x020A0C02, 0x020A0C02, 0xFF000003, /* 549 */
|
||||
0x03090C02, 0x030D0702, 0x020E0502, 0x020E0502, 0x010D0B02, /* 554 */
|
||||
0x010D0B02, 0x010D0B02, 0x010D0B02, 0xFF000002, 0x010E0902, /* 559 */
|
||||
0x010E0902, 0x020C0B02, 0x020B0C02, 0xFF000002, 0x020E0802, /* 564 */
|
||||
0x02080E02, 0x020D0902, 0x02070E02, 0xFF000002, 0x020B0B02, /* 569 */
|
||||
0x020D0802, 0x02080D02, 0x020E0602, 0xFF000001, 0x01060E02, /* 574 */
|
||||
0x010C0902, 0xFF000002, 0x020B0A02, 0x020A0B02, 0x02050E02, /* 579 */
|
||||
0x02070D02, 0xFF000002, 0x010E0402, 0x010E0402, 0x02040E02, /* 584 */
|
||||
0x020C0802, 0xFF000001, 0x01080C02, 0x010E0302, 0xFF000002, /* 589 */
|
||||
0x010D0602, 0x010D0602, 0x02060D02, 0x020B0902, 0xFF000002, /* 594 */
|
||||
0x02090B02, 0x020A0A02, 0x01010E02, 0x01010E02, 0xFF000002, /* 599 */
|
||||
0x01040D02, 0x01040D02, 0x02080B02, 0x02090A02, 0xFF000002, /* 604 */
|
||||
0x010B0702, 0x010B0702, 0x02070B02, 0x02000D01, 0xFF000001, /* 609 */
|
||||
0x010E0001, 0x01000E01, 0xFF000001, 0x010D0502, 0x01050D02, /* 614 */
|
||||
0xFF000001, 0x010C0702, 0x01070C02, 0xFF000001, 0x010D0402, /* 619 */
|
||||
0x010B0802, 0xFF000001, 0x010A0902, 0x010C0602, 0xFF000001, /* 624 */
|
||||
0x01060C02, 0x010D0302, 0xFF000001, 0x010C0502, 0x01050C02, /* 629 */
|
||||
0xFF000001, 0x010A0802, 0x01080A02, 0xFF000001, 0x01090902, /* 634 */
|
||||
0x010C0402, 0xFF000001, 0x01060B02, 0x010A0702, 0xFF000001, /* 639 */
|
||||
0x010B0502, 0x01090802, 0xFF000001, 0x01080902, 0x01090702, /* 644 */
|
||||
0xFF000001, 0x01070902, 0x01080802, 0xFF000001, 0x010C0E02, /* 649 */
|
||||
0x010D0D02,};
|
||||
|
||||
/* max table bits 8 */
|
||||
/* NO XING TABLE 17 */
|
||||
/* NO XING TABLE 18 */
|
||||
/* NO XING TABLE 19 */
|
||||
/* NO XING TABLE 20 */
|
||||
/* NO XING TABLE 21 */
|
||||
/* NO XING TABLE 22 */
|
||||
/* NO XING TABLE 23 */
|
||||
|
||||
/* TABLE 24 256 entries maxbits 12 linbits 0 */
|
||||
static HUFF_ELEMENT huff_table_24[] =
|
||||
{
|
||||
0xFF000009, 0x080F0E02, 0x080F0E02, 0x080E0F02, 0x080E0F02, /* 4 */
|
||||
0x080F0D02, 0x080F0D02, 0x080D0F02, 0x080D0F02, 0x080F0C02, /* 9 */
|
||||
0x080F0C02, 0x080C0F02, 0x080C0F02, 0x080F0B02, 0x080F0B02, /* 14 */
|
||||
0x080B0F02, 0x080B0F02, 0x070A0F02, 0x070A0F02, 0x070A0F02, /* 19 */
|
||||
0x070A0F02, 0x080F0A02, 0x080F0A02, 0x080F0902, 0x080F0902, /* 24 */
|
||||
0x07090F02, 0x07090F02, 0x07090F02, 0x07090F02, 0x07080F02, /* 29 */
|
||||
0x07080F02, 0x07080F02, 0x07080F02, 0x080F0802, 0x080F0802, /* 34 */
|
||||
0x080F0702, 0x080F0702, 0x07070F02, 0x07070F02, 0x07070F02, /* 39 */
|
||||
0x07070F02, 0x070F0602, 0x070F0602, 0x070F0602, 0x070F0602, /* 44 */
|
||||
0x07060F02, 0x07060F02, 0x07060F02, 0x07060F02, 0x070F0502, /* 49 */
|
||||
0x070F0502, 0x070F0502, 0x070F0502, 0x07050F02, 0x07050F02, /* 54 */
|
||||
0x07050F02, 0x07050F02, 0x070F0402, 0x070F0402, 0x070F0402, /* 59 */
|
||||
0x070F0402, 0x07040F02, 0x07040F02, 0x07040F02, 0x07040F02, /* 64 */
|
||||
0x070F0302, 0x070F0302, 0x070F0302, 0x070F0302, 0x07030F02, /* 69 */
|
||||
0x07030F02, 0x07030F02, 0x07030F02, 0x070F0202, 0x070F0202, /* 74 */
|
||||
0x070F0202, 0x070F0202, 0x07020F02, 0x07020F02, 0x07020F02, /* 79 */
|
||||
0x07020F02, 0x07010F02, 0x07010F02, 0x07010F02, 0x07010F02, /* 84 */
|
||||
0x080F0102, 0x080F0102, 0x08000F01, 0x08000F01, 0x090F0001, /* 89 */
|
||||
0x00000201, 0x00000206, 0x0000020B, 0x00000210, 0x00000215, /* 94 */
|
||||
0x0000021A, 0x0000021F, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 99 */
|
||||
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 104 */
|
||||
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 109 */
|
||||
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 114 */
|
||||
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 119 */
|
||||
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 124 */
|
||||
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x00000224, /* 129 */
|
||||
0x00000229, 0x00000232, 0x00000237, 0x0000023A, 0x0000023F, /* 134 */
|
||||
0x00000242, 0x00000245, 0x0000024A, 0x0000024D, 0x00000250, /* 139 */
|
||||
0x00000253, 0x00000256, 0x00000259, 0x0000025C, 0x0000025F, /* 144 */
|
||||
0x00000262, 0x00000265, 0x00000268, 0x0000026B, 0x0000026E, /* 149 */
|
||||
0x00000271, 0x00000274, 0x00000277, 0x0000027A, 0x0000027D, /* 154 */
|
||||
0x00000280, 0x00000283, 0x00000288, 0x0000028B, 0x0000028E, /* 159 */
|
||||
0x00000291, 0x00000294, 0x00000297, 0x0000029A, 0x0000029F, /* 164 */
|
||||
0x09040B02, 0x000002A4, 0x000002A7, 0x000002AA, 0x09030B02, /* 169 */
|
||||
0x09080802, 0x000002AF, 0x09020B02, 0x000002B2, 0x000002B5, /* 174 */
|
||||
0x09060902, 0x09040A02, 0x000002B8, 0x09070802, 0x090A0302, /* 179 */
|
||||
0x09030A02, 0x09090502, 0x09050902, 0x090A0202, 0x09020A02, /* 184 */
|
||||
0x09010A02, 0x09080602, 0x09060802, 0x09070702, 0x09090402, /* 189 */
|
||||
0x09040902, 0x09090302, 0x09030902, 0x09080502, 0x09050802, /* 194 */
|
||||
0x09090202, 0x09070602, 0x09060702, 0x09020902, 0x09090102, /* 199 */
|
||||
0x09010902, 0x09080402, 0x09040802, 0x09070502, 0x09050702, /* 204 */
|
||||
0x09080302, 0x09030802, 0x09060602, 0x09080202, 0x09020802, /* 209 */
|
||||
0x09080102, 0x09070402, 0x09040702, 0x09010802, 0x000002BB, /* 214 */
|
||||
0x09060502, 0x09050602, 0x09070102, 0x000002BE, 0x08030702, /* 219 */
|
||||
0x08030702, 0x09070302, 0x09070202, 0x08020702, 0x08020702, /* 224 */
|
||||
0x08060402, 0x08060402, 0x08040602, 0x08040602, 0x08050502, /* 229 */
|
||||
0x08050502, 0x08010702, 0x08010702, 0x08060302, 0x08060302, /* 234 */
|
||||
0x08030602, 0x08030602, 0x08050402, 0x08050402, 0x08040502, /* 239 */
|
||||
0x08040502, 0x08060202, 0x08060202, 0x08020602, 0x08020602, /* 244 */
|
||||
0x08060102, 0x08060102, 0x08010602, 0x08010602, 0x09060001, /* 249 */
|
||||
0x09000601, 0x08050302, 0x08050302, 0x08030502, 0x08030502, /* 254 */
|
||||
0x08040402, 0x08040402, 0x08050202, 0x08050202, 0x08020502, /* 259 */
|
||||
0x08020502, 0x08050102, 0x08050102, 0x09050001, 0x09000501, /* 264 */
|
||||
0x07010502, 0x07010502, 0x07010502, 0x07010502, 0x08040302, /* 269 */
|
||||
0x08040302, 0x08030402, 0x08030402, 0x07040202, 0x07040202, /* 274 */
|
||||
0x07040202, 0x07040202, 0x07020402, 0x07020402, 0x07020402, /* 279 */
|
||||
0x07020402, 0x07030302, 0x07030302, 0x07030302, 0x07030302, /* 284 */
|
||||
0x07040102, 0x07040102, 0x07040102, 0x07040102, 0x07010402, /* 289 */
|
||||
0x07010402, 0x07010402, 0x07010402, 0x08040001, 0x08040001, /* 294 */
|
||||
0x08000401, 0x08000401, 0x07030202, 0x07030202, 0x07030202, /* 299 */
|
||||
0x07030202, 0x07020302, 0x07020302, 0x07020302, 0x07020302, /* 304 */
|
||||
0x06030102, 0x06030102, 0x06030102, 0x06030102, 0x06030102, /* 309 */
|
||||
0x06030102, 0x06030102, 0x06030102, 0x06010302, 0x06010302, /* 314 */
|
||||
0x06010302, 0x06010302, 0x06010302, 0x06010302, 0x06010302, /* 319 */
|
||||
0x06010302, 0x07030001, 0x07030001, 0x07030001, 0x07030001, /* 324 */
|
||||
0x07000301, 0x07000301, 0x07000301, 0x07000301, 0x06020202, /* 329 */
|
||||
0x06020202, 0x06020202, 0x06020202, 0x06020202, 0x06020202, /* 334 */
|
||||
0x06020202, 0x06020202, 0x05020102, 0x05020102, 0x05020102, /* 339 */
|
||||
0x05020102, 0x05020102, 0x05020102, 0x05020102, 0x05020102, /* 344 */
|
||||
0x05020102, 0x05020102, 0x05020102, 0x05020102, 0x05020102, /* 349 */
|
||||
0x05020102, 0x05020102, 0x05020102, 0x05010202, 0x05010202, /* 354 */
|
||||
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 359 */
|
||||
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 364 */
|
||||
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x06020001, /* 369 */
|
||||
0x06020001, 0x06020001, 0x06020001, 0x06020001, 0x06020001, /* 374 */
|
||||
0x06020001, 0x06020001, 0x06000201, 0x06000201, 0x06000201, /* 379 */
|
||||
0x06000201, 0x06000201, 0x06000201, 0x06000201, 0x06000201, /* 384 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 389 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 394 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 399 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 404 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 409 */
|
||||
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 414 */
|
||||
0x04010102, 0x04010102, 0x04010001, 0x04010001, 0x04010001, /* 419 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 424 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 429 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 434 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 439 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 444 */
|
||||
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04000101, /* 449 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 454 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 459 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 464 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 469 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 474 */
|
||||
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 479 */
|
||||
0x04000101, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 484 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 489 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 494 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 499 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 504 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 509 */
|
||||
0x04000000, 0x04000000, 0x04000000, 0xFF000002, 0x020E0E02, /* 514 */
|
||||
0x020E0D02, 0x020D0E02, 0x020E0C02, 0xFF000002, 0x020C0E02, /* 519 */
|
||||
0x020D0D02, 0x020E0B02, 0x020B0E02, 0xFF000002, 0x020D0C02, /* 524 */
|
||||
0x020C0D02, 0x020E0A02, 0x020A0E02, 0xFF000002, 0x020D0B02, /* 529 */
|
||||
0x020B0D02, 0x020C0C02, 0x020E0902, 0xFF000002, 0x02090E02, /* 534 */
|
||||
0x020D0A02, 0x020A0D02, 0x020C0B02, 0xFF000002, 0x020B0C02, /* 539 */
|
||||
0x020E0802, 0x02080E02, 0x020D0902, 0xFF000002, 0x02090D02, /* 544 */
|
||||
0x020E0702, 0x02070E02, 0x020C0A02, 0xFF000002, 0x020A0C02, /* 549 */
|
||||
0x020B0B02, 0x020D0802, 0x02080D02, 0xFF000003, 0x030E0001, /* 554 */
|
||||
0x03000E01, 0x020D0001, 0x020D0001, 0x01060E02, 0x01060E02, /* 559 */
|
||||
0x01060E02, 0x01060E02, 0xFF000002, 0x020E0602, 0x020C0902, /* 564 */
|
||||
0x01090C02, 0x01090C02, 0xFF000001, 0x010E0502, 0x010A0B02, /* 569 */
|
||||
0xFF000002, 0x01050E02, 0x01050E02, 0x020B0A02, 0x020D0702, /* 574 */
|
||||
0xFF000001, 0x01070D02, 0x01040E02, 0xFF000001, 0x010C0802, /* 579 */
|
||||
0x01080C02, 0xFF000002, 0x020E0402, 0x020E0202, 0x010E0302, /* 584 */
|
||||
0x010E0302, 0xFF000001, 0x010D0602, 0x01060D02, 0xFF000001, /* 589 */
|
||||
0x01030E02, 0x010B0902, 0xFF000001, 0x01090B02, 0x010A0A02, /* 594 */
|
||||
0xFF000001, 0x01020E02, 0x010E0102, 0xFF000001, 0x01010E02, /* 599 */
|
||||
0x010D0502, 0xFF000001, 0x01050D02, 0x010C0702, 0xFF000001, /* 604 */
|
||||
0x01070C02, 0x010D0402, 0xFF000001, 0x010B0802, 0x01080B02, /* 609 */
|
||||
0xFF000001, 0x01040D02, 0x010A0902, 0xFF000001, 0x01090A02, /* 614 */
|
||||
0x010C0602, 0xFF000001, 0x01060C02, 0x010D0302, 0xFF000001, /* 619 */
|
||||
0x01030D02, 0x010D0202, 0xFF000001, 0x01020D02, 0x010D0102, /* 624 */
|
||||
0xFF000001, 0x010B0702, 0x01070B02, 0xFF000001, 0x01010D02, /* 629 */
|
||||
0x010C0502, 0xFF000001, 0x01050C02, 0x010A0802, 0xFF000001, /* 634 */
|
||||
0x01080A02, 0x01090902, 0xFF000001, 0x010C0402, 0x01040C02, /* 639 */
|
||||
0xFF000001, 0x010B0602, 0x01060B02, 0xFF000002, 0x02000D01, /* 644 */
|
||||
0x020C0001, 0x010C0302, 0x010C0302, 0xFF000001, 0x01030C02, /* 649 */
|
||||
0x010A0702, 0xFF000001, 0x01070A02, 0x010C0202, 0xFF000001, /* 654 */
|
||||
0x01020C02, 0x010B0502, 0xFF000001, 0x01050B02, 0x010C0102, /* 659 */
|
||||
0xFF000001, 0x01090802, 0x01080902, 0xFF000001, 0x01010C02, /* 664 */
|
||||
0x010B0402, 0xFF000002, 0x02000C01, 0x020B0001, 0x010B0302, /* 669 */
|
||||
0x010B0302, 0xFF000002, 0x02000B01, 0x020A0001, 0x010A0102, /* 674 */
|
||||
0x010A0102, 0xFF000001, 0x010A0602, 0x01060A02, 0xFF000001, /* 679 */
|
||||
0x01090702, 0x01070902, 0xFF000002, 0x02000A01, 0x02090001, /* 684 */
|
||||
0x01000901, 0x01000901, 0xFF000001, 0x010B0202, 0x010A0502, /* 689 */
|
||||
0xFF000001, 0x01050A02, 0x010B0102, 0xFF000001, 0x01010B02, /* 694 */
|
||||
0x01090602, 0xFF000001, 0x010A0402, 0x01080702, 0xFF000001, /* 699 */
|
||||
0x01080001, 0x01000801, 0xFF000001, 0x01070001, 0x01000701, /* 704 */ };
|
||||
|
||||
/* max table bits 9 */
|
||||
/* NO XING TABLE 25 */
|
||||
/* NO XING TABLE 26 */
|
||||
/* NO XING TABLE 27 */
|
||||
/* NO XING TABLE 28 */
|
||||
/* NO XING TABLE 29 */
|
||||
/* NO XING TABLE 30 */
|
||||
/* NO XING TABLE 31 */
|
||||
/* done */
|
||||
@ -1,265 +0,0 @@
|
||||
#include <math.h>
|
||||
|
||||
extern int m_band_limit;
|
||||
|
||||
/* "imdct.c" */
|
||||
void imdct18(float f[]); /* 18 point */
|
||||
void imdct6_3(float f[]); /* 6 point */
|
||||
|
||||
|
||||
/*-- windows by block type --*/
|
||||
static float win[4][36];
|
||||
|
||||
void hwin_init()
|
||||
{
|
||||
int i, j;
|
||||
double pi;
|
||||
|
||||
pi = 4.0 * atan(1.0);
|
||||
|
||||
/* type 0 */
|
||||
for (i = 0; i < 36; i++)
|
||||
win[0][i] = (float) sin(pi / 36 * (i + 0.5));
|
||||
|
||||
/* type 1 */
|
||||
for (i = 0; i < 18; i++)
|
||||
win[1][i] = (float) sin(pi / 36 * (i + 0.5));
|
||||
for (i = 18; i < 24; i++)
|
||||
win[1][i] = 1.0F;
|
||||
for (i = 24; i < 30; i++)
|
||||
win[1][i] = (float) sin(pi / 12 * (i + 0.5 - 18));
|
||||
for (i = 30; i < 36; i++)
|
||||
win[1][i] = 0.0F;
|
||||
|
||||
/* type 3 */
|
||||
for (i = 0; i < 6; i++)
|
||||
win[3][i] = 0.0F;
|
||||
for (i = 6; i < 12; i++)
|
||||
win[3][i] = (float) sin(pi / 12 * (i + 0.5 - 6));
|
||||
for (i = 12; i < 18; i++)
|
||||
win[3][i] = 1.0F;
|
||||
for (i = 18; i < 36; i++)
|
||||
win[3][i] = (float) sin(pi / 36 * (i + 0.5));
|
||||
|
||||
/* type 2 */
|
||||
for (i = 0; i < 12; i++)
|
||||
win[2][i] = (float) sin(pi / 12 * (i + 0.5));
|
||||
for (i = 12; i < 36; i++)
|
||||
win[2][i] = 0.0F;
|
||||
|
||||
/*--- invert signs by region to match mdct 18pt --> 36pt mapping */
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
if (j == 2)
|
||||
continue;
|
||||
for (i = 9; i < 36; i++)
|
||||
win[j][i] = -win[j][i];
|
||||
}
|
||||
|
||||
/*-- invert signs for short blocks --*/
|
||||
for (i = 3; i < 12; i++)
|
||||
win[2][i] = -win[2][i];
|
||||
|
||||
return;
|
||||
}
|
||||
/*====================================================================*/
|
||||
int hybrid(float xin[], float xprev[], float y[18][32],
|
||||
int btype, int nlong, int ntot, int nprev)
|
||||
{
|
||||
int i, j;
|
||||
float *x, *x0;
|
||||
float xa, xb;
|
||||
int n;
|
||||
int nout;
|
||||
int band_limit_nsb;
|
||||
|
||||
if (btype == 2)
|
||||
btype = 0;
|
||||
x = xin;
|
||||
x0 = xprev;
|
||||
|
||||
/*-- do long blocks (if any) --*/
|
||||
n = (nlong + 17) / 18; /* number of dct's to do */
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
imdct18(x);
|
||||
for (j = 0; j < 9; j++)
|
||||
{
|
||||
y[j][i] = x0[j] + win[btype][j] * x[9 + j];
|
||||
y[9 + j][i] = x0[9 + j] + win[btype][9 + j] * x[17 - j];
|
||||
}
|
||||
/* window x for next time x0 */
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
xa = x[j];
|
||||
xb = x[8 - j];
|
||||
x[j] = win[btype][18 + j] * xb;
|
||||
x[8 - j] = win[btype][(18 + 8) - j] * xa;
|
||||
x[9 + j] = win[btype][(18 + 9) + j] * xa;
|
||||
x[17 - j] = win[btype][(18 + 17) - j] * xb;
|
||||
}
|
||||
xa = x[j];
|
||||
x[j] = win[btype][18 + j] * xa;
|
||||
x[9 + j] = win[btype][(18 + 9) + j] * xa;
|
||||
|
||||
x += 18;
|
||||
x0 += 18;
|
||||
}
|
||||
|
||||
/*-- do short blocks (if any) --*/
|
||||
n = (ntot + 17) / 18; /* number of 6 pt dct's triples to do */
|
||||
for (; i < n; i++)
|
||||
{
|
||||
imdct6_3(x);
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
y[j][i] = x0[j];
|
||||
y[3 + j][i] = x0[3 + j];
|
||||
|
||||
y[6 + j][i] = x0[6 + j] + win[2][j] * x[3 + j];
|
||||
y[9 + j][i] = x0[9 + j] + win[2][3 + j] * x[5 - j];
|
||||
|
||||
y[12 + j][i] = x0[12 + j] + win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
|
||||
y[15 + j][i] = x0[15 + j] + win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
|
||||
}
|
||||
/* window x for next time x0 */
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
x[j] = win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
|
||||
x[3 + j] = win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
|
||||
}
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
x[6 + j] = win[2][6 + j] * x[(12 + 2) - j];
|
||||
x[9 + j] = win[2][9 + j] * x[12 + j];
|
||||
}
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
x[12 + j] = 0.0f;
|
||||
x[15 + j] = 0.0f;
|
||||
}
|
||||
x += 18;
|
||||
x0 += 18;
|
||||
}
|
||||
|
||||
/*--- overlap prev if prev longer that current --*/
|
||||
n = (nprev + 17) / 18;
|
||||
for (; i < n; i++)
|
||||
{
|
||||
for (j = 0; j < 18; j++)
|
||||
y[j][i] = x0[j];
|
||||
x0 += 18;
|
||||
}
|
||||
nout = 18 * i;
|
||||
|
||||
/*--- clear remaining only to band limit --*/
|
||||
band_limit_nsb = (m_band_limit + 17) / 18; /* limit nsb's rounded up */
|
||||
for (; i < band_limit_nsb; i++)
|
||||
{
|
||||
for (j = 0; j < 18; j++)
|
||||
y[j][i] = 0.0f;
|
||||
}
|
||||
|
||||
return nout;
|
||||
}
|
||||
/*--------------------------------------------------------------------*/
|
||||
/*--------------------------------------------------------------------*/
|
||||
/*-- convert to mono, add curr result to y,
|
||||
window and add next time to current left */
|
||||
int hybrid_sum(float xin[], float xin_left[], float y[18][32],
|
||||
int btype, int nlong, int ntot)
|
||||
{
|
||||
int i, j;
|
||||
float *x, *x0;
|
||||
float xa, xb;
|
||||
int n;
|
||||
int nout;
|
||||
|
||||
if (btype == 2)
|
||||
btype = 0;
|
||||
x = xin;
|
||||
x0 = xin_left;
|
||||
|
||||
/*-- do long blocks (if any) --*/
|
||||
n = (nlong + 17) / 18; /* number of dct's to do */
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
imdct18(x);
|
||||
for (j = 0; j < 9; j++)
|
||||
{
|
||||
y[j][i] += win[btype][j] * x[9 + j];
|
||||
y[9 + j][i] += win[btype][9 + j] * x[17 - j];
|
||||
}
|
||||
/* window x for next time x0 */
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
xa = x[j];
|
||||
xb = x[8 - j];
|
||||
x0[j] += win[btype][18 + j] * xb;
|
||||
x0[8 - j] += win[btype][(18 + 8) - j] * xa;
|
||||
x0[9 + j] += win[btype][(18 + 9) + j] * xa;
|
||||
x0[17 - j] += win[btype][(18 + 17) - j] * xb;
|
||||
}
|
||||
xa = x[j];
|
||||
x0[j] += win[btype][18 + j] * xa;
|
||||
x0[9 + j] += win[btype][(18 + 9) + j] * xa;
|
||||
|
||||
x += 18;
|
||||
x0 += 18;
|
||||
}
|
||||
|
||||
/*-- do short blocks (if any) --*/
|
||||
n = (ntot + 17) / 18; /* number of 6 pt dct's triples to do */
|
||||
for (; i < n; i++)
|
||||
{
|
||||
imdct6_3(x);
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
y[6 + j][i] += win[2][j] * x[3 + j];
|
||||
y[9 + j][i] += win[2][3 + j] * x[5 - j];
|
||||
|
||||
y[12 + j][i] += win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
|
||||
y[15 + j][i] += win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
|
||||
}
|
||||
/* window x for next time */
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
x0[j] += win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
|
||||
x0[3 + j] += win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
|
||||
}
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
x0[6 + j] += win[2][6 + j] * x[(12 + 2) - j];
|
||||
x0[9 + j] += win[2][9 + j] * x[12 + j];
|
||||
}
|
||||
x += 18;
|
||||
x0 += 18;
|
||||
}
|
||||
|
||||
nout = 18 * i;
|
||||
|
||||
return nout;
|
||||
}
|
||||
/*--------------------------------------------------------------------*/
|
||||
void sum_f_bands(float a[], float b[], int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
a[i] += b[i];
|
||||
}
|
||||
/*--------------------------------------------------------------------*/
|
||||
void freq_invert(float y[18][32], int n)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
n = (n + 17) / 18;
|
||||
for (j = 0; j < 18; j += 2)
|
||||
{
|
||||
for (i = 0; i < n; i += 2)
|
||||
{
|
||||
y[1 + j][1 + i] = -y[1 + j][1 + i];
|
||||
}
|
||||
}
|
||||
}
|
||||
/*--------------------------------------------------------------------*/
|
||||
@ -1,212 +0,0 @@
|
||||
#include "layer3.h"
|
||||
|
||||
extern MPEG_DECODE_OPTION m_option;
|
||||
extern SAMPLE m_sample[2][2][576];
|
||||
extern int m_frequency;
|
||||
|
||||
extern SBT_PROC m_sbt_proc;
|
||||
extern XFORM_PROC m_xform_proc;
|
||||
extern int m_channels;
|
||||
extern int m_sfBandIndex[2][22];// [long/short][cb]
|
||||
extern int m_nBand[2][22];
|
||||
extern int m_band_limit;
|
||||
extern int m_band_limit21; // limit for sf band 21
|
||||
extern int m_band_limit12; // limit for sf band 12 short
|
||||
extern int m_band_limit_nsb;
|
||||
extern int m_ncbl_mixed;
|
||||
extern int m_nsb_limit;
|
||||
|
||||
extern int m_gr;
|
||||
extern int m_buf_ptr0, m_buf_ptr1;
|
||||
extern float m_yout[576];
|
||||
|
||||
//extern "l3sbt.c"
|
||||
void sbt_mono_L3(float *sample, signed short *pcm, int ch);
|
||||
void sbt_dual_L3(float *sample, signed short *pcm, int ch);
|
||||
void sbt16_mono_L3(float *sample, signed short *pcm, int ch);
|
||||
void sbt16_dual_L3(float *sample, signed short *pcm, int ch);
|
||||
void sbt8_mono_L3(float *sample, signed short *pcm, int ch);
|
||||
void sbt8_dual_L3(float *sample, signed short *pcm, int ch);
|
||||
void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch);
|
||||
void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch);
|
||||
|
||||
//extern "l3dec.c"
|
||||
void xform_mono(void *pcm, int igr);
|
||||
void xform_dual(void *pcm, int igr);
|
||||
void xform_dual_mono(void *pcm, int igr);
|
||||
void xform_dual_right(void *pcm, int igr);
|
||||
|
||||
static const SBT_PROC sbt_table[2][3][2] =
|
||||
{
|
||||
sbt_mono_L3,
|
||||
sbt_dual_L3,
|
||||
sbt16_mono_L3,
|
||||
sbt16_dual_L3,
|
||||
sbt8_mono_L3,
|
||||
sbt8_dual_L3,
|
||||
// 8 bit output
|
||||
sbtB_mono_L3,
|
||||
sbtB_dual_L3,
|
||||
sbtB16_mono_L3,
|
||||
sbtB16_dual_L3,
|
||||
sbtB8_mono_L3,
|
||||
sbtB8_dual_L3,
|
||||
};
|
||||
|
||||
static const XFORM_PROC xform_table[5] =
|
||||
{
|
||||
xform_mono,
|
||||
xform_dual,
|
||||
xform_dual_mono,
|
||||
xform_mono, /* left */
|
||||
xform_dual_right,
|
||||
};
|
||||
|
||||
static const struct {
|
||||
int l[23];
|
||||
int s[14];
|
||||
} sfBandTable[3][3] = {
|
||||
// MPEG-1
|
||||
{{
|
||||
{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},
|
||||
{0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192}
|
||||
},{
|
||||
{0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},
|
||||
{0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192}
|
||||
},{
|
||||
{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},
|
||||
{0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192}
|
||||
}},
|
||||
// MPEG-2
|
||||
{{
|
||||
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
||||
{0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192}
|
||||
},{
|
||||
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},
|
||||
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192}
|
||||
},{
|
||||
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
||||
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
|
||||
}},
|
||||
// MPEG-2.5, 11 & 12 KHz seem ok, 8 ok
|
||||
{{
|
||||
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
||||
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
|
||||
},{
|
||||
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
|
||||
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
|
||||
},{
|
||||
// this 8khz table, and only 8khz, from mpeg123)
|
||||
{0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},
|
||||
{0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192}
|
||||
}},
|
||||
};
|
||||
|
||||
void quant_init();
|
||||
void alias_init();
|
||||
void msis_init();
|
||||
void fdct_init();
|
||||
void imdct_init();
|
||||
void hwin_init();
|
||||
|
||||
void L3table_init()
|
||||
{
|
||||
quant_init();
|
||||
alias_init();
|
||||
msis_init();
|
||||
fdct_init();
|
||||
imdct_init();
|
||||
hwin_init();
|
||||
}
|
||||
|
||||
int L3decode_start(MPEG_HEADER* h)
|
||||
{
|
||||
int i, j, k, v;
|
||||
int channels, limit;
|
||||
int bit_code;
|
||||
|
||||
m_buf_ptr0 = 0;
|
||||
m_buf_ptr1 = 0;
|
||||
m_gr = 0;
|
||||
v = h->version - 1;
|
||||
if (h->version == 1) //MPEG-1
|
||||
m_ncbl_mixed = 8;
|
||||
else //MPEG-2, MPEG-2.5
|
||||
m_ncbl_mixed = 6;
|
||||
|
||||
// compute nsb_limit
|
||||
m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
|
||||
// caller limit
|
||||
limit = (32 >> m_option.reduction);
|
||||
if (limit > 8)
|
||||
limit--;
|
||||
if (m_nsb_limit > limit)
|
||||
m_nsb_limit = limit;
|
||||
limit = 18 * m_nsb_limit;
|
||||
|
||||
if (h->version == 1) {
|
||||
//MPEG-1
|
||||
m_band_limit12 = 3 * sfBandTable[v][h->fr_index].s[13];
|
||||
m_band_limit = m_band_limit21 = sfBandTable[v][h->fr_index].l[22];
|
||||
}
|
||||
else {
|
||||
//MPEG-2, MPEG-2.5
|
||||
m_band_limit12 = 3 * sfBandTable[v][h->fr_index].s[12];
|
||||
m_band_limit = m_band_limit21 = sfBandTable[v][h->fr_index].l[21];
|
||||
}
|
||||
m_band_limit += 8; // allow for antialias
|
||||
if (m_band_limit > limit)
|
||||
m_band_limit = limit;
|
||||
if (m_band_limit21 > m_band_limit)
|
||||
m_band_limit21 = m_band_limit;
|
||||
if (m_band_limit12 > m_band_limit)
|
||||
m_band_limit12 = m_band_limit;
|
||||
m_band_limit_nsb = (m_band_limit + 17) / 18; // limit nsb's rounded up
|
||||
/*
|
||||
gain_adjust = 0; // adjust gain e.g. cvt to mono sum channel
|
||||
if ((h->mode != 3) && (m_option.convert == 1))
|
||||
gain_adjust = -4;
|
||||
*/
|
||||
m_channels = (h->mode == 3) ? 1 : 2;
|
||||
if (m_option.convert) channels = 1;
|
||||
else channels = m_channels;
|
||||
|
||||
bit_code = (m_option.convert & 8) ? 1 : 0;
|
||||
m_sbt_proc = sbt_table[bit_code][m_option.reduction][channels - 1];//[2][3][2]
|
||||
k = (h->mode != 3) ? (1 + m_option.convert) : 0;
|
||||
m_xform_proc = xform_table[k];//[5]
|
||||
/*
|
||||
if (bit_code)
|
||||
zero_level_pcm = 128;// 8 bit output
|
||||
else
|
||||
zero_level_pcm = 0;
|
||||
*/
|
||||
// init band tables
|
||||
for (i = 0; i < 22; i ++)
|
||||
m_sfBandIndex[0][i] = sfBandTable[v][h->fr_index].l[i + 1];
|
||||
for (i = 0; i < 13; i ++)
|
||||
m_sfBandIndex[1][i] = 3 * sfBandTable[v][h->fr_index].s[i + 1];
|
||||
for (i = 0; i < 22; i ++)
|
||||
m_nBand[0][i] = sfBandTable[v][h->fr_index].l[i + 1]
|
||||
- sfBandTable[v][h->fr_index].l[i];
|
||||
for (i = 0; i < 13; i ++)
|
||||
m_nBand[1][i] = sfBandTable[v][h->fr_index].s[i + 1]
|
||||
- sfBandTable[v][h->fr_index].s[i];
|
||||
|
||||
// clear buffers
|
||||
for (i = 0; i < 576; i++)
|
||||
m_yout[i] = 0.0f;
|
||||
for (i = 0; i < 2; i ++)
|
||||
{ for (j = 0; j < 2; j ++)
|
||||
{ for (k = 0; k < 576; k++)
|
||||
{ m_sample[i][j][k].x = 0.0f;
|
||||
m_sample[i][j][k].s = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
@ -1,332 +0,0 @@
|
||||
#include "layer3.h"
|
||||
#include <math.h>
|
||||
//#include <windows.h>
|
||||
|
||||
extern IS_SF_INFO m_is_sf_info;
|
||||
extern int m_ms_mode, m_is_mode;
|
||||
|
||||
extern int m_sfBandIndex[2][22];// [long/short][cb]
|
||||
extern int m_nBand[2][22];
|
||||
|
||||
/* intensity stereo */
|
||||
/* if ms mode quant pre-scales all values by 1.0/sqrt(2.0) ms_mode in table
|
||||
compensates */
|
||||
/* [ms_mode 0/1][sf][left/right] */
|
||||
static float lr[2][8][2];
|
||||
/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
|
||||
static float lr2[2][2][64][2];
|
||||
|
||||
/*-------*msis_init_addr()
|
||||
pi = 4.0*atan(1.0);
|
||||
t = pi/12.0;
|
||||
for(i=0;i<7;i++) {
|
||||
s = sin(i*t);
|
||||
c = cos(i*t);
|
||||
// ms_mode = 0
|
||||
lr[0][i][0] = (float)(s/(s+c));
|
||||
lr[0][i][1] = (float)(c/(s+c));
|
||||
// ms_mode = 1
|
||||
lr[1][i][0] = (float)(sqrt(2.0)*(s/(s+c)));
|
||||
lr[1][i][1] = (float)(sqrt(2.0)*(c/(s+c)));
|
||||
}
|
||||
//sf = 7
|
||||
//ms_mode = 0
|
||||
lr[0][i][0] = 1.0f;
|
||||
lr[0][i][1] = 0.0f;
|
||||
// ms_mode = 1, in is bands is routine does ms processing
|
||||
lr[1][i][0] = 1.0f;
|
||||
lr[1][i][1] = 1.0f;
|
||||
------------*/
|
||||
|
||||
/*===============================================================*/
|
||||
void msis_init1()
|
||||
{
|
||||
int i;
|
||||
double s, c;
|
||||
double pi;
|
||||
double t;
|
||||
|
||||
pi = 4.0 * atan(1.0);
|
||||
t = pi / 12.0;
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
s = sin(i * t);
|
||||
c = cos(i * t);
|
||||
/* ms_mode = 0 */
|
||||
lr[0][i][0] = (float) (s / (s + c));
|
||||
lr[0][i][1] = (float) (c / (s + c));
|
||||
/* ms_mode = 1 */
|
||||
lr[1][i][0] = (float) (sqrt(2.0) * (s / (s + c)));
|
||||
lr[1][i][1] = (float) (sqrt(2.0) * (c / (s + c)));
|
||||
}
|
||||
/* sf = 7 */
|
||||
/* ms_mode = 0 */
|
||||
lr[0][i][0] = 1.0f;
|
||||
lr[0][i][1] = 0.0f;
|
||||
/* ms_mode = 1, in is bands is routine does ms processing */
|
||||
lr[1][i][0] = 1.0f;
|
||||
lr[1][i][1] = 1.0f;
|
||||
|
||||
|
||||
/*-------
|
||||
for(i=0;i<21;i++) m_nBand[0][i] =
|
||||
sfBandTable[sr_index].l[i+1] - sfBandTable[sr_index].l[i];
|
||||
for(i=0;i<12;i++) m_nBand[1][i] =
|
||||
sfBandTable[sr_index].s[i+1] - sfBandTable[sr_index].s[i];
|
||||
-------------*/
|
||||
}
|
||||
/*===============================================================*/
|
||||
void msis_init2()
|
||||
{
|
||||
int k, n;
|
||||
double t;
|
||||
int intensity_scale, ms_mode, sf, sflen;
|
||||
float ms_factor[2];
|
||||
|
||||
|
||||
ms_factor[0] = 1.0;
|
||||
ms_factor[1] = (float) sqrt(2.0);
|
||||
|
||||
/* intensity stereo MPEG2 */
|
||||
/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
|
||||
|
||||
for (intensity_scale = 0; intensity_scale < 2; intensity_scale++)
|
||||
{
|
||||
t = pow_test(2.0, -0.25 * (1 + intensity_scale));
|
||||
for (ms_mode = 0; ms_mode < 2; ms_mode++)
|
||||
{
|
||||
|
||||
n = 1;
|
||||
k = 0;
|
||||
for (sflen = 0; sflen < 6; sflen++)
|
||||
{
|
||||
for (sf = 0; sf < (n - 1); sf++, k++)
|
||||
{
|
||||
if (sf == 0)
|
||||
{
|
||||
lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
|
||||
lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
|
||||
}
|
||||
else if ((sf & 1))
|
||||
{
|
||||
lr2[intensity_scale][ms_mode][k][0] =
|
||||
(float) (ms_factor[ms_mode] * pow_test(t, (sf + 1) / 2));
|
||||
lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
|
||||
lr2[intensity_scale][ms_mode][k][1] =
|
||||
(float) (ms_factor[ms_mode] * pow_test(t, sf / 2));
|
||||
}
|
||||
}
|
||||
|
||||
/* illegal is_pos used to do ms processing */
|
||||
if (ms_mode == 0)
|
||||
{ /* ms_mode = 0 */
|
||||
lr2[intensity_scale][ms_mode][k][0] = 1.0f;
|
||||
lr2[intensity_scale][ms_mode][k][1] = 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* ms_mode = 1, in is bands is routine does ms processing */
|
||||
lr2[intensity_scale][ms_mode][k][0] = 1.0f;
|
||||
lr2[intensity_scale][ms_mode][k][1] = 1.0f;
|
||||
}
|
||||
k++;
|
||||
n = n + n;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void msis_init()
|
||||
{
|
||||
msis_init1();
|
||||
msis_init2();
|
||||
}
|
||||
|
||||
/*===============================================================*/
|
||||
void ms_process(float x[][1152], int n) /* sum-difference stereo */
|
||||
{
|
||||
int i;
|
||||
float xl, xr;
|
||||
|
||||
/*-- note: sqrt(2) done scaling by dequant ---*/
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
xl = x[0][i] + x[1][i];
|
||||
xr = x[0][i] - x[1][i];
|
||||
x[0][i] = xl;
|
||||
x[1][i] = xr;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void is_process1(float x[][1152], /* intensity stereo */
|
||||
SCALE_FACTOR* sf,
|
||||
CB_INFO cb_info[2], /* [ch] */
|
||||
int nsamp)
|
||||
{
|
||||
int i, j, n, cb, w;
|
||||
float fl, fr;
|
||||
int m;
|
||||
int isf;
|
||||
float fls[3], frs[3];
|
||||
int cb0;
|
||||
|
||||
|
||||
cb0 = cb_info[1].cbmax; /* start at end of right */
|
||||
i = m_sfBandIndex[cb_info[1].cbtype][cb0];
|
||||
cb0++;
|
||||
m = nsamp - i; /* process to len of left */
|
||||
|
||||
if (cb_info[1].cbtype)
|
||||
goto short_blocks;
|
||||
/*------------------------*/
|
||||
/* long_blocks: */
|
||||
for (cb = cb0; cb < 21; cb++)
|
||||
{
|
||||
isf = sf->l[cb];
|
||||
n = m_nBand[0][cb];
|
||||
fl = lr[m_ms_mode][isf][0];
|
||||
fr = lr[m_ms_mode][isf][1];
|
||||
for (j = 0; j < n; j++, i++)
|
||||
{
|
||||
if (--m < 0)
|
||||
goto exit;
|
||||
x[1][i] = fr * x[0][i];
|
||||
x[0][i] = fl * x[0][i];
|
||||
}
|
||||
}
|
||||
return;
|
||||
/*------------------------*/
|
||||
short_blocks:
|
||||
for (cb = cb0; cb < 12; cb++)
|
||||
{
|
||||
for (w = 0; w < 3; w++)
|
||||
{
|
||||
isf = sf->s[w][cb];
|
||||
fls[w] = lr[m_ms_mode][isf][0];
|
||||
frs[w] = lr[m_ms_mode][isf][1];
|
||||
}
|
||||
n = m_nBand[1][cb];
|
||||
for (j = 0; j < n; j++)
|
||||
{
|
||||
m -= 3;
|
||||
if (m < 0)
|
||||
goto exit;
|
||||
x[1][i] = frs[0] * x[0][i];
|
||||
x[0][i] = fls[0] * x[0][i];
|
||||
x[1][1 + i] = frs[1] * x[0][1 + i];
|
||||
x[0][1 + i] = fls[1] * x[0][1 + i];
|
||||
x[1][2 + i] = frs[2] * x[0][2 + i];
|
||||
x[0][2 + i] = fls[2] * x[0][2 + i];
|
||||
i += 3;
|
||||
}
|
||||
}
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
|
||||
typedef float ARRAY2[2];
|
||||
|
||||
void is_process2(float x[][1152], /* intensity stereo */
|
||||
SCALE_FACTOR* sf,
|
||||
CB_INFO cb_info[2], /* [ch] */
|
||||
int nsamp)
|
||||
{
|
||||
int i, j, k, n, cb, w;
|
||||
float fl, fr;
|
||||
int m;
|
||||
int isf;
|
||||
int il[21];
|
||||
int tmp;
|
||||
int r;
|
||||
ARRAY2 *lr;
|
||||
int cb0, cb1;
|
||||
|
||||
lr = lr2[m_is_sf_info.intensity_scale][m_ms_mode];
|
||||
|
||||
if (cb_info[1].cbtype)
|
||||
goto short_blocks;
|
||||
|
||||
/*------------------------*/
|
||||
/* long_blocks: */
|
||||
cb0 = cb_info[1].cbmax; /* start at end of right */
|
||||
i = m_sfBandIndex[0][cb0];
|
||||
m = nsamp - i; /* process to len of left */
|
||||
/* gen sf info */
|
||||
for (k = r = 0; r < 3; r++)
|
||||
{
|
||||
tmp = (1 << m_is_sf_info.slen[r]) - 1;
|
||||
for (j = 0; j < m_is_sf_info.nr[r]; j++, k++)
|
||||
il[k] = tmp;
|
||||
}
|
||||
for (cb = cb0 + 1; cb < 21; cb++)
|
||||
{
|
||||
isf = il[cb] + sf->l[cb];
|
||||
// X-MaD 27-02-02
|
||||
if (isf < 0) { isf = 0; }
|
||||
fl = 0;
|
||||
fr = 0;
|
||||
|
||||
//try
|
||||
//{
|
||||
fl = lr[isf][0];
|
||||
fr = lr[isf][1];
|
||||
n = m_nBand[0][cb];
|
||||
//}
|
||||
//catch(...)
|
||||
//{
|
||||
// isf = 0;
|
||||
//}
|
||||
// X-MaD 27-02-02
|
||||
|
||||
for (j = 0; j < n; j++, i++)
|
||||
{
|
||||
if (--m < 0)
|
||||
{
|
||||
goto exit;
|
||||
}
|
||||
x[1][i] = fr * x[0][i];
|
||||
x[0][i] = fl * x[0][i];
|
||||
}
|
||||
}
|
||||
return;
|
||||
/*------------------------*/
|
||||
short_blocks:
|
||||
|
||||
for (k = r = 0; r < 3; r++)
|
||||
{
|
||||
tmp = (1 << m_is_sf_info.slen[r]) - 1;
|
||||
for (j = 0; j < m_is_sf_info.nr[r]; j++, k++)
|
||||
il[k] = tmp;
|
||||
}
|
||||
|
||||
for (w = 0; w < 3; w++)
|
||||
{
|
||||
cb0 = cb_info[1].cbmax_s[w]; /* start at end of right */
|
||||
i = m_sfBandIndex[1][cb0] + w;
|
||||
cb1 = cb_info[0].cbmax_s[w]; /* process to end of left */
|
||||
|
||||
for (cb = cb0 + 1; cb <= cb1; cb++)
|
||||
{
|
||||
isf = il[cb] + sf->s[w][cb];
|
||||
fl = lr[isf][0];
|
||||
fr = lr[isf][1];
|
||||
n = m_nBand[1][cb];
|
||||
for (j = 0; j < n; j++)
|
||||
{
|
||||
x[1][i] = fr * x[0][i];
|
||||
x[0][i] = fl * x[0][i];
|
||||
i += 3;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
@ -1,217 +0,0 @@
|
||||
#include "layer3.h"
|
||||
|
||||
#include <math.h>
|
||||
#include <string.h> //memmove
|
||||
|
||||
extern SIDE_INFO m_side_info;
|
||||
extern SCALE_FACTOR m_scale_fac[2][2]; // [gr][ch]
|
||||
extern CB_INFO m_cb_info[2][2]; // [gr][ch]
|
||||
|
||||
extern int m_nsamp[2][2];
|
||||
extern int m_nBand[2][22];
|
||||
extern int m_ncbl_mixed;
|
||||
|
||||
#define GLOBAL_GAIN_SCALE (4*15)
|
||||
|
||||
static const int pretab[2][22] =
|
||||
{
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0},
|
||||
};
|
||||
|
||||
/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
|
||||
/* two extra slots to do 1/sqrt(2) scaling for ms */
|
||||
/* 4 extra slots to do 1/2 scaling for cvt to mono */
|
||||
static float look_global[256 + 2 + 4];
|
||||
|
||||
/*-------- scaling lookup
|
||||
x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp)
|
||||
look_scale[scalefact_scale][preemp][scalefac]
|
||||
-----------------------*/
|
||||
static float look_scale[2][4][32];
|
||||
|
||||
/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
|
||||
#define ISMAX 32
|
||||
static float look_pow[2 * ISMAX];
|
||||
|
||||
/*-- pow(2.0, -0.25*8.0*subblock_gain) --*/
|
||||
static float look_subblock[8];
|
||||
|
||||
/*-- reorder buffer ---*/
|
||||
static float re_buf[192][3];
|
||||
typedef float ARRAY3[3];
|
||||
|
||||
void quant_init()
|
||||
{
|
||||
int i;
|
||||
int scalefact_scale, preemp, scalefac;
|
||||
double tmp;
|
||||
|
||||
/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
|
||||
/* extra 2 for ms scaling by 1/sqrt(2) */
|
||||
/* extra 4 for cvt to mono scaling by 1/2 */
|
||||
for (i = 0; i < 256 + 2 + 4; i++)
|
||||
look_global[i] = (float) pow_test(2.0, 0.25 * ((i - (2 + 4)) - 210 + GLOBAL_GAIN_SCALE));
|
||||
|
||||
/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
|
||||
for (scalefact_scale = 0; scalefact_scale < 2; scalefact_scale++)
|
||||
{
|
||||
for (preemp = 0; preemp < 4; preemp++)
|
||||
{
|
||||
for (scalefac = 0; scalefac < 32; scalefac++)
|
||||
{
|
||||
look_scale[scalefact_scale][preemp][scalefac] =
|
||||
(float) pow_test(2.0, -0.5 * (1 + scalefact_scale) * (scalefac + preemp));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
tmp = i - 32;
|
||||
look_pow[i] = (float) (tmp * pow_test(fabs(tmp), (1.0 / 3.0)));
|
||||
}
|
||||
|
||||
/*-- pow(2.0, -0.25*8.0*subblock_gain) 3 bits --*/
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
look_subblock[i] = (float) pow_test(2.0, 0.25 * -8.0 * i);
|
||||
}
|
||||
// quant_init_sf_band(sr_index); replaced by code in sup.c
|
||||
}
|
||||
|
||||
void dequant(SAMPLE Sample[], int gr, int ch)
|
||||
{
|
||||
SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
|
||||
GR_INFO* gr_info = &m_side_info.gr[gr][ch];
|
||||
CB_INFO* cb_info = &m_cb_info[gr][ch];
|
||||
int* nsamp = &m_nsamp[gr][ch];
|
||||
|
||||
int i, j;
|
||||
int cb, n, w;
|
||||
float x0, xs;
|
||||
float xsb[3];
|
||||
double tmp;
|
||||
int ncbl;
|
||||
int cbs0;
|
||||
ARRAY3 *buf; /* short block reorder */
|
||||
int nbands;
|
||||
int i0;
|
||||
int non_zero;
|
||||
int cbmax[3];
|
||||
|
||||
nbands = *nsamp;
|
||||
|
||||
|
||||
ncbl = 22; /* long block cb end */
|
||||
cbs0 = 12; /* short block cb start */
|
||||
/* ncbl_mixed = 8 or 6 mpeg1 or 2 */
|
||||
if (gr_info->block_type == 2)
|
||||
{
|
||||
ncbl = 0;
|
||||
cbs0 = 0;
|
||||
if (gr_info->mixed_block_flag)
|
||||
{
|
||||
ncbl = m_ncbl_mixed;
|
||||
cbs0 = 3;
|
||||
}
|
||||
}
|
||||
/* fill in cb_info -- */
|
||||
cb_info->lb_type = gr_info->block_type;
|
||||
if (gr_info->block_type == 2)
|
||||
cb_info->lb_type;
|
||||
cb_info->cbs0 = cbs0;
|
||||
cb_info->ncbl = ncbl;
|
||||
|
||||
cbmax[2] = cbmax[1] = cbmax[0] = 0;
|
||||
/* global gain pre-adjusted by 2 if ms_mode, 0 otherwise */
|
||||
x0 = look_global[(2 + 4) + gr_info->global_gain];
|
||||
i = 0;
|
||||
/*----- long blocks ---*/
|
||||
for (cb = 0; cb < ncbl; cb++)
|
||||
{
|
||||
non_zero = 0;
|
||||
xs = x0 * look_scale[gr_info->scalefac_scale][pretab[gr_info->preflag][cb]][sf->l[cb]];
|
||||
n = m_nBand[0][cb];
|
||||
for (j = 0; j < n; j++, i++)
|
||||
{
|
||||
if (Sample[i].s == 0)
|
||||
Sample[i].x = 0.0F;
|
||||
else
|
||||
{
|
||||
non_zero = 1;
|
||||
if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
|
||||
Sample[i].x = xs * look_pow[ISMAX + Sample[i].s];
|
||||
else
|
||||
{
|
||||
tmp = (double) Sample[i].s;
|
||||
Sample[i].x = (float) (xs * tmp * pow_test(fabs(tmp), (1.0 / 3.0)));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (non_zero)
|
||||
cbmax[0] = cb;
|
||||
if (i >= nbands)
|
||||
break;
|
||||
}
|
||||
|
||||
cb_info->cbmax = cbmax[0];
|
||||
cb_info->cbtype = 0; // type = long
|
||||
|
||||
if (cbs0 >= 12)
|
||||
return;
|
||||
/*---------------------------
|
||||
block type = 2 short blocks
|
||||
----------------------------*/
|
||||
cbmax[2] = cbmax[1] = cbmax[0] = cbs0;
|
||||
i0 = i; /* save for reorder */
|
||||
buf = re_buf;
|
||||
for (w = 0; w < 3; w++)
|
||||
xsb[w] = x0 * look_subblock[gr_info->subblock_gain[w]];
|
||||
for (cb = cbs0; cb < 13; cb++)
|
||||
{
|
||||
n = m_nBand[1][cb];
|
||||
for (w = 0; w < 3; w++)
|
||||
{
|
||||
non_zero = 0;
|
||||
xs = xsb[w] * look_scale[gr_info->scalefac_scale][0][sf->s[w][cb]];
|
||||
for (j = 0; j < n; j++, i++)
|
||||
{
|
||||
if (Sample[i].s == 0)
|
||||
buf[j][w] = 0.0F;
|
||||
else
|
||||
{
|
||||
non_zero = 1;
|
||||
if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
|
||||
buf[j][w] = xs * look_pow[ISMAX + Sample[i].s];
|
||||
else
|
||||
{
|
||||
tmp = (double) Sample[i].s;
|
||||
buf[j][w] = (float) (xs * tmp * pow_test(fabs(tmp), (1.0 / 3.0)));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (non_zero)
|
||||
cbmax[w] = cb;
|
||||
}
|
||||
if (i >= nbands)
|
||||
break;
|
||||
buf += n;
|
||||
}
|
||||
|
||||
|
||||
memmove(&Sample[i0].x, &re_buf[0][0], sizeof(float) * (i - i0));
|
||||
|
||||
*nsamp = i; /* update nsamp */
|
||||
cb_info->cbmax_s[0] = cbmax[0];
|
||||
cb_info->cbmax_s[1] = cbmax[1];
|
||||
cb_info->cbmax_s[2] = cbmax[2];
|
||||
if (cbmax[1] > cbmax[0])
|
||||
cbmax[0] = cbmax[1];
|
||||
if (cbmax[2] > cbmax[0])
|
||||
cbmax[0] = cbmax[2];
|
||||
|
||||
cb_info->cbmax = cbmax[0];
|
||||
cb_info->cbtype = 1; /* type = short */
|
||||
}
|
||||
@ -1,353 +0,0 @@
|
||||
#include "layer3.h"
|
||||
|
||||
extern SIDE_INFO m_side_info;
|
||||
extern SCALE_FACTOR m_scale_fac[2][2]; // [gr][ch]
|
||||
extern IS_SF_INFO m_is_sf_info;
|
||||
|
||||
extern int m_is_mode;
|
||||
|
||||
static const int slen_table[16][2] =
|
||||
{
|
||||
0, 0, 0, 1,
|
||||
0, 2, 0, 3,
|
||||
3, 0, 1, 1,
|
||||
1, 2, 1, 3,
|
||||
2, 1, 2, 2,
|
||||
2, 3, 3, 1,
|
||||
3, 2, 3, 3,
|
||||
4, 2, 4, 3,
|
||||
};
|
||||
|
||||
/* nr_table[size+3*is_right][block type 0,1,3 2, 2+mixed][4] */
|
||||
/* for bt=2 nr is count for group of 3 */
|
||||
static const int nr_table[6][3][4] =
|
||||
{
|
||||
6, 5, 5, 5,
|
||||
3, 3, 3, 3,
|
||||
6, 3, 3, 3,
|
||||
|
||||
6, 5, 7, 3,
|
||||
3, 3, 4, 2,
|
||||
6, 3, 4, 2,
|
||||
|
||||
11, 10, 0, 0,
|
||||
6, 6, 0, 0,
|
||||
6, 3, 6, 0, /* adjusted *//* 15, 18, 0, 0, */
|
||||
/*-intensity stereo right chan--*/
|
||||
7, 7, 7, 0,
|
||||
4, 4, 4, 0,
|
||||
6, 5, 4, 0,
|
||||
|
||||
6, 6, 6, 3,
|
||||
4, 3, 3, 2,
|
||||
6, 4, 3, 2,
|
||||
|
||||
8, 8, 5, 0,
|
||||
5, 4, 3, 0,
|
||||
6, 6, 3, 0,
|
||||
};
|
||||
|
||||
void L3get_scale_factor1(int gr, int ch)
|
||||
{
|
||||
SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
|
||||
GR_INFO* grdat = &m_side_info.gr[gr][ch];
|
||||
int scfsi = m_side_info.scfsi[ch];
|
||||
|
||||
int sfb;
|
||||
int slen0, slen1;
|
||||
int block_type, mixed_block_flag, scalefac_compress;
|
||||
|
||||
block_type = grdat->block_type;
|
||||
mixed_block_flag = grdat->mixed_block_flag;
|
||||
scalefac_compress = grdat->scalefac_compress;
|
||||
|
||||
slen0 = slen_table[scalefac_compress][0];
|
||||
slen1 = slen_table[scalefac_compress][1];
|
||||
|
||||
if (block_type == 2) {
|
||||
if (mixed_block_flag) { /* mixed */
|
||||
for (sfb = 0; sfb < 8; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen0);
|
||||
for (sfb = 3; sfb < 6; sfb++) {
|
||||
sf[0].s[0][sfb] = bitget(slen0);
|
||||
sf[0].s[1][sfb] = bitget(slen0);
|
||||
sf[0].s[2][sfb] = bitget(slen0);
|
||||
}
|
||||
for (sfb = 6; sfb < 12; sfb++) {
|
||||
sf[0].s[0][sfb] = bitget(slen1);
|
||||
sf[0].s[1][sfb] = bitget(slen1);
|
||||
sf[0].s[2][sfb] = bitget(slen1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
for (sfb = 0; sfb < 6; sfb++) {
|
||||
sf[0].s[0][sfb] = bitget(slen0);
|
||||
sf[0].s[1][sfb] = bitget(slen0);
|
||||
sf[0].s[2][sfb] = bitget(slen0);
|
||||
}
|
||||
for (; sfb < 12; sfb++) {
|
||||
sf[0].s[0][sfb] = bitget(slen1);
|
||||
sf[0].s[1][sfb] = bitget(slen1);
|
||||
sf[0].s[2][sfb] = bitget(slen1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* long blocks types 0 1 3, first granule */
|
||||
if (gr == 0)
|
||||
{
|
||||
for (sfb = 0; sfb < 11; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen0);
|
||||
for (; sfb < 21; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen1);
|
||||
return;
|
||||
}
|
||||
|
||||
/* long blocks 0, 1, 3, second granule */
|
||||
sfb = 0;
|
||||
if (scfsi & 8)
|
||||
for (; sfb < 6; sfb++)
|
||||
sf[0].l[sfb] = sf[-2].l[sfb];
|
||||
else
|
||||
for (; sfb < 6; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen0);
|
||||
if (scfsi & 4)
|
||||
for (; sfb < 11; sfb++)
|
||||
sf[0].l[sfb] = sf[-2].l[sfb];
|
||||
else
|
||||
for (; sfb < 11; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen0);
|
||||
if (scfsi & 2)
|
||||
for (; sfb < 16; sfb++)
|
||||
sf[0].l[sfb] = sf[-2].l[sfb];
|
||||
else
|
||||
for (; sfb < 16; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen1);
|
||||
if (scfsi & 1)
|
||||
for (; sfb < 21; sfb++)
|
||||
sf[0].l[sfb] = sf[-2].l[sfb];
|
||||
else
|
||||
for (; sfb < 21; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen1);
|
||||
}
|
||||
|
||||
void L3get_scale_factor2(int gr, int ch)
|
||||
{
|
||||
SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
|
||||
GR_INFO* grdat = &m_side_info.gr[gr][ch];
|
||||
int is_and_ch = m_is_mode & ch;
|
||||
|
||||
int sfb;
|
||||
int slen1, slen2, slen3, slen4;
|
||||
int nr1, nr2, nr3, nr4;
|
||||
int i, k;
|
||||
int preflag, intensity_scale;
|
||||
int block_type, mixed_block_flag, scalefac_compress;
|
||||
|
||||
|
||||
block_type = grdat->block_type;
|
||||
mixed_block_flag = grdat->mixed_block_flag;
|
||||
scalefac_compress = grdat->scalefac_compress;
|
||||
|
||||
preflag = 0;
|
||||
intensity_scale = 0; /* to avoid compiler warning */
|
||||
if (is_and_ch == 0)
|
||||
{
|
||||
if (scalefac_compress < 400)
|
||||
{
|
||||
slen2 = scalefac_compress >> 4;
|
||||
slen1 = slen2 / 5;
|
||||
slen2 = slen2 % 5;
|
||||
slen4 = scalefac_compress & 15;
|
||||
slen3 = slen4 >> 2;
|
||||
slen4 = slen4 & 3;
|
||||
k = 0;
|
||||
}
|
||||
else if (scalefac_compress < 500)
|
||||
{
|
||||
scalefac_compress -= 400;
|
||||
slen2 = scalefac_compress >> 2;
|
||||
slen1 = slen2 / 5;
|
||||
slen2 = slen2 % 5;
|
||||
slen3 = scalefac_compress & 3;
|
||||
slen4 = 0;
|
||||
k = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
scalefac_compress -= 500;
|
||||
slen1 = scalefac_compress / 3;
|
||||
slen2 = scalefac_compress % 3;
|
||||
slen3 = slen4 = 0;
|
||||
if (mixed_block_flag)
|
||||
{
|
||||
slen3 = slen2; /* adjust for long/short mix logic */
|
||||
slen2 = slen1;
|
||||
}
|
||||
preflag = 1;
|
||||
k = 2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{ /* intensity stereo ch = 1 (right) */
|
||||
intensity_scale = scalefac_compress & 1;
|
||||
scalefac_compress >>= 1;
|
||||
if (scalefac_compress < 180)
|
||||
{
|
||||
slen1 = scalefac_compress / 36;
|
||||
slen2 = scalefac_compress % 36;
|
||||
slen3 = slen2 % 6;
|
||||
slen2 = slen2 / 6;
|
||||
slen4 = 0;
|
||||
k = 3 + 0;
|
||||
}
|
||||
else if (scalefac_compress < 244)
|
||||
{
|
||||
scalefac_compress -= 180;
|
||||
slen3 = scalefac_compress & 3;
|
||||
scalefac_compress >>= 2;
|
||||
slen2 = scalefac_compress & 3;
|
||||
slen1 = scalefac_compress >> 2;
|
||||
slen4 = 0;
|
||||
k = 3 + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
scalefac_compress -= 244;
|
||||
slen1 = scalefac_compress / 3;
|
||||
slen2 = scalefac_compress % 3;
|
||||
slen3 = slen4 = 0;
|
||||
k = 3 + 2;
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
if (block_type == 2)
|
||||
i = (mixed_block_flag & 1) + 1;
|
||||
nr1 = nr_table[k][i][0];
|
||||
nr2 = nr_table[k][i][1];
|
||||
nr3 = nr_table[k][i][2];
|
||||
nr4 = nr_table[k][i][3];
|
||||
|
||||
|
||||
/* return is scale factor info (for right chan is mode) */
|
||||
if (is_and_ch)
|
||||
{
|
||||
m_is_sf_info.nr[0] = nr1;
|
||||
m_is_sf_info.nr[1] = nr2;
|
||||
m_is_sf_info.nr[2] = nr3;
|
||||
m_is_sf_info.slen[0] = slen1;
|
||||
m_is_sf_info.slen[1] = slen2;
|
||||
m_is_sf_info.slen[2] = slen3;
|
||||
m_is_sf_info.intensity_scale = intensity_scale;
|
||||
}
|
||||
grdat->preflag = preflag; /* return preflag */
|
||||
|
||||
/*--------------------------------------*/
|
||||
if (block_type == 2)
|
||||
{
|
||||
if (mixed_block_flag)
|
||||
{ /* mixed */
|
||||
if (slen1 != 0) /* long block portion */
|
||||
for (sfb = 0; sfb < 6; sfb++)
|
||||
sf[0].l[sfb] = bitget(slen1);
|
||||
else
|
||||
for (sfb = 0; sfb < 6; sfb++)
|
||||
sf[0].l[sfb] = 0;
|
||||
sfb = 3; /* start sfb for short */
|
||||
}
|
||||
else
|
||||
{ /* all short, initial short blocks */
|
||||
sfb = 0;
|
||||
if (slen1 != 0)
|
||||
for (i = 0; i < nr1; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = bitget(slen1);
|
||||
sf[0].s[1][sfb] = bitget(slen1);
|
||||
sf[0].s[2][sfb] = bitget(slen1);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < nr1; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = 0;
|
||||
sf[0].s[1][sfb] = 0;
|
||||
sf[0].s[2][sfb] = 0;
|
||||
}
|
||||
}
|
||||
/* remaining short blocks */
|
||||
if (slen2 != 0)
|
||||
for (i = 0; i < nr2; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = bitget(slen2);
|
||||
sf[0].s[1][sfb] = bitget(slen2);
|
||||
sf[0].s[2][sfb] = bitget(slen2);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < nr2; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = 0;
|
||||
sf[0].s[1][sfb] = 0;
|
||||
sf[0].s[2][sfb] = 0;
|
||||
}
|
||||
if (slen3 != 0)
|
||||
for (i = 0; i < nr3; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = bitget(slen3);
|
||||
sf[0].s[1][sfb] = bitget(slen3);
|
||||
sf[0].s[2][sfb] = bitget(slen3);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < nr3; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = 0;
|
||||
sf[0].s[1][sfb] = 0;
|
||||
sf[0].s[2][sfb] = 0;
|
||||
}
|
||||
if (slen4 != 0)
|
||||
for (i = 0; i < nr4; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = bitget(slen4);
|
||||
sf[0].s[1][sfb] = bitget(slen4);
|
||||
sf[0].s[2][sfb] = bitget(slen4);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < nr4; i++, sfb++)
|
||||
{
|
||||
sf[0].s[0][sfb] = 0;
|
||||
sf[0].s[1][sfb] = 0;
|
||||
sf[0].s[2][sfb] = 0;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* long blocks types 0 1 3 */
|
||||
sfb = 0;
|
||||
if (slen1 != 0)
|
||||
for (i = 0; i < nr1; i++, sfb++)
|
||||
sf[0].l[sfb] = bitget(slen1);
|
||||
else
|
||||
for (i = 0; i < nr1; i++, sfb++)
|
||||
sf[0].l[sfb] = 0;
|
||||
|
||||
if (slen2 != 0)
|
||||
for (i = 0; i < nr2; i++, sfb++)
|
||||
sf[0].l[sfb] = bitget(slen2);
|
||||
else
|
||||
for (i = 0; i < nr2; i++, sfb++)
|
||||
sf[0].l[sfb] = 0;
|
||||
|
||||
if (slen3 != 0)
|
||||
for (i = 0; i < nr3; i++, sfb++)
|
||||
sf[0].l[sfb] = bitget(slen3);
|
||||
else
|
||||
for (i = 0; i < nr3; i++, sfb++)
|
||||
sf[0].l[sfb] = 0;
|
||||
|
||||
if (slen4 != 0)
|
||||
for (i = 0; i < nr4; i++, sfb++)
|
||||
sf[0].l[sfb] = bitget(slen4);
|
||||
else
|
||||
for (i = 0; i < nr4; i++, sfb++)
|
||||
sf[0].l[sfb] = 0;
|
||||
}
|
||||
@ -1,127 +0,0 @@
|
||||
#include "layer3.h"
|
||||
|
||||
extern int m_channels;
|
||||
extern int m_ms_mode, m_is_mode;
|
||||
|
||||
extern SIDE_INFO m_side_info;
|
||||
|
||||
int L3get_side_info1()
|
||||
{
|
||||
int gr, ch, size;
|
||||
|
||||
m_side_info.main_data_begin = bitget(9);
|
||||
if (m_channels == 1) {
|
||||
m_side_info.private_bits = bitget(5);
|
||||
size = 17;
|
||||
}
|
||||
else {
|
||||
m_side_info.private_bits = bitget(3);
|
||||
size = 32;
|
||||
}
|
||||
for (ch = 0; ch < m_channels; ch ++)
|
||||
m_side_info.scfsi[ch] = bitget(4);
|
||||
|
||||
for (gr = 0; gr < 2; gr ++) {
|
||||
for (ch = 0; ch < m_channels; ch ++) {
|
||||
GR_INFO* gr_info = &m_side_info.gr[gr][ch];
|
||||
gr_info->part2_3_length = bitget(12);
|
||||
gr_info->big_values = bitget(9);
|
||||
gr_info->global_gain = bitget(8);
|
||||
//gr_info->global_gain += gain_adjust;
|
||||
if (m_ms_mode) gr_info->global_gain -= 2;
|
||||
gr_info->scalefac_compress = bitget(4);
|
||||
gr_info->window_switching_flag = bitget(1);
|
||||
if (gr_info->window_switching_flag) {
|
||||
gr_info->block_type = bitget(2);
|
||||
gr_info->mixed_block_flag = bitget(1);
|
||||
gr_info->table_select[0] = bitget(5);
|
||||
gr_info->table_select[1] = bitget(5);
|
||||
gr_info->subblock_gain[0] = bitget(3);
|
||||
gr_info->subblock_gain[1] = bitget(3);
|
||||
gr_info->subblock_gain[2] = bitget(3);
|
||||
/* region count set in terms of long block cb's/bands */
|
||||
/* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
|
||||
/* if(window_switching_flag) always 36 samples in region0 */
|
||||
gr_info->region0_count = (8 - 1); /* 36 samples */
|
||||
gr_info->region1_count = 20 - (8 - 1);
|
||||
}
|
||||
else {
|
||||
gr_info->mixed_block_flag = 0;
|
||||
gr_info->block_type = 0;
|
||||
gr_info->table_select[0] = bitget(5);
|
||||
gr_info->table_select[1] = bitget(5);
|
||||
gr_info->table_select[2] = bitget(5);
|
||||
gr_info->region0_count = bitget(4);
|
||||
gr_info->region1_count = bitget(3);
|
||||
}
|
||||
gr_info->preflag = bitget(1);
|
||||
gr_info->scalefac_scale = bitget(1);
|
||||
gr_info->count1table_select = bitget(1);
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
int L3get_side_info2(int gr)
|
||||
{
|
||||
int ch, size;
|
||||
|
||||
m_side_info.main_data_begin = bitget(8);
|
||||
if (m_channels == 1) {
|
||||
m_side_info.private_bits = bitget(1);
|
||||
size = 9;
|
||||
}
|
||||
else {
|
||||
m_side_info.private_bits = bitget(2);
|
||||
size = 17;
|
||||
}
|
||||
m_side_info.scfsi[0] = 0;
|
||||
m_side_info.scfsi[1] = 0;
|
||||
|
||||
for (ch = 0; ch < m_channels; ch ++) {
|
||||
m_side_info.gr[gr][ch].part2_3_length = bitget(12);
|
||||
m_side_info.gr[gr][ch].big_values = bitget(9);
|
||||
m_side_info.gr[gr][ch].global_gain = bitget(8);// + gain_adjust;
|
||||
if (m_ms_mode) m_side_info.gr[gr][ch].global_gain -= 2;
|
||||
m_side_info.gr[gr][ch].scalefac_compress = bitget(9);
|
||||
m_side_info.gr[gr][ch].window_switching_flag = bitget(1);
|
||||
if (m_side_info.gr[gr][ch].window_switching_flag) {
|
||||
m_side_info.gr[gr][ch].block_type = bitget(2);
|
||||
m_side_info.gr[gr][ch].mixed_block_flag = bitget(1);
|
||||
m_side_info.gr[gr][ch].table_select[0] = bitget(5);
|
||||
m_side_info.gr[gr][ch].table_select[1] = bitget(5);
|
||||
m_side_info.gr[gr][ch].subblock_gain[0] = bitget(3);
|
||||
m_side_info.gr[gr][ch].subblock_gain[1] = bitget(3);
|
||||
m_side_info.gr[gr][ch].subblock_gain[2] = bitget(3);
|
||||
/* region count set in terms of long block cb's/bands */
|
||||
/* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
|
||||
/* bt=1 or 3 54 samples */
|
||||
/* bt=2 mixed=0 36 samples */
|
||||
/* bt=2 mixed=1 54 (8 long sf) samples? or maybe 36 */
|
||||
/* region0 discussion says 54 but this would mix long */
|
||||
/* and short in region0 if scale factors switch */
|
||||
/* at band 36 (6 long scale factors) */
|
||||
if ((m_side_info.gr[gr][ch].block_type == 2)) {
|
||||
m_side_info.gr[gr][ch].region0_count = (6 - 1); /* 36 samples */
|
||||
m_side_info.gr[gr][ch].region1_count = 20 - (6 - 1);
|
||||
}
|
||||
else {/* long block type 1 or 3 */
|
||||
m_side_info.gr[gr][ch].region0_count = (8 - 1); /* 54 samples */
|
||||
m_side_info.gr[gr][ch].region1_count = 20 - (8 - 1);
|
||||
}
|
||||
}
|
||||
else {
|
||||
m_side_info.gr[gr][ch].mixed_block_flag = 0;
|
||||
m_side_info.gr[gr][ch].block_type = 0;
|
||||
m_side_info.gr[gr][ch].table_select[0] = bitget(5);
|
||||
m_side_info.gr[gr][ch].table_select[1] = bitget(5);
|
||||
m_side_info.gr[gr][ch].table_select[2] = bitget(5);
|
||||
m_side_info.gr[gr][ch].region0_count = bitget(4);
|
||||
m_side_info.gr[gr][ch].region1_count = bitget(3);
|
||||
}
|
||||
m_side_info.gr[gr][ch].preflag = 0;
|
||||
m_side_info.gr[gr][ch].scalefac_scale = bitget(1);
|
||||
m_side_info.gr[gr][ch].count1table_select = bitget(1);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
@ -1,52 +0,0 @@
|
||||
#include "bstream.h"
|
||||
#include "mp3dec.h"
|
||||
|
||||
typedef struct {
|
||||
uint part2_3_length;
|
||||
uint big_values;
|
||||
uint global_gain;
|
||||
uint scalefac_compress;
|
||||
uint window_switching_flag;
|
||||
uint block_type;
|
||||
uint mixed_block_flag;
|
||||
uint table_select[3];
|
||||
uint subblock_gain[3];
|
||||
uint region0_count;
|
||||
uint region1_count;
|
||||
uint preflag;
|
||||
uint scalefac_scale;
|
||||
uint count1table_select;
|
||||
} GR_INFO;
|
||||
|
||||
typedef struct {
|
||||
uint main_data_begin;
|
||||
uint private_bits;
|
||||
|
||||
uint scfsi[2]; /* 4 bit flags [ch] */
|
||||
GR_INFO gr[2][2]; /* [gr][ch] */
|
||||
} SIDE_INFO;
|
||||
|
||||
typedef struct {
|
||||
int l[23]; /* [cb] */
|
||||
int s[3][13]; /* [window][cb] */
|
||||
} SCALE_FACTOR;
|
||||
|
||||
typedef struct {
|
||||
int cbtype; /* long=0 short=1 */
|
||||
int cbmax; /* max crit band */
|
||||
int lb_type; /* long block type 0 1 3 */
|
||||
int cbs0; /* short band start index 0 3 12 (12=no shorts */
|
||||
int ncbl; /* number long cb's 0 8 21 */
|
||||
int cbmax_s[3]; /* cbmax by individual short blocks */
|
||||
} CB_INFO;
|
||||
|
||||
typedef struct {
|
||||
int nr[3];
|
||||
int slen[3];
|
||||
int intensity_scale;
|
||||
} IS_SF_INFO;
|
||||
|
||||
typedef union {
|
||||
int s;
|
||||
float x;
|
||||
} SAMPLE;
|
||||
@ -1,513 +0,0 @@
|
||||
#include "mp3dec.h"
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
typedef unsigned char byte;
|
||||
typedef unsigned int uint;
|
||||
typedef unsigned short ushort;
|
||||
|
||||
static const int br_tbl[3][3][16] = {
|
||||
{// MPEG-1
|
||||
// Layer1
|
||||
{ 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },
|
||||
// Layer2
|
||||
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },
|
||||
// Layer3
|
||||
{ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0 },
|
||||
},
|
||||
{// MPEG-2
|
||||
// Layer1
|
||||
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
|
||||
// Layer2
|
||||
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
|
||||
// Layer3
|
||||
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
|
||||
},
|
||||
{// MPEG-2.5
|
||||
// Layer1 (not available)
|
||||
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
|
||||
// Layer2 (not available)
|
||||
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
|
||||
// Layer3
|
||||
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
|
||||
},
|
||||
};
|
||||
|
||||
static const int fr_tbl[3][4] = {
|
||||
// MPEG-1
|
||||
{ 44100, 48000, 32000, 0/*reserved*/ },
|
||||
// MPEG-2
|
||||
{ 22050, 24000, 16000, 0/*reserved*/ },
|
||||
// MPEG-2.5
|
||||
{ 11025, 12000, 8000, 0/*reserved*/ },
|
||||
};
|
||||
/* 1999/11/01<30>í<EFBFBD>œ
|
||||
static const double ms_p_f_table[3][3] =
|
||||
{
|
||||
// Layer1
|
||||
{8.707483f, 8.0f, 12.0f},
|
||||
// Layer2
|
||||
{26.12245f, 24.0f, 36.0f},
|
||||
// Layer3
|
||||
{26.12245f, 24.0f, 36.0f},
|
||||
};
|
||||
*/
|
||||
typedef void (*FRAME_PROC) (MPEG_HEADER* h, byte* mpeg, byte* pcm);
|
||||
|
||||
MPEG_DECODE_OPTION m_option;
|
||||
FRAME_PROC m_frame_proc;
|
||||
int m_last_error;
|
||||
int m_frequency;
|
||||
int m_frame_size, m_pcm_size;
|
||||
int m_enableEQ;
|
||||
float m_equalizer[32];
|
||||
//float m_band_tbl[2][32];
|
||||
|
||||
void L1table_init();
|
||||
void L2table_init();
|
||||
void L3table_init();
|
||||
void L1decode_start(MPEG_HEADER* h);
|
||||
void L2decode_start(MPEG_HEADER* h);
|
||||
void L3decode_start(MPEG_HEADER* h);
|
||||
void L1decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
|
||||
void L2decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
|
||||
void L3decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
|
||||
|
||||
void _stdcall debug_out_hex(unsigned int val);
|
||||
void debug_out_str(char* str);
|
||||
|
||||
|
||||
void mp3DecodeInit()
|
||||
{
|
||||
// _set_SSE2_enable(0);
|
||||
|
||||
m_option.reduction = 0;
|
||||
m_option.convert = 0;
|
||||
m_option.freqLimit = 24000;
|
||||
|
||||
L1table_init();
|
||||
L2table_init();
|
||||
L3table_init();
|
||||
}
|
||||
|
||||
int mp3GetHeader(byte* buf, MPEG_HEADER* h)
|
||||
{
|
||||
h->version = (buf[1] & 0x08) >> 3;
|
||||
h->layer = (buf[1] & 0x06) >> 1;
|
||||
h->error_prot = (buf[1] & 0x01);
|
||||
h->br_index = (buf[2] & 0xf0) >> 4;
|
||||
h->fr_index = (buf[2] & 0x0c) >> 2;
|
||||
h->padding = (buf[2] & 0x02) >> 1;
|
||||
h->extension = (buf[2] & 0x01);
|
||||
h->mode = (buf[3] & 0xc0) >> 6;
|
||||
h->mode_ext = (buf[3] & 0x30) >> 4;
|
||||
h->copyright = (buf[3] & 0x08) >> 3;
|
||||
h->original = (buf[3] & 0x04) >> 2;
|
||||
h->emphasis = (buf[3] & 0x03);
|
||||
|
||||
if (buf[0] != 0xFF) {//sync error
|
||||
m_last_error = MP3_ERROR_INVALID_SYNC;
|
||||
return 0;
|
||||
}
|
||||
if ((buf[1] & 0xF0) == 0xF0) //MPEG-1, MPEG-2
|
||||
h->version = (h->version) ? 1 : 2;
|
||||
else if ((buf[1] & 0xF0) == 0xE0) //MPEG-2.5
|
||||
h->version = 3;
|
||||
else {
|
||||
m_last_error = MP3_ERROR_INVALID_SYNC;
|
||||
return 0;
|
||||
}
|
||||
if (h->fr_index >= 3 ||
|
||||
h->br_index == 0 || h->br_index >= 15 ||
|
||||
h->layer == 0 || h->layer >= 4) {
|
||||
m_last_error = MP3_ERROR_INVALID_HEADER;
|
||||
return 0;
|
||||
}
|
||||
h->layer = 4 - h->layer;
|
||||
h->error_prot = (h->error_prot) ? 0 : 1;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mp3GetLastError()
|
||||
{
|
||||
return m_last_error;
|
||||
}
|
||||
|
||||
int mp3FindSync(byte* buf, int size, int* sync)
|
||||
{
|
||||
int i;
|
||||
|
||||
*sync = 0;
|
||||
size -= 3;
|
||||
if (size <= 0) {
|
||||
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
|
||||
return 0;
|
||||
}
|
||||
for (i = 0; i < size; i ++) {
|
||||
if (buf[i] == 0xFF) {
|
||||
if ((buf[i + 1] & 0xF0) == 0xF0) {
|
||||
break;
|
||||
}
|
||||
else if ((buf[i + 1] & 0xF0) == 0xE0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (i == size) {
|
||||
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
|
||||
return 0;
|
||||
}
|
||||
*sync = i;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void mp3GetDecodeOption(MPEG_DECODE_OPTION* option)
|
||||
{
|
||||
*option = m_option;
|
||||
}
|
||||
|
||||
int mp3SetDecodeOption(MPEG_DECODE_OPTION* option)
|
||||
{
|
||||
m_option = *option;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mp3SetEqualizer(int* value)
|
||||
{
|
||||
int i;
|
||||
if (value == (void*)0) {
|
||||
m_enableEQ = 0;
|
||||
return 1;
|
||||
}
|
||||
m_enableEQ = 1;
|
||||
//60, 170, 310, 600, 1K, 3K
|
||||
for (i = 0; i < 6; i ++) {
|
||||
m_equalizer[i] = (float)pow_test(10,(double)value[i]/200);
|
||||
}
|
||||
//6K
|
||||
m_equalizer[6] = (float)pow_test(10,(double)value[6]/200);
|
||||
m_equalizer[7] = m_equalizer[6];
|
||||
//12K
|
||||
m_equalizer[8] = (float)pow_test(10,(double)value[7]/200);
|
||||
m_equalizer[9] = m_equalizer[8];
|
||||
m_equalizer[10] = m_equalizer[8];
|
||||
m_equalizer[11] = m_equalizer[8];
|
||||
//14K
|
||||
m_equalizer[12] = (float)pow_test(10,(double)value[8]/200);
|
||||
m_equalizer[13] = m_equalizer[12];
|
||||
m_equalizer[14] = m_equalizer[12];
|
||||
m_equalizer[15] = m_equalizer[12];
|
||||
m_equalizer[16] = m_equalizer[12];
|
||||
m_equalizer[17] = m_equalizer[12];
|
||||
m_equalizer[18] = m_equalizer[12];
|
||||
m_equalizer[19] = m_equalizer[12];
|
||||
//16K
|
||||
m_equalizer[20] = (float)pow_test(10,(double)value[9]/200);
|
||||
m_equalizer[21] = m_equalizer[20];
|
||||
m_equalizer[22] = m_equalizer[20];
|
||||
m_equalizer[23] = m_equalizer[20];
|
||||
m_equalizer[24] = m_equalizer[20];
|
||||
m_equalizer[25] = m_equalizer[20];
|
||||
m_equalizer[26] = m_equalizer[20];
|
||||
m_equalizer[27] = m_equalizer[20];
|
||||
m_equalizer[28] = m_equalizer[20];
|
||||
m_equalizer[29] = m_equalizer[20];
|
||||
m_equalizer[30] = m_equalizer[20];
|
||||
m_equalizer[31] = m_equalizer[20];
|
||||
return 1;
|
||||
}
|
||||
|
||||
#define VBR_FRAMES_FLAG 0x0001
|
||||
#define VBR_BYTES_FLAG 0x0002
|
||||
#define VBR_TOC_FLAG 0x0004
|
||||
#define VBR_SCALE_FLAG 0x0008
|
||||
|
||||
static int extractInt4(byte* buf)
|
||||
{// big endian extract
|
||||
return buf[3] | (buf[2] << 8) |
|
||||
(buf[1] << 16) | (buf[0] << 24);
|
||||
}
|
||||
|
||||
int mp3GetDecodeInfo(byte* mpeg, int size, MPEG_DECODE_INFO* info, int decFlag)
|
||||
{
|
||||
MPEG_HEADER* h = &info->header;
|
||||
byte* p = mpeg;
|
||||
int vbr;
|
||||
uint minBitRate, maxBitRate;
|
||||
uint i, j, flags;
|
||||
|
||||
|
||||
//int bitRate;
|
||||
//int frame_size;
|
||||
|
||||
if (size < 156) {//max vbr header size
|
||||
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
|
||||
return 0;
|
||||
}
|
||||
if (!mp3GetHeader(p, h)) {
|
||||
return 0;
|
||||
}
|
||||
//check VBR Header
|
||||
p += 4;//skip mpeg header
|
||||
if (h->error_prot) p += 2;//skip crc
|
||||
if (h->layer == 3) {//skip side info
|
||||
if (h->version == 1) {//MPEG-1
|
||||
if (h->mode != 3) p += 32;
|
||||
else p += 17;
|
||||
}
|
||||
else {//MPEG-2, MPEG-2.5
|
||||
if (h->mode != 3) p += 17;
|
||||
else p += 9;
|
||||
}
|
||||
}
|
||||
|
||||
info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
|
||||
info->frequency = fr_tbl[h->version-1][h->fr_index];
|
||||
if (memcmp(p, "Xing", 4) == 0) {//VBR
|
||||
p += 4;
|
||||
flags = extractInt4(p);
|
||||
p += 4;
|
||||
if (!(flags & (VBR_FRAMES_FLAG | VBR_BYTES_FLAG))) {
|
||||
m_last_error = MP3_ERROR_INVALID_HEADER;
|
||||
return 0;
|
||||
}
|
||||
info->frames = extractInt4(p);
|
||||
p += 4;
|
||||
info->dataSize = extractInt4(p);
|
||||
p += 4;
|
||||
if (flags & VBR_TOC_FLAG) p += 100;
|
||||
if (flags & VBR_SCALE_FLAG) p += 4;
|
||||
|
||||
/*/////////////////////////////////
|
||||
//•W<E280A2>€VBR‘Ήž
|
||||
if ( p[0] == mpeg[0] && p[1] == mpeg[1] ) {
|
||||
info->skipSize = (int)(p - mpeg);
|
||||
} else {
|
||||
info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
|
||||
switch (h->layer) {
|
||||
case 1://layer1
|
||||
m_frame_size = (12 * info->bitRate / fr_tbl[h->version-1][h->fr_index]) * 4;//one slot is 4 bytes long
|
||||
if (h->padding) m_frame_size += 4;
|
||||
break;
|
||||
case 2://layer2
|
||||
m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index];
|
||||
if (h->padding) m_frame_size ++;
|
||||
break;
|
||||
case 3://layer3
|
||||
m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index];
|
||||
if (h->version != 1) //MPEG-2, MPEG-2.5
|
||||
m_frame_size /= 2;
|
||||
if (h->padding) m_frame_size;
|
||||
break;
|
||||
}
|
||||
info->skipSize = (int)(m_frame_size);
|
||||
}
|
||||
info->bitRate = 0;
|
||||
/////////////////////////////////*/
|
||||
|
||||
vbr = 1;
|
||||
minBitRate = 0xffffffff;
|
||||
maxBitRate = 0;
|
||||
for (i = 1; i < 15; i ++) {
|
||||
j = br_tbl[h->version-1][h->layer-1][i] * 1000;
|
||||
if (j < minBitRate) minBitRate = j;
|
||||
if (j > maxBitRate) maxBitRate = j;
|
||||
}
|
||||
}
|
||||
else if (memcmp(p, "VBRI", 4) == 0) {//VBRI
|
||||
p += 10;
|
||||
info->dataSize = extractInt4(p);
|
||||
p += 4;
|
||||
info->frames = extractInt4(p);
|
||||
p += 4;
|
||||
vbr = 1;
|
||||
minBitRate = 0xffffffff;
|
||||
maxBitRate = 0;
|
||||
for (i = 1; i < 15; i ++) {
|
||||
j = br_tbl[h->version-1][h->layer-1][i] * 1000;
|
||||
if (j < minBitRate) minBitRate = j;
|
||||
if (j > maxBitRate) maxBitRate = j;
|
||||
}
|
||||
}
|
||||
else {//not VBR
|
||||
vbr = 0;
|
||||
info->frames = 0;
|
||||
//info->skipSize = 0;
|
||||
info->dataSize = 0;
|
||||
//info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
|
||||
}
|
||||
|
||||
// info->frequency = fr_tbl[h->version-1][h->fr_index];
|
||||
// info->msPerFrame = ms_p_f_table[h->layer-1][h->fr_index];
|
||||
// if (h->version == 3) info->msPerFrame *= 2;
|
||||
switch (h->layer) {
|
||||
case 1://layer1
|
||||
info->outputSize = 384 >> m_option.reduction;
|
||||
//if (info->bitRate) {
|
||||
if (!vbr) {
|
||||
info->skipSize = 0;
|
||||
info->minInputSize = (12 * info->bitRate / info->frequency) * 4;//one slot is 4 bytes long
|
||||
info->maxInputSize = info->minInputSize + 4;
|
||||
}
|
||||
else {
|
||||
info->skipSize = (12 * info->bitRate / info->frequency + h->padding) * 4;
|
||||
info->minInputSize = (12 * minBitRate / info->frequency) * 4;
|
||||
info->maxInputSize = (12 * maxBitRate / info->frequency) * 4 + 4;
|
||||
}
|
||||
break;
|
||||
case 2://layer2
|
||||
info->outputSize = 1152 >> m_option.reduction;
|
||||
//if (info->bitRate) {
|
||||
if (!vbr) {
|
||||
info->skipSize = 0;
|
||||
info->minInputSize = 144 * info->bitRate / info->frequency;
|
||||
info->maxInputSize = info->minInputSize + 1;
|
||||
}
|
||||
else {
|
||||
info->skipSize = 144 * info->bitRate / info->frequency + h->padding;
|
||||
info->minInputSize = 144 * minBitRate / info->frequency;
|
||||
info->maxInputSize = 144 * maxBitRate / info->frequency + 1;
|
||||
}
|
||||
break;
|
||||
case 3://layer3
|
||||
i = (h->version == 1) ? 1 : 2;
|
||||
//info->outputSize = 1152 >> m_option.reduction;
|
||||
info->outputSize = (1152 >> m_option.reduction) / i;
|
||||
//if (info->bitRate) {
|
||||
if (!vbr) {
|
||||
info->skipSize = 0;
|
||||
info->minInputSize = 144 * info->bitRate / info->frequency / i;
|
||||
info->maxInputSize = info->minInputSize + 1;
|
||||
}
|
||||
else {
|
||||
info->skipSize = 144 * info->bitRate / info->frequency / i + h->padding;
|
||||
info->minInputSize = 144 * minBitRate / info->frequency / i;
|
||||
info->maxInputSize = 144 * maxBitRate / info->frequency / i + 1;
|
||||
}
|
||||
break;
|
||||
|
||||
/*
|
||||
if (h->version != 1) {
|
||||
//MPEG-2, MPEG-2.5
|
||||
info->outputSize /= 2;
|
||||
info->minInputSize /= 2;
|
||||
info->maxInputSize /= 2;
|
||||
}
|
||||
info->maxInputSize ++;
|
||||
break; */
|
||||
|
||||
}
|
||||
|
||||
if ((h->mode == 3) || (m_option.convert & 3))
|
||||
info->channels = 1;
|
||||
else
|
||||
info->channels = 2;
|
||||
if (m_option.convert & 8) {
|
||||
//not available
|
||||
info->bitsPerSample = 8;
|
||||
info->outputSize *= info->channels;
|
||||
}
|
||||
else {
|
||||
info->bitsPerSample = 16;
|
||||
info->outputSize *= info->channels * 2;
|
||||
}
|
||||
if ( decFlag == 1 ) {
|
||||
m_frequency = info->frequency;
|
||||
m_pcm_size = info->outputSize;
|
||||
}
|
||||
info->frequency >>= m_option.reduction;
|
||||
if (vbr) info->bitRate = 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void sbt_init();
|
||||
|
||||
int mp3DecodeStart(byte* mpeg, int size)
|
||||
{
|
||||
MPEG_DECODE_INFO info;
|
||||
MPEG_HEADER* h = &info.header;
|
||||
|
||||
if (!mp3GetDecodeInfo(mpeg, size, &info, 1)) {
|
||||
return 0;
|
||||
}
|
||||
sbt_init();
|
||||
switch (h->layer) {
|
||||
case 1:
|
||||
L1decode_start(h);
|
||||
m_frame_proc = L1decode_frame;
|
||||
break;
|
||||
case 2:
|
||||
L2decode_start(h);
|
||||
m_frame_proc = L2decode_frame;
|
||||
break;
|
||||
case 3:
|
||||
L3decode_start(h);
|
||||
m_frame_proc = L3decode_frame;
|
||||
break;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mp3DecodeFrame(MPEG_DECODE_PARAM* param)
|
||||
{
|
||||
MPEG_HEADER* h = ¶m->header;
|
||||
|
||||
if (param->inputSize <= 4) {
|
||||
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
|
||||
return 0;
|
||||
}
|
||||
if (!mp3GetHeader(param->inputBuf, h)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
param->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
|
||||
switch (h->layer) {
|
||||
case 1://layer1
|
||||
m_frame_size = (12 * param->bitRate / m_frequency + h->padding) * 4;
|
||||
break;
|
||||
case 2://layer2
|
||||
m_frame_size = 144 * param->bitRate / m_frequency + h->padding;
|
||||
break;
|
||||
case 3://layer3
|
||||
if (h->version == 1) m_frame_size = 144 * param->bitRate / m_frequency + h->padding;
|
||||
else m_frame_size = (144 * param->bitRate / m_frequency) / 2 + h->padding;
|
||||
break;
|
||||
}
|
||||
if (param->inputSize < m_frame_size) {
|
||||
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
|
||||
return 0;
|
||||
}
|
||||
|
||||
m_frame_proc(h, param->inputBuf, param->outputBuf);
|
||||
param->inputSize = m_frame_size;
|
||||
param->outputSize = m_pcm_size;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void null_frame_proc(MPEG_HEADER* h, byte* mpeg, byte* pcm) {}
|
||||
void L3decode_reset();
|
||||
|
||||
void mp3MuteStart(MPEG_DECODE_PARAM* param)
|
||||
{
|
||||
m_frame_proc = null_frame_proc;
|
||||
}
|
||||
|
||||
void mp3MuteEnd(MPEG_DECODE_PARAM* param)
|
||||
{
|
||||
MPEG_HEADER* h = ¶m->header;
|
||||
|
||||
switch (h->layer) {
|
||||
case 1:
|
||||
m_frame_proc = L1decode_frame;
|
||||
break;
|
||||
case 2:
|
||||
m_frame_proc = L2decode_frame;
|
||||
break;
|
||||
case 3:
|
||||
L3decode_reset();
|
||||
m_frame_proc = L3decode_frame;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -1,76 +0,0 @@
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define MP3_ERROR_UNKNOWN 1
|
||||
#define MP3_ERROR_INVALID_PARAMETER 2
|
||||
#define MP3_ERROR_INVALID_SYNC 3
|
||||
#define MP3_ERROR_INVALID_HEADER 4
|
||||
#define MP3_ERROR_OUT_OF_BUFFER 5
|
||||
|
||||
typedef struct {
|
||||
int version; //1:MPEG-1, 2:MPEG-2, 3:MPEG-2.5
|
||||
int layer; //1:Layer1, 2:Layer2, 3:Layer3
|
||||
int error_prot; //1:CRC on, 0:CRC off
|
||||
int br_index;
|
||||
int fr_index;
|
||||
int padding;
|
||||
int extension;
|
||||
int mode;
|
||||
int mode_ext;
|
||||
int copyright;
|
||||
int original;
|
||||
int emphasis;
|
||||
} MPEG_HEADER;
|
||||
|
||||
typedef struct {
|
||||
int reduction;
|
||||
int convert;
|
||||
int freqLimit;
|
||||
} MPEG_DECODE_OPTION;
|
||||
|
||||
typedef struct {
|
||||
MPEG_HEADER header;
|
||||
int channels; //出力チャネル
|
||||
int bitsPerSample; //
|
||||
int frequency; //サンプリングレート（Hz）
|
||||
int bitRate; //ビットレート（bps）
|
||||
|
||||
int frames; //フレーム数（VBR only）
|
||||
int skipSize; //（VBR only）
|
||||
int dataSize; //データサイズ（VBR only）
|
||||
|
||||
int minInputSize; //1フレームの最小入力サイズ
|
||||
int maxInputSize; //1フレームの最大入力サイズ
|
||||
int outputSize; //1フレームの出力サイズ
|
||||
} MPEG_DECODE_INFO;
|
||||
|
||||
typedef struct {
|
||||
MPEG_HEADER header;
|
||||
int bitRate; //ビットレート（bps）
|
||||
|
||||
void* inputBuf;
|
||||
int inputSize;
|
||||
void* outputBuf;
|
||||
int outputSize;
|
||||
} MPEG_DECODE_PARAM;
|
||||
|
||||
void mp3DecodeInit();
|
||||
int mp3GetLastError();
|
||||
int mp3SetDecodeOption(MPEG_DECODE_OPTION* option);
|
||||
void mp3GetDecodeOption(MPEG_DECODE_OPTION* option);
|
||||
int mp3SetEqualizer(int* value);
|
||||
|
||||
int mp3FindSync(void* buf, int size, int* sync);
|
||||
int mp3GetDecodeInfo(void* mpeg, int size, MPEG_DECODE_INFO* info, int decFlag);
|
||||
int mp3DecodeStart(void* buf, int size);
|
||||
int mp3DecodeFrame(MPEG_DECODE_PARAM* param);
|
||||
|
||||
void mp3MuteStart(MPEG_DECODE_PARAM* param);
|
||||
void mp3MuteEnd(MPEG_DECODE_PARAM* param);
|
||||
|
||||
double pow_test(double, double);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@ -1,355 +0,0 @@
|
||||
; ix87 specific implementation of pow function.
|
||||
; Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
|
||||
; This file is part of the GNU C Library.
|
||||
; Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
|
||||
|
||||
; The GNU C Library is free software; you can redistribute it and/or
|
||||
; modify it under the terms of the GNU Library General Public License as
|
||||
; published by the Free Software Foundation; either version 2 of the
|
||||
; License, or (at your option) any later version.
|
||||
|
||||
; The GNU C Library is distributed in the hope that it will be useful,
|
||||
; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
; Library General Public License for more details.
|
||||
|
||||
; You should have received a copy of the GNU Library General Public
|
||||
; License along with the GNU C Library; see the file COPYING.LIB. If not,
|
||||
; write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
; Boston, MA 02111-1307, USA. */
|
||||
|
||||
format MS COFF
|
||||
|
||||
include 'proc32.inc'
|
||||
|
||||
section '.text' code readable executable
|
||||
|
||||
;public _pow_test@8
|
||||
|
||||
public _scalbn
|
||||
|
||||
align 4
|
||||
proc _scalbn
|
||||
fild dword [esp+12]
|
||||
fld qword [esp+4]
|
||||
fscale
|
||||
fstp st1
|
||||
ret
|
||||
endp
|
||||
|
||||
proc _pow_test@8 stdcall x:dword, y:dword
|
||||
fld [x]
|
||||
fld [y]
|
||||
jmp __CIpow
|
||||
|
||||
|
||||
__CIpow:
|
||||
; fldl 12(%esp) // y
|
||||
|
||||
fxam
|
||||
|
||||
fnstsw ax
|
||||
mov dl,ah
|
||||
and ah, 0x45
|
||||
cmp ah, 0x40 ; is y == 0 ?
|
||||
je .L_11
|
||||
|
||||
cmp ah, 0x05 ; is y == ±inf ?
|
||||
je .L_12
|
||||
|
||||
cmp ah, 0x01 ; is y == NaN ?
|
||||
je .L_30
|
||||
|
||||
fxch
|
||||
|
||||
sub esp, 8
|
||||
|
||||
fxam
|
||||
fnstsw ax
|
||||
mov dh, ah
|
||||
and ah, 0x45
|
||||
cmp ah, 0x40
|
||||
je .L_20 ; x is ±0
|
||||
|
||||
cmp ah, 0x05
|
||||
je .L_15 ; x is ±inf
|
||||
|
||||
fxch ; y : x
|
||||
|
||||
; First see whether `y' is a natural number. In this case we
|
||||
; can use a more precise algorithm. */
|
||||
|
||||
fld st ; y : y : x
|
||||
fistp qword [esp] ; y : x
|
||||
fild qword [esp] ; int(y) : y : x
|
||||
fucomp st1 ; y : x
|
||||
fnstsw ax
|
||||
sahf
|
||||
jne .L_2
|
||||
|
||||
; OK, we have an integer value for y. */
|
||||
|
||||
pop eax
|
||||
pop edx
|
||||
or edx,0
|
||||
fstp st0 ; x
|
||||
jns .L_4 ; y >= 0, jump
|
||||
fidiv dword [one] ; 1/x (now referred to as x)
|
||||
neg eax
|
||||
adc edx,0
|
||||
neg edx
|
||||
.L_4:
|
||||
fld1 ; 1 : x
|
||||
fxch
|
||||
.L_6:
|
||||
shrd edx, eax,1
|
||||
jnc .L_5
|
||||
fxch
|
||||
fmul st1,st0 ; x : ST*x
|
||||
fxch
|
||||
.L_5:
|
||||
fmul st0, st0 ; x*x : ST*x
|
||||
shr edx,1
|
||||
mov ecx, eax
|
||||
or ecx, edx
|
||||
jnz .L_6
|
||||
fstp st0 ; ST*x
|
||||
.L_30:
|
||||
ret
|
||||
|
||||
align 4
|
||||
|
||||
; y is a real number. */
|
||||
|
||||
.L_2:
|
||||
fxch ; x : y
|
||||
fld1 ; 1.0 : x : y
|
||||
fld st1 ; x : 1.0 : x : y
|
||||
fsub st0,st1 ; x-1 : 1.0 : x : y
|
||||
fabs ; |x-1| : 1.0 : x : y
|
||||
fcomp qword [limit] ; 1.0 : x : y
|
||||
fnstsw ax
|
||||
fxch ; x : 1.0 : y
|
||||
sahf
|
||||
ja .L_7
|
||||
fsub st0, st1 ; x-1 : 1.0 : y
|
||||
fyl2xp1 ; log2(x) : y
|
||||
jmp .L_8
|
||||
.L_7:
|
||||
fyl2x ; log2(x) : y
|
||||
.L_8:
|
||||
fmul st0,st1 ; y*log2(x) : y
|
||||
fst st1 ; y*log2(x) : y*log2(x)
|
||||
frndint ; int(y*log2(x)) : y*log2(x)
|
||||
fsubr st1, st0 ; int(y*log2(x)) : fract(y*log2(x))
|
||||
fxch ; fract(y*log2(x)) : int(y*log2(x))
|
||||
f2xm1 ; 2^fract(y*log2(x))-1 : int(y*log2(x))
|
||||
fld1
|
||||
faddp ; 2^fract(y*log2(x)) : int(y*log2(x))
|
||||
fscale ; 2^fract(y*log2(x))*2^int(y*log2(x)) : int(y*log2(x))
|
||||
add esp,8
|
||||
fstp st1 ; 2^fract(y*log2(x))*2^int(y*log2(x))
|
||||
ret
|
||||
|
||||
|
||||
align 4
|
||||
; // pow(x,±0) = 1
|
||||
|
||||
.L_11:
|
||||
fstp st0 ; pop y
|
||||
fld1
|
||||
ret
|
||||
|
||||
align 4
|
||||
|
||||
; y == ±inf
|
||||
|
||||
.L_12:
|
||||
fstp st0 ; pop y
|
||||
; fld 4(%esp) ; x
|
||||
fabs
|
||||
fcomp qword [one] ; < 1, == 1, or > 1
|
||||
fnstsw ax
|
||||
and ah,0x45
|
||||
cmp ah,0x45
|
||||
je .L_13 ; jump if x is NaN
|
||||
|
||||
cmp ah,0x40
|
||||
je .L_14 ; jump if |x| == 1
|
||||
|
||||
shl ah, 1
|
||||
xor ah, dl
|
||||
and edx, 2
|
||||
fld qword [inf_zero+edx+4]
|
||||
ret
|
||||
|
||||
align 4
|
||||
.L_14:
|
||||
fld qword [infinity]
|
||||
fmul qword [zero] ; raise invalid exception
|
||||
ret
|
||||
|
||||
align 4
|
||||
.L_13:
|
||||
; //fld 4(%esp) // load x == NaN
|
||||
ret
|
||||
|
||||
align 4
|
||||
; // x is ±inf
|
||||
.L_15:
|
||||
fstp st0 ; y
|
||||
test dh, 2
|
||||
jz .L_16 ; jump if x == +inf
|
||||
|
||||
; We must find out whether y is an odd integer.
|
||||
fld st ; y : y
|
||||
fistp qword [esp] ; y
|
||||
fild qword [esp] ; int(y) : y
|
||||
fucompp ; <empty>
|
||||
fnstsw ax
|
||||
sahf
|
||||
jne .L_17
|
||||
|
||||
; OK, the value is an integer, but is the number of bits small
|
||||
; enough so that all are coming from the mantissa?
|
||||
pop eax
|
||||
pop edx
|
||||
and al, 1
|
||||
jz .L_18 ;// jump if not odd
|
||||
mov eax, edx
|
||||
or edx, eax
|
||||
jns .L_155
|
||||
neg eax
|
||||
.L_155:
|
||||
cmp eax, 0x00200000
|
||||
ja .L_18 ;// does not fit in mantissa bits
|
||||
; It's an odd integer.
|
||||
shr edx, 31
|
||||
fld qword [minf_mzero+edx+8]
|
||||
ret
|
||||
|
||||
align 4
|
||||
|
||||
.L_16:
|
||||
fcomp qword [zero]
|
||||
add esp, 8
|
||||
fnstsw ax
|
||||
shr eax, 5
|
||||
and eax, 8
|
||||
fld qword [inf_zero+eax+1]
|
||||
ret
|
||||
|
||||
align 4
|
||||
.L_17:
|
||||
shl edx, 30 ;// sign bit for y in right position
|
||||
add esp ,8
|
||||
.L_18:
|
||||
shr edx, 31
|
||||
fld qword [inf_zero+edx+8]
|
||||
ret
|
||||
|
||||
align 4
|
||||
; x is ±0
|
||||
.L_20:
|
||||
fstp st0 ; y
|
||||
test dl,2
|
||||
jz .L_21 ; y > 0
|
||||
|
||||
;x is ±0 and y is < 0. We must find out whether y is an odd integer.
|
||||
test dh, 2
|
||||
jz .L_25
|
||||
|
||||
fld st ; y : y
|
||||
fistp qword [esp] ; y
|
||||
fild qword [esp] ; int(y) : y
|
||||
fucompp ; <empty>
|
||||
fnstsw ax
|
||||
sahf
|
||||
jne .L_26
|
||||
|
||||
;OK, the value is an integer, but is the number of bits small
|
||||
;enough so that all are coming from the mantissa?
|
||||
|
||||
pop eax
|
||||
pop edx
|
||||
and al, 1
|
||||
jz .L_27 ; jump if not odd
|
||||
cmp edx,0xffe00000
|
||||
jbe .L_27 ; does not fit in mantissa bits
|
||||
|
||||
; It's an odd integer.
|
||||
; Raise divide-by-zero exception and get minus infinity value.
|
||||
|
||||
fld1
|
||||
fdiv qword [zero]
|
||||
fchs
|
||||
ret
|
||||
|
||||
.L_25:
|
||||
fstp st0
|
||||
.L_26:
|
||||
add esp,8
|
||||
.L_27:
|
||||
|
||||
;Raise divide-by-zero exception and get infinity value.
|
||||
|
||||
fld1
|
||||
fdiv qword [zero]
|
||||
ret
|
||||
|
||||
align 4
|
||||
|
||||
; x is ±0 and y is > 0. We must find out whether y is an odd integer.
|
||||
|
||||
.L_21:
|
||||
test dh,2
|
||||
jz .L_22
|
||||
|
||||
fld st ; y : y
|
||||
fistp qword [esp] ; y
|
||||
fild qword [esp] ; int(y) : y
|
||||
fucompp ; <empty>
|
||||
fnstsw ax
|
||||
sahf
|
||||
jne .L_23
|
||||
|
||||
; OK, the value is an integer, but is the number of bits small
|
||||
; enough so that all are coming from the mantissa?
|
||||
|
||||
pop eax
|
||||
pop edx
|
||||
and al,1
|
||||
jz .L_24 ; jump if not odd
|
||||
cmp edx,0xffe00000
|
||||
jae .L_24 ; does not fit in mantissa bits
|
||||
|
||||
; It's an odd integer.
|
||||
|
||||
fld qword [mzero]
|
||||
ret
|
||||
|
||||
.L_22:
|
||||
fstp st0
|
||||
.L_23:
|
||||
add esp,8 ; Don't use 2 x pop
|
||||
.L_24:
|
||||
fldz
|
||||
ret
|
||||
endp
|
||||
|
||||
align 4
|
||||
|
||||
inf_zero:
|
||||
infinity:
|
||||
db 0,0,0,0,0,0,0xf0,0x7f
|
||||
zero: dq 0.0
|
||||
minf_mzero:
|
||||
minfinity:
|
||||
db 0,0,0,0,0,0,0xf0,0xff
|
||||
mzero:
|
||||
db 0,0,0,0,0,0,0,0x80
|
||||
one:
|
||||
dq 1.0
|
||||
limit:
|
||||
dq 0.29
|
||||
|
||||
@ -1,394 +0,0 @@
|
||||
#include <math.h>
|
||||
|
||||
/* "fdct.c" */
|
||||
void fdct32(float *, float *);
|
||||
void fdct32_dual(float *, float *);
|
||||
void fdct32_dual_mono(float *, float *);
|
||||
void fdct16(float *, float *);
|
||||
void fdct16_dual(float *, float *);
|
||||
void fdct16_dual_mono(float *, float *);
|
||||
void fdct8(float *, float *);
|
||||
void fdct8_dual(float *, float *);
|
||||
void fdct8_dual_mono(float *, float *);
|
||||
|
||||
/* "window.c" */
|
||||
void window(float *vbuf, int vb_ptr, short *pcm);
|
||||
void window_dual(float *vbuf, int vb_ptr, short *pcm);
|
||||
void window16(float *vbuf, int vb_ptr, short *pcm);
|
||||
void window16_dual(float *vbuf, int vb_ptr, short *pcm);
|
||||
void window8(float *vbuf, int vb_ptr, short *pcm);
|
||||
void window8_dual(float *vbuf, int vb_ptr, short *pcm);
|
||||
|
||||
/* circular window buffers */
|
||||
int vb_ptr;
|
||||
int vb2_ptr;
|
||||
float vbuf[512];
|
||||
float vbuf2[512];
|
||||
|
||||
void sbt_init()
|
||||
{
|
||||
int i;
|
||||
|
||||
/* clear window vbuf */
|
||||
for (i = 0; i < 512; i++)
|
||||
{
|
||||
vbuf[i] = 0.0F;
|
||||
vbuf2[i] = 0.0F;
|
||||
}
|
||||
vb2_ptr = vb_ptr = 0;
|
||||
}
|
||||
|
||||
void sbt_mono(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32(sample, vbuf + vb_ptr);
|
||||
window(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbt_dual(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual(sample, vbuf + vb_ptr);
|
||||
fdct32_dual(sample + 1, vbuf2 + vb_ptr);
|
||||
window_dual(vbuf, vb_ptr, pcm);
|
||||
window_dual(vbuf2, vb_ptr, pcm + 1);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 64;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt_dual_mono(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual_mono(sample, vbuf + vb_ptr);
|
||||
window(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbt_dual_left(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual(sample, vbuf + vb_ptr);
|
||||
window(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt_dual_right(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
sample++; /* point to right chan */
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual(sample, vbuf + vb_ptr);
|
||||
window(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt16_mono(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16(sample, vbuf + vb_ptr);
|
||||
window16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt16_dual(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual(sample, vbuf + vb_ptr);
|
||||
fdct16_dual(sample + 1, vbuf2 + vb_ptr);
|
||||
window16_dual(vbuf, vb_ptr, pcm);
|
||||
window16_dual(vbuf2, vb_ptr, pcm + 1);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt16_dual_mono(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual_mono(sample, vbuf + vb_ptr);
|
||||
window16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt16_dual_left(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual(sample, vbuf + vb_ptr);
|
||||
window16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt16_dual_right(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
sample++;
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual(sample, vbuf + vb_ptr);
|
||||
window16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt8_mono(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8(sample, vbuf + vb_ptr);
|
||||
window8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbt8_dual(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual(sample, vbuf + vb_ptr);
|
||||
fdct8_dual(sample + 1, vbuf2 + vb_ptr);
|
||||
window8_dual(vbuf, vb_ptr, pcm);
|
||||
window8_dual(vbuf2, vb_ptr, pcm + 1);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt8_dual_mono(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual_mono(sample, vbuf + vb_ptr);
|
||||
window8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt8_dual_left(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual(sample, vbuf + vb_ptr);
|
||||
window8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt8_dual_right(float *sample, short *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
sample++;
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual(sample, vbuf + vb_ptr);
|
||||
window8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt_mono_L3(float *sample, short *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
ch = 0;
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct32(sample, vbuf + vb_ptr);
|
||||
window(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbt_dual_L3(float *sample, short *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ch == 0)
|
||||
for (i = 0; i < 18; i++) {
|
||||
fdct32(sample, vbuf + vb_ptr);
|
||||
window_dual(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 64;
|
||||
}
|
||||
else
|
||||
for (i = 0; i < 18; i++) {
|
||||
fdct32(sample, vbuf2 + vb2_ptr);
|
||||
window_dual(vbuf2, vb2_ptr, pcm + 1);
|
||||
sample += 32;
|
||||
vb2_ptr = (vb2_ptr - 32) & 511;
|
||||
pcm += 64;
|
||||
}
|
||||
}
|
||||
|
||||
void sbt16_mono_L3(float *sample, short *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
ch = 0;
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct16(sample, vbuf + vb_ptr);
|
||||
window16(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void sbt16_dual_L3(float *sample, short *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
||||
if (ch == 0)
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct16(sample, vbuf + vb_ptr);
|
||||
window16_dual(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct16(sample, vbuf2 + vb2_ptr);
|
||||
window16_dual(vbuf2, vb2_ptr, pcm + 1);
|
||||
sample += 32;
|
||||
vb2_ptr = (vb2_ptr - 16) & 255;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbt8_mono_L3(float *sample, short *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
ch = 0;
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct8(sample, vbuf + vb_ptr);
|
||||
window8(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbt8_dual_L3(float *sample, short *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ch == 0)
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct8(sample, vbuf + vb_ptr);
|
||||
window8_dual(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct8(sample, vbuf2 + vb2_ptr);
|
||||
window8_dual(vbuf2, vb2_ptr, pcm + 1);
|
||||
sample += 32;
|
||||
vb2_ptr = (vb2_ptr - 8) & 127;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
@ -1,382 +0,0 @@
|
||||
#include <math.h>
|
||||
|
||||
/* "fdct.c" */
|
||||
void fdct32(float *, float *);
|
||||
void fdct32_dual(float *, float *);
|
||||
void fdct32_dual_mono(float *, float *);
|
||||
void fdct16(float *, float *);
|
||||
void fdct16_dual(float *, float *);
|
||||
void fdct16_dual_mono(float *, float *);
|
||||
void fdct8(float *, float *);
|
||||
void fdct8_dual(float *, float *);
|
||||
void fdct8_dual_mono(float *, float *);
|
||||
|
||||
/* "windowb.c" */
|
||||
void windowB(float *vbuf, int vb_ptr, unsigned char *pcm);
|
||||
void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
|
||||
void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm);
|
||||
void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
|
||||
void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm);
|
||||
void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
|
||||
|
||||
extern int vb_ptr;
|
||||
extern int vb2_ptr;
|
||||
extern float vbuf[512];
|
||||
extern float vbuf2[512];
|
||||
|
||||
void sbtB_mono(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32(sample, vbuf + vb_ptr);
|
||||
windowB(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB_dual(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual(sample, vbuf + vb_ptr);
|
||||
fdct32_dual(sample + 1, vbuf2 + vb_ptr);
|
||||
windowB_dual(vbuf, vb_ptr, pcm);
|
||||
windowB_dual(vbuf2, vb_ptr, pcm + 1);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 64;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void sbtB_dual_mono(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual_mono(sample, vbuf + vb_ptr);
|
||||
windowB(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB_dual_left(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual(sample, vbuf + vb_ptr);
|
||||
windowB(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB_dual_right(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
sample++; /* point to right chan */
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct32_dual(sample, vbuf + vb_ptr);
|
||||
windowB(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB16_mono(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16(sample, vbuf + vb_ptr);
|
||||
windowB16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void sbtB16_dual(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual(sample, vbuf + vb_ptr);
|
||||
fdct16_dual(sample + 1, vbuf2 + vb_ptr);
|
||||
windowB16_dual(vbuf, vb_ptr, pcm);
|
||||
windowB16_dual(vbuf2, vb_ptr, pcm + 1);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual_mono(sample, vbuf + vb_ptr);
|
||||
windowB16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB16_dual_left(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual(sample, vbuf + vb_ptr);
|
||||
windowB16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB16_dual_right(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
sample++;
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct16_dual(sample, vbuf + vb_ptr);
|
||||
windowB16(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB8_mono(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8(sample, vbuf + vb_ptr);
|
||||
windowB8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB8_dual(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual(sample, vbuf + vb_ptr);
|
||||
fdct8_dual(sample + 1, vbuf2 + vb_ptr);
|
||||
windowB8_dual(vbuf, vb_ptr, pcm);
|
||||
windowB8_dual(vbuf2, vb_ptr, pcm + 1);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual_mono(sample, vbuf + vb_ptr);
|
||||
windowB8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB8_dual_left(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual(sample, vbuf + vb_ptr);
|
||||
windowB8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB8_dual_right(float *sample, unsigned char *pcm, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
sample++;
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
fdct8_dual(sample, vbuf + vb_ptr);
|
||||
windowB8(vbuf, vb_ptr, pcm);
|
||||
sample += 64;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
}
|
||||
|
||||
void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
ch = 0;
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct32(sample, vbuf + vb_ptr);
|
||||
windowB(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 32;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ch == 0)
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct32(sample, vbuf + vb_ptr);
|
||||
windowB_dual(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 32) & 511;
|
||||
pcm += 64;
|
||||
}
|
||||
else
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct32(sample, vbuf2 + vb2_ptr);
|
||||
windowB_dual(vbuf2, vb2_ptr, pcm + 1);
|
||||
sample += 32;
|
||||
vb2_ptr = (vb2_ptr - 32) & 511;
|
||||
pcm += 64;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
ch = 0;
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct16(sample, vbuf + vb_ptr);
|
||||
windowB16(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 16;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ch == 0)
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct16(sample, vbuf + vb_ptr);
|
||||
windowB16_dual(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 16) & 255;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct16(sample, vbuf2 + vb2_ptr);
|
||||
windowB16_dual(vbuf2, vb2_ptr, pcm + 1);
|
||||
sample += 32;
|
||||
vb2_ptr = (vb2_ptr - 16) & 255;
|
||||
pcm += 32;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
ch = 0;
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct8(sample, vbuf + vb_ptr);
|
||||
windowB8(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 8;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ch == 0)
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct8(sample, vbuf + vb_ptr);
|
||||
windowB8_dual(vbuf, vb_ptr, pcm);
|
||||
sample += 32;
|
||||
vb_ptr = (vb_ptr - 8) & 127;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < 18; i++)
|
||||
{
|
||||
fdct8(sample, vbuf2 + vb2_ptr);
|
||||
windowB8_dual(vbuf2, vb2_ptr, pcm + 1);
|
||||
sample += 32;
|
||||
vb2_ptr = (vb2_ptr - 8) & 127;
|
||||
pcm += 16;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,503 +0,0 @@
|
||||
// disable precision loss warning on type conversion
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable:4244 4056)
|
||||
#endif
|
||||
|
||||
float wincoef[264] =
|
||||
{ // window coefs
|
||||
0.000000000f, 0.000442505f, -0.003250122f, 0.007003784f,
|
||||
-0.031082151f, 0.078628540f, -0.100311279f, 0.572036743f,
|
||||
-1.144989014f, -0.572036743f, -0.100311279f, -0.078628540f,
|
||||
-0.031082151f, -0.007003784f, -0.003250122f, -0.000442505f,
|
||||
0.000015259f, 0.000473022f, -0.003326416f, 0.007919312f,
|
||||
-0.030517576f, 0.084182739f, -0.090927124f, 0.600219727f,
|
||||
-1.144287109f, -0.543823242f, -0.108856201f, -0.073059082f,
|
||||
-0.031478882f, -0.006118774f, -0.003173828f, -0.000396729f,
|
||||
0.000015259f, 0.000534058f, -0.003387451f, 0.008865356f,
|
||||
-0.029785154f, 0.089706421f, -0.080688477f, 0.628295898f,
|
||||
-1.142211914f, -0.515609741f, -0.116577141f, -0.067520142f,
|
||||
-0.031738281f, -0.005294800f, -0.003082275f, -0.000366211f,
|
||||
0.000015259f, 0.000579834f, -0.003433228f, 0.009841919f,
|
||||
-0.028884888f, 0.095169067f, -0.069595337f, 0.656219482f,
|
||||
-1.138763428f, -0.487472534f, -0.123474121f, -0.061996460f,
|
||||
-0.031845093f, -0.004486084f, -0.002990723f, -0.000320435f,
|
||||
0.000015259f, 0.000625610f, -0.003463745f, 0.010848999f,
|
||||
-0.027801514f, 0.100540161f, -0.057617184f, 0.683914185f,
|
||||
-1.133926392f, -0.459472656f, -0.129577637f, -0.056533810f,
|
||||
-0.031814575f, -0.003723145f, -0.002899170f, -0.000289917f,
|
||||
0.000015259f, 0.000686646f, -0.003479004f, 0.011886597f,
|
||||
-0.026535034f, 0.105819702f, -0.044784546f, 0.711318970f,
|
||||
-1.127746582f, -0.431655884f, -0.134887695f, -0.051132202f,
|
||||
-0.031661987f, -0.003005981f, -0.002792358f, -0.000259399f,
|
||||
0.000015259f, 0.000747681f, -0.003479004f, 0.012939452f,
|
||||
-0.025085449f, 0.110946655f, -0.031082151f, 0.738372803f,
|
||||
-1.120223999f, -0.404083252f, -0.139450073f, -0.045837402f,
|
||||
-0.031387329f, -0.002334595f, -0.002685547f, -0.000244141f,
|
||||
0.000030518f, 0.000808716f, -0.003463745f, 0.014022826f,
|
||||
-0.023422241f, 0.115921021f, -0.016510010f, 0.765029907f,
|
||||
-1.111373901f, -0.376800537f, -0.143264771f, -0.040634155f,
|
||||
-0.031005858f, -0.001693726f, -0.002578735f, -0.000213623f,
|
||||
0.000030518f, 0.000885010f, -0.003417969f, 0.015121460f,
|
||||
-0.021575928f, 0.120697014f, -0.001068115f, 0.791213989f,
|
||||
-1.101211548f, -0.349868774f, -0.146362305f, -0.035552979f,
|
||||
-0.030532837f, -0.001098633f, -0.002456665f, -0.000198364f,
|
||||
0.000030518f, 0.000961304f, -0.003372192f, 0.016235352f,
|
||||
-0.019531250f, 0.125259399f, 0.015228271f, 0.816864014f,
|
||||
-1.089782715f, -0.323318481f, -0.148773193f, -0.030609131f,
|
||||
-0.029937742f, -0.000549316f, -0.002349854f, -0.000167847f,
|
||||
0.000030518f, 0.001037598f, -0.003280640f, 0.017349243f,
|
||||
-0.017257690f, 0.129562378f, 0.032379150f, 0.841949463f,
|
||||
-1.077117920f, -0.297210693f, -0.150497437f, -0.025817871f,
|
||||
-0.029281614f, -0.000030518f, -0.002243042f, -0.000152588f,
|
||||
0.000045776f, 0.001113892f, -0.003173828f, 0.018463135f,
|
||||
-0.014801024f, 0.133590698f, 0.050354004f, 0.866363525f,
|
||||
-1.063217163f, -0.271591187f, -0.151596069f, -0.021179199f,
|
||||
-0.028533936f, 0.000442505f, -0.002120972f, -0.000137329f,
|
||||
0.000045776f, 0.001205444f, -0.003051758f, 0.019577026f,
|
||||
-0.012115479f, 0.137298584f, 0.069168091f, 0.890090942f,
|
||||
-1.048156738f, -0.246505737f, -0.152069092f, -0.016708374f,
|
||||
-0.027725220f, 0.000869751f, -0.002014160f, -0.000122070f,
|
||||
0.000061035f, 0.001296997f, -0.002883911f, 0.020690918f,
|
||||
-0.009231566f, 0.140670776f, 0.088775635f, 0.913055420f,
|
||||
-1.031936646f, -0.221984863f, -0.151962280f, -0.012420653f,
|
||||
-0.026840210f, 0.001266479f, -0.001907349f, -0.000106812f,
|
||||
0.000061035f, 0.001388550f, -0.002700806f, 0.021789551f,
|
||||
-0.006134033f, 0.143676758f, 0.109161377f, 0.935195923f,
|
||||
-1.014617920f, -0.198059082f, -0.151306152f, -0.008316040f,
|
||||
-0.025909424f, 0.001617432f, -0.001785278f, -0.000106812f,
|
||||
0.000076294f, 0.001480103f, -0.002487183f, 0.022857666f,
|
||||
-0.002822876f, 0.146255493f, 0.130310059f, 0.956481934f,
|
||||
-0.996246338f, -0.174789429f, -0.150115967f, -0.004394531f,
|
||||
-0.024932859f, 0.001937866f, -0.001693726f, -0.000091553f,
|
||||
-0.001586914f, -0.023910521f, -0.148422241f, -0.976852417f,
|
||||
0.152206421f, 0.000686646f, -0.002227783f, 0.000076294f,
|
||||
};
|
||||
|
||||
void window(float *vbuf, int vb_ptr, short *pcm)
|
||||
{
|
||||
int i, j;
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 16;
|
||||
bx = (si + 32) & 511;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 16 --*/
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
/*-- last 15 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 15; i++)
|
||||
{
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*------------------------------------------------------------*/
|
||||
void window_dual(float *vbuf, int vb_ptr, short *pcm)
|
||||
{
|
||||
int i, j; /* dual window interleaves output */
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 16;
|
||||
bx = (si + 32) & 511;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 16 --*/
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
/*-- last 15 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 15; i++)
|
||||
{
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
}
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
/*------------------- 16 pt window ------------------------------*/
|
||||
void window16(float *vbuf, int vb_ptr, short *pcm)
|
||||
{
|
||||
int i, j;
|
||||
unsigned char si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 8;
|
||||
bx = si + 16;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 8 --*/
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si += 32;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 16;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
/*-- last 7 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
coef -= 16;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si += 32;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
}
|
||||
}
|
||||
/*--------------- 16 pt dual window (interleaved output) -----------------*/
|
||||
void window16_dual(float *vbuf, int vb_ptr, short *pcm)
|
||||
{
|
||||
int i, j;
|
||||
unsigned char si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 8;
|
||||
bx = si + 16;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 8 --*/
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si += 32;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 16;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
/*-- last 7 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
coef -= 16;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si += 32;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
}
|
||||
}
|
||||
/*------------------- 8 pt window ------------------------------*/
|
||||
void window8(float *vbuf, int vb_ptr, short *pcm)
|
||||
{
|
||||
int i, j;
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 4;
|
||||
bx = (si + 8) & 127;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 4 --*/
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 48;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
/*-- last 3 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
coef -= 48;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = tmp;
|
||||
}
|
||||
}
|
||||
/*--------------- 8 pt dual window (interleaved output) -----------------*/
|
||||
void window8_dual(float *vbuf, int vb_ptr, short *pcm)
|
||||
{
|
||||
int i, j;
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 4;
|
||||
bx = (si + 8) & 127;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 4 --*/
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 48;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
/*-- last 3 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
coef -= 48;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = tmp;
|
||||
pcm += 2;
|
||||
}
|
||||
}
|
||||
@ -1,427 +0,0 @@
|
||||
extern float wincoef[264];
|
||||
|
||||
void windowB(float *vbuf, int vb_ptr, unsigned char *pcm)
|
||||
{
|
||||
int i, j;
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 16;
|
||||
bx = (si + 32) & 511;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 16 --*/
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
/*-- last 15 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 15; i++)
|
||||
{
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
}
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
|
||||
{
|
||||
int i, j; /* dual window interleaves output */
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 16;
|
||||
bx = (si + 32) & 511;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 16 --*/
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
/*-- last 15 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 15; i++)
|
||||
{
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 64) & 511;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 64) & 511;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
}
|
||||
}
|
||||
/*------------------------------------------------------------*/
|
||||
/*------------------- 16 pt window ------------------------------*/
|
||||
void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm)
|
||||
{
|
||||
int i, j;
|
||||
unsigned char si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 8;
|
||||
bx = si + 16;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 8 --*/
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si += 32;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 16;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
/*-- last 7 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
coef -= 16;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si += 32;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
}
|
||||
}
|
||||
/*--------------- 16 pt dual window (interleaved output) -----------------*/
|
||||
void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
|
||||
{
|
||||
int i, j;
|
||||
unsigned char si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 8;
|
||||
bx = si + 16;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 8 --*/
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si += 32;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 16;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
/*-- last 7 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
coef -= 16;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si += 32;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx += 32;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
}
|
||||
}
|
||||
/*------------------- 8 pt window ------------------------------*/
|
||||
void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm)
|
||||
{
|
||||
int i, j;
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 4;
|
||||
bx = (si + 8) & 127;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 4 --*/
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 48;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
/*-- last 3 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
coef -= 48;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
}
|
||||
}
|
||||
/*--------------- 8 pt dual window (interleaved output) -----------------*/
|
||||
void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
|
||||
{
|
||||
int i, j;
|
||||
int si, bx;
|
||||
float *coef;
|
||||
float sum;
|
||||
long tmp;
|
||||
|
||||
si = vb_ptr + 4;
|
||||
bx = (si + 8) & 127;
|
||||
coef = wincoef;
|
||||
|
||||
/*-- first 4 --*/
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum -= (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
si++;
|
||||
bx--;
|
||||
coef += 48;
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
}
|
||||
/*-- special case --*/
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef++) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
/*-- last 3 --*/
|
||||
coef = wincoef + 255; /* back pass through coefs */
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
coef -= 48;
|
||||
si--;
|
||||
bx++;
|
||||
sum = 0.0F;
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
sum += (*coef--) * vbuf[si];
|
||||
si = (si + 16) & 127;
|
||||
sum += (*coef--) * vbuf[bx];
|
||||
bx = (bx + 16) & 127;
|
||||
}
|
||||
tmp = (long) sum;
|
||||
if (tmp > 32767)
|
||||
tmp = 32767;
|
||||
else if (tmp < -32768)
|
||||
tmp = -32768;
|
||||
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
|
||||
pcm += 2;
|
||||
}
|
||||
}
|
||||
@ -1,136 +0,0 @@
|
||||
#include <stdlib.h>
|
||||
#include "mpg123.h"
|
||||
|
||||
int tabsel_123[2][3][16] = {
|
||||
{ {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
|
||||
{0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
|
||||
{0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} },
|
||||
|
||||
{ {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
|
||||
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
|
||||
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} }
|
||||
};
|
||||
|
||||
long freqs[9] = { 44100, 48000, 32000,
|
||||
22050, 24000, 16000 ,
|
||||
11025 , 12000 , 8000 };
|
||||
|
||||
#define HDRCMPMASK 0xfffffd00
|
||||
|
||||
struct bitstream_info bsi;
|
||||
|
||||
int ssize;
|
||||
|
||||
unsigned long read_header(BYTE *mpeg)
|
||||
{ unsigned long hdr;
|
||||
|
||||
hdr = *mpeg++;
|
||||
hdr <<= 8;
|
||||
hdr |= *mpeg++;
|
||||
hdr <<= 8;
|
||||
hdr |= *mpeg++;
|
||||
hdr <<= 8;
|
||||
hdr |= *mpeg++;
|
||||
return hdr;
|
||||
};
|
||||
|
||||
int head_check(unsigned long head)
|
||||
{
|
||||
if( (head & 0xffe00000) != 0xffe00000)
|
||||
return FALSE;
|
||||
if(!((head>>17)&3))
|
||||
return FALSE;
|
||||
if( ((head>>12)&0xf) == 0xf)
|
||||
return FALSE;
|
||||
if( ((head>>10)&0x3) == 0x3 )
|
||||
return FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int decode_header(struct frame *fr,unsigned long newhead)
|
||||
{
|
||||
if( newhead & (1<<20) ) {
|
||||
fr->lsf = (newhead & (1<<19)) ? 0x0 : 0x1;
|
||||
fr->mpeg25 = 0;
|
||||
}
|
||||
else {
|
||||
fr->lsf = 1;
|
||||
fr->mpeg25 = 1;
|
||||
}
|
||||
|
||||
fr->lay = 4-((newhead>>17)&3);
|
||||
if( ((newhead>>10)&0x3) == 0x3) {
|
||||
fprintf(stderr,"Stream error, reserved sampling rate\n");
|
||||
return 0;
|
||||
}
|
||||
if(fr->mpeg25) {
|
||||
fr->sampling_frequency = 6 + ((newhead>>10)&0x3);
|
||||
}
|
||||
else
|
||||
fr->sampling_frequency = ((newhead>>10)&0x3) + (fr->lsf*3);
|
||||
fr->error_protection = ((newhead>>16)&0x1)^0x1;
|
||||
|
||||
if(fr->mpeg25) /* allow Bitrate change for 2.5 ... */
|
||||
fr->bitrate_index = ((newhead>>12)&0xf);
|
||||
|
||||
fr->bitrate_index = ((newhead>>12)&0xf);
|
||||
fr->padding = ((newhead>>9)&0x1);
|
||||
fr->extension = ((newhead>>8)&0x1);
|
||||
fr->mode = ((newhead>>6)&0x3);
|
||||
fr->mode_ext = ((newhead>>4)&0x3);
|
||||
fr->copyright = ((newhead>>3)&0x1);
|
||||
fr->original = ((newhead>>2)&0x1);
|
||||
fr->emphasis = newhead & 0x3;
|
||||
|
||||
fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2;
|
||||
|
||||
if(!fr->bitrate_index)
|
||||
{
|
||||
fprintf(stderr, "Stream error, free format bitrate index not supported\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch(fr->lay)
|
||||
{
|
||||
case 1:
|
||||
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
|
||||
(fr->mode_ext<<2)+4 : 32;
|
||||
fr->framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000;
|
||||
fr->framesize /= freqs[fr->sampling_frequency];
|
||||
fr->framesize = ((fr->framesize+fr->padding)<<2)-4;
|
||||
break;
|
||||
case 2:
|
||||
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
|
||||
(fr->mode_ext<<2)+4 : fr->II_sblimit;
|
||||
fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000;
|
||||
fr->framesize /= freqs[fr->sampling_frequency];
|
||||
fr->framesize += fr->padding - 4;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
fr->do_layer = do_layer3;
|
||||
if(fr->lsf)
|
||||
ssize = (fr->stereo == 1) ? 9 : 17;
|
||||
else
|
||||
ssize = (fr->stereo == 1) ? 17 : 32;
|
||||
|
||||
if(fr->error_protection)
|
||||
ssize += 2;
|
||||
fr->framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000;
|
||||
fr->framesize /= freqs[fr->sampling_frequency]<<(fr->lsf);
|
||||
fr->framesize = fr->framesize + fr->padding - 4;
|
||||
break;
|
||||
default:
|
||||
return (0);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
//void set_pointer(long backstep)
|
||||
//{
|
||||
// bsi.wordpointer = bsbuf + ssize - backstep;
|
||||
// if (backstep)
|
||||
// memcpy(bsi.wordpointer,bsbufold+fsizeold-backstep,backstep);
|
||||
// bsi.bitindex = 0;
|
||||
//}
|
||||
|
||||
@ -1,209 +0,0 @@
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunPro, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
* from: @(#)fdlibm.h 5.1 93/09/24
|
||||
* $Id: math_private.h,v 1.8 1998/11/27 11:33:46 drepper Exp $
|
||||
*/
|
||||
|
||||
#ifndef _MATH_PRIVATE_H_
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
|
||||
/* The original fdlibm code used statements like:
|
||||
n0 = ((*(int*)&one)>>29)^1; * index of high word *
|
||||
ix0 = *(n0+(int*)&x); * high word of x *
|
||||
ix1 = *((1-n0)+(int*)&x); * low word of x *
|
||||
to dig two 32 bit words out of the 64 bit IEEE floating point
|
||||
value. That is non-ANSI, and, moreover, the gcc instruction
|
||||
scheduler gets it wrong. We instead use the following macros.
|
||||
Unlike the original code, we determine the endianness at compile
|
||||
time, not at run time; I don't see much benefit to selecting
|
||||
endianness at run time. */
|
||||
|
||||
/* A union which permits us to convert between a double and two 32 bit
|
||||
ints. */
|
||||
|
||||
typedef int int32_t;
|
||||
typedef unsigned int u_int32_t;
|
||||
|
||||
typedef union
|
||||
{
|
||||
double value;
|
||||
struct
|
||||
{
|
||||
u_int32_t lsw;
|
||||
u_int32_t msw;
|
||||
} parts;
|
||||
} ieee_double_shape_type;
|
||||
|
||||
/* Get two 32 bit ints from a double. */
|
||||
|
||||
#define EXTRACT_WORDS(ix0,ix1,d) \
|
||||
do { \
|
||||
ieee_double_shape_type ew_u; \
|
||||
ew_u.value = (d); \
|
||||
(ix0) = ew_u.parts.msw; \
|
||||
(ix1) = ew_u.parts.lsw; \
|
||||
} while (0)
|
||||
|
||||
/* Get the more significant 32 bit int from a double. */
|
||||
|
||||
#define GET_HIGH_WORD(i,d) \
|
||||
do { \
|
||||
ieee_double_shape_type gh_u; \
|
||||
gh_u.value = (d); \
|
||||
(i) = gh_u.parts.msw; \
|
||||
} while (0)
|
||||
|
||||
/* Get the less significant 32 bit int from a double. */
|
||||
|
||||
#define GET_LOW_WORD(i,d) \
|
||||
do { \
|
||||
ieee_double_shape_type gl_u; \
|
||||
gl_u.value = (d); \
|
||||
(i) = gl_u.parts.lsw; \
|
||||
} while (0)
|
||||
|
||||
/* Set a double from two 32 bit ints. */
|
||||
|
||||
#define INSERT_WORDS(d,ix0,ix1) \
|
||||
do { \
|
||||
ieee_double_shape_type iw_u; \
|
||||
iw_u.parts.msw = (ix0); \
|
||||
iw_u.parts.lsw = (ix1); \
|
||||
(d) = iw_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Set the more significant 32 bits of a double from an int. */
|
||||
|
||||
#define SET_HIGH_WORD(d,v) \
|
||||
do { \
|
||||
ieee_double_shape_type sh_u; \
|
||||
sh_u.value = (d); \
|
||||
sh_u.parts.msw = (v); \
|
||||
(d) = sh_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Set the less significant 32 bits of a double from an int. */
|
||||
|
||||
#define SET_LOW_WORD(d,v) \
|
||||
do { \
|
||||
ieee_double_shape_type sl_u; \
|
||||
sl_u.value = (d); \
|
||||
sl_u.parts.lsw = (v); \
|
||||
(d) = sl_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* A union which permits us to convert between a float and a 32 bit
|
||||
int. */
|
||||
|
||||
typedef union
|
||||
{
|
||||
float value;
|
||||
u_int32_t word;
|
||||
} ieee_float_shape_type;
|
||||
|
||||
/* Get a 32 bit int from a float. */
|
||||
|
||||
#define GET_FLOAT_WORD(i,d) \
|
||||
do { \
|
||||
ieee_float_shape_type gf_u; \
|
||||
gf_u.value = (d); \
|
||||
(i) = gf_u.word; \
|
||||
} while (0)
|
||||
|
||||
/* Set a float from a 32 bit int. */
|
||||
|
||||
#define SET_FLOAT_WORD(d,i) \
|
||||
do { \
|
||||
ieee_float_shape_type sf_u; \
|
||||
sf_u.word = (i); \
|
||||
(d) = sf_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* A union which permits us to convert between a long double and
|
||||
three 32 bit ints. */
|
||||
|
||||
|
||||
typedef union
|
||||
{
|
||||
long double value;
|
||||
struct
|
||||
{
|
||||
u_int32_t lsw;
|
||||
u_int32_t msw;
|
||||
unsigned int sign_exponent:16;
|
||||
unsigned int empty:16;
|
||||
} parts;
|
||||
} ieee_long_double_shape_type;
|
||||
|
||||
/* Get three 32 bit ints from a double. */
|
||||
|
||||
#define GET_LDOUBLE_WORDS(exp,ix0,ix1,d) \
|
||||
do { \
|
||||
ieee_long_double_shape_type ew_u; \
|
||||
ew_u.value = (d); \
|
||||
(exp) = ew_u.parts.sign_exponent; \
|
||||
(ix0) = ew_u.parts.msw; \
|
||||
(ix1) = ew_u.parts.lsw; \
|
||||
} while (0)
|
||||
|
||||
/* Set a double from two 32 bit ints. */
|
||||
|
||||
#define SET_LDOUBLE_WORDS(d,exp,ix0,ix1) \
|
||||
do { \
|
||||
ieee_long_double_shape_type iw_u; \
|
||||
iw_u.parts.sign_exponent = (exp); \
|
||||
iw_u.parts.msw = (ix0); \
|
||||
iw_u.parts.lsw = (ix1); \
|
||||
(d) = iw_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Get the more significant 32 bits of a long double mantissa. */
|
||||
|
||||
#define GET_LDOUBLE_MSW(v,d) \
|
||||
do { \
|
||||
ieee_long_double_shape_type sh_u; \
|
||||
sh_u.value = (d); \
|
||||
(v) = sh_u.parts.msw; \
|
||||
} while (0)
|
||||
|
||||
/* Set the more significant 32 bits of a long double mantissa from an int. */
|
||||
|
||||
#define SET_LDOUBLE_MSW(d,v) \
|
||||
do { \
|
||||
ieee_long_double_shape_type sh_u; \
|
||||
sh_u.value = (d); \
|
||||
sh_u.parts.msw = (v); \
|
||||
(d) = sh_u.value; \
|
||||
} while (0)
|
||||
|
||||
/* Get int from the exponent of a long double. */
|
||||
|
||||
#define GET_LDOUBLE_EXP(exp,d) \
|
||||
do { \
|
||||
ieee_long_double_shape_type ge_u; \
|
||||
ge_u.value = (d); \
|
||||
(exp) = ge_u.parts.sign_exponent; \
|
||||
} while (0)
|
||||
|
||||
/* Set exponent of a long double from an int. */
|
||||
|
||||
#define SET_LDOUBLE_EXP(d,exp) \
|
||||
do { \
|
||||
ieee_long_double_shape_type se_u; \
|
||||
se_u.value = (d); \
|
||||
se_u.parts.sign_exponent = (exp); \
|
||||
(d) = se_u.value; \
|
||||
} while (0)
|
||||
|
||||
#endif /* _MATH_PRIVATE_H_ */
|
||||
@ -1,365 +0,0 @@
|
||||
<?xml version="1.0" encoding="windows-1251"?>
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="8,00"
|
||||
Name="mpg"
|
||||
ProjectGUID="{CF807B93-2860-41DF-A4D2-5B92B52DFD96}"
|
||||
RootNamespace="mpg"
|
||||
Keyword="Win32Proj"
|
||||
>
|
||||
<Platforms>
|
||||
<Platform
|
||||
Name="Win32"
|
||||
/>
|
||||
</Platforms>
|
||||
<ToolFiles>
|
||||
</ToolFiles>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
Name="Debug|Win32"
|
||||
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||
IntermediateDirectory="$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
|
||||
MinimalRebuild="true"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="3"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="true"
|
||||
DebugInformationFormat="4"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Release|Win32"
|
||||
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
|
||||
IntermediateDirectory="$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="1"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="3"
|
||||
InlineFunctionExpansion="1"
|
||||
EnableIntrinsicFunctions="true"
|
||||
FavorSizeOrSpeed="2"
|
||||
OmitFramePointers="true"
|
||||
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
|
||||
ExceptionHandling="0"
|
||||
RuntimeLibrary="0"
|
||||
StructMemberAlignment="1"
|
||||
BufferSecurityCheck="false"
|
||||
FloatingPointModel="2"
|
||||
UsePrecompiledHeader="0"
|
||||
AssemblerOutput="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="true"
|
||||
DebugInformationFormat="3"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
<References>
|
||||
</References>
|
||||
<Files>
|
||||
<Filter
|
||||
Name="Source Files"
|
||||
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\dct64_i386.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
ExpandAttributedSource="false"
|
||||
AssemblerOutput="4"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\dct64_i486.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_2to1.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_4to1.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_i386.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_i486.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\decode_ntom.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\e_pow.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\getbits.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\layer1.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\layer2.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\layer3.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
ExpandAttributedSource="true"
|
||||
AssemblerOutput="4"
|
||||
AssemblerListingLocation="$(IntDir)\"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\pow.asm"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
CommandLine="e:\fasm\fasm.exe $(InputPath) $(TargetDir)\$(InputName).obj
"
|
||||
Outputs="$(OutDir)\$(InputName).obj"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\readers.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
ExpandAttributedSource="false"
|
||||
AssemblerOutput="4"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\tabinit.c"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Header Files"
|
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\getbits.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\huffman.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\l2tables.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\layer3.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\mpg123.h"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Resource Files"
|
||||
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
|
||||
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
|
||||
>
|
||||
<File
|
||||
RelativePath="E:\arrow.cur"
|
||||
FileType="32"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<File
|
||||
RelativePath=".\ReadMe.txt"
|
||||
>
|
||||
</File>
|
||||
</Files>
|
||||
<Globals>
|
||||
</Globals>
|
||||
</VisualStudioProject>
|
||||
Loading…
Reference in New Issue
Block a user