Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 573 → Rev 576

/programs/media/ac97snd/trunk/mp3dec/l3init.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/bstream.h
File deleted
/programs/media/ac97snd/trunk/mp3dec/pow.asm
File deleted
/programs/media/ac97snd/trunk/mp3dec/layer3.h
File deleted
/programs/media/ac97snd/trunk/mp3dec/window.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3sf.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/e_pow.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/windowb.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3msis.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/mp3dec.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/fdct.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3hybrid.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/mp3dec.h
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3side.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3quant.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3huff.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/math_private.h
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3alias.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/sbt.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l1dec.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l2dec.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3dec.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/sbtb.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/mp3dec.vcproj
File deleted
/programs/media/ac97snd/trunk/mp3dec/l3huff.h
File deleted
/programs/media/ac97snd/trunk/mp3dec/bstream.c
File deleted
\ No newline at end of file
/programs/media/ac97snd/trunk/mp3dec/PROC32.INC
File deleted
/programs/media/ac97snd/trunk/mp3dec/imdct.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l1init.c
File deleted
/programs/media/ac97snd/trunk/mp3dec/l2init.c
File deleted
/programs/media/ac97snd/trunk/ac97.sln
File deleted
/programs/media/ac97snd/trunk/crt.h
File deleted
/programs/media/ac97snd/trunk/sound.h
File deleted
/programs/media/ac97snd/trunk/k_lib.asm
File deleted
/programs/media/ac97snd/trunk/PROC32.INC
File deleted
/programs/media/ac97snd/trunk/kolibri.h
File deleted
/programs/media/ac97snd/trunk/ac97wav.c
File deleted
/programs/media/ac97snd/trunk/mpg/l2tables.h
File deleted
/programs/media/ac97snd/trunk/mpg/mpg123.h
File deleted
/programs/media/ac97snd/trunk/mpg/readers.c
File deleted
\ No newline at end of file
/programs/media/ac97snd/trunk/mpg/math_private.h
File deleted
/programs/media/ac97snd/trunk/mpg/common.c
File deleted
/programs/media/ac97snd/trunk/mpg/huffman.h
File deleted
/programs/media/ac97snd/trunk/mpg/tabinit.c
File deleted
\ No newline at end of file
/programs/media/ac97snd/trunk/mpg/decode_i386.c
File deleted
/programs/media/ac97snd/trunk/mpg/dct64_i386.c
File deleted
/programs/media/ac97snd/trunk/mpg/layer1.c
File deleted
/programs/media/ac97snd/trunk/mpg/decode_i486.c
File deleted
/programs/media/ac97snd/trunk/mpg/dct64_i486.c
File deleted
/programs/media/ac97snd/trunk/mpg/layer2.c
File deleted
/programs/media/ac97snd/trunk/mpg/layer3.c
File deleted
/programs/media/ac97snd/trunk/mpg/getbits.c
File deleted
/programs/media/ac97snd/trunk/mpg/layer3.h
File deleted
/programs/media/ac97snd/trunk/mpg/mpg.vcproj
File deleted
/programs/media/ac97snd/trunk/mpg/getbits.h
File deleted
/programs/media/ac97snd/trunk/mpg/e_pow.c
File deleted
/programs/media/ac97snd/trunk/ac97wav.h
File deleted
/programs/media/ac97snd/trunk/crt.c
File deleted
/programs/media/ac97snd/ac97snd/ac97snd.vcproj
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>
/programs/media/ac97snd/ac97snd/ac97wav.c
0,0 → 1,722
//
// This file is part of the AC97 mp3 player.
// (C) copyright Serge 2006
// email: infinity_sound@mail.ru
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
 
#include "../kolibri.h"
#include "string.h"
#include "ac97wav.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);
 
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;
 
FILEINFO fileinfo;
 
int m_vol;
int l_vol=-700; //-7db
int r_vol=-700;
int pan =0;
 
DWORD status;
DWORD offset;
DWORD first_sync;
 
unsigned char *testbuff;
unsigned char *outbuf;
unsigned char *inpbuf;
unsigned char *outPtr;
 
int inpsize;
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)();
 
 
int main(int argc, char *argv[]) //int argc, char *argv[])
{
int err;
int ver;
int evnt;
int key;
int pos;
int msg;
int cnt;
IPC *incom;
_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");
return 0;
}
if( (SOUND_VERSION>(ver&0xFFFF)) ||
(SOUND_VERSION<(ver >> 16)))
{ debug_out_str("Sound service version mismatch\n\r");
return 0;
}
 
make_decode_tables(32767);
init_layer2();
init_layer3(32);
fr.single = -1;
 
outremain = 0x40000 ;
if( !(outbuf=UserAlloc(outremain)))
return 0;
touch(outbuf, outremain);
if ( !(testbuff=UserAlloc(4096)))
return 0;
if (! (inpbuf=UserAlloc(0x10000)))
return 0;
touch(inpbuf, 0x10000);
create_reader(&rd, inpbuf, 0x10000);
 
fname = argv[1];
if(get_fileinfo(fname, &fileinfo)==FILE_NOT_FOUND)
{
_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();
 
while(1)
{ if(status==ST_PLAY)
{ draw_progress_bar();
evnt = wait_for_event(80);
}
else
evnt = wait_for_event_infinite();
 
switch(evnt)
{
case EV_REDRAW:
draw_window();
break;
 
case EV_KEY:
if(!get_key(&key))
{
switch(key)
{ case 0xE0:
case 0xE1:
break;
default:
switch (key)
{
case 0x01: //Esc
status = ST_EXIT;
exit();
break;
case 0x47: //Home
if(l_vol < 0)
{ l_vol+=100;
r_vol+=100;
SetVolume(hBuff,l_vol,r_vol);
};
break;
case 0x4F: //End
if(l_vol > -10000)
{ l_vol-=100;
r_vol-=100;
SetVolume(hBuff,l_vol,r_vol);
};
break;
case 0x53:
if(pan > -10000)
{ pan -=100;
SetPan(hBuff,pan);
};
break;
case 0x51:
if(pan < 10000)
{ pan +=100;
SetPan(hBuff,pan);
};
break;
}
};
};
break;
 
case EV_BUTTON:
switch(get_button_id())
{ case 1:
status = ST_EXIT;
exit();
break;
case 0x10:
status = ST_PLAY;
continue;
 
case 0x11:
status = ST_STOP;
break;
// case 0x12:
// case 0x13:
case 0x14:
if(l_vol > -10000)
{
l_vol-=100;
r_vol-=100;
SetVolume(hBuff,l_vol,r_vol);
};
break;
 
case 0x15:
if(l_vol < 0)
{ l_vol+=100;
r_vol+=100;
SetVolume(hBuff,l_vol,r_vol);
};
break;
 
case 0x30:
if(status==ST_DONE)
break;
pos = (GetMousePos(REL_WINDOW)>>16)-7;
offset = ((fileinfo.size-44)/286*pos+44)&0xFFFFFFFC;
set_reader(&rd, offset);
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 ebx, [val]
int 0x40
};
}
 
int wait_for_event(int time)
{ int retval;
_asm
{ mov eax,23
mov ebx,[time]
int 0x40
mov [retval], eax
};
return retval;
};
int wait_for_event_infinite()
{ int retval;
_asm
{ mov eax,10
int 0x40
mov [retval], eax
};
return retval;
};
 
void BeginDraw()
{_asm
{ mov eax,12
mov ebx, 1
int 0x40
};
};
 
void EndDraw()
{ _asm
{ mov eax,12
mov ebx, 2
int 0x40
};
};
 
///*********
void *memmove ( void * dst, void * src, int count)
{ void *ret;
ret = dst;
 
if (dst <= src || (char *)dst >= ((char *)src + count))
{
while (count--)
{ *(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else
{
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--)
{ *(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return ret;
};
//**********/
 
void * __cdecl mem_cpy(void * dst,const void * src,size_t count)
{ void * ret = dst;
while (count--)
{ *(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
};
return(ret);
}
 
// debug_out_str(formats[fmt]);
// debug_out_str("\x0D\x0A\x00");
 
// debug_out_str("pci cmd: ");
// debug_out_hex(info.pci_cmd);
// debug_out_str("\x0D\x0A\x00");
 
// debug_out_str("irq line: ");
// debug_out_hex(info.irq);
// debug_out_str("\x0D\x0A\x00");
 
// debug_out_str("global control: ");
// debug_out_hex(info.glob_cntrl);
// debug_out_str("\x0D\x0A\x00");
 
// debug_out_str("global status: ");
// debug_out_hex(info.glob_sta);
// debug_out_str("\x0D\x0A\x00");
 
 
// call _print_volume
 
// debug_out_hex(whdr.nChannels);
// debug_out_str("\x0D\x0A\x00");
// debug_out_hex(whdr.nSamplesPerSec);
// debug_out_str("\x0D\x0A\x00");
 
// debug_out_hex(fmt);
// debug_out_str("\x0D\x0A\x00");
 
 
 
/programs/media/ac97snd/ac97snd/ac97wav.h
0,0 → 1,32
//
// This file is part of the AC97 mp3 player.
// (C) copyright Serge 2006
// email: infinity_sound@mail.ru
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
 
 
#define ST_DONE 0x0
#define ST_PLAY 0x1
#define ST_EXIT 0x2
#define ST_STOP 0x4
#define ST_TRACK 0x5
 
 
DWORD test_mp3(char *buf);
 
//void (*snd_play)();
void wave_out(char* buff);
 
void play_wave();
void play_mp3();
 
void snd_stop();
/programs/media/ac97snd/ac97snd/crt.c
0,0 → 1,74
#include "crt.h"
 
#define atexitBufferSize 32
 
char pureCallMessage[] = "PURE function call!";
 
char *__argv[2];
int __argc;
 
void (__cdecl *atExitList[atexitBufferSize])();
int atExitFnNum = 0;
int main(int argc, char *argv[]);
 
void exit()
{ int i;
 
for ( i = atExitFnNum - 1; i >= 0; i-- )
atExitList[i]();
__asm
{
mov eax, -1
int 0x40
};
};
 
int __cdecl atexit( void (__cdecl *func )( void ))
{
//
if ( atExitFnNum < atexitBufferSize )
{
//
atExitList[atExitFnNum++] = func;
return 0;
}
else
{
return 1;
}
}
 
int __cdecl _purecall()
{
exit();
return 0;
}
 
#pragma section(".CRT$XCA",long,read,write)
#pragma section(".CRT$XCZ",long,read,write)
typedef void (__cdecl *_PVFV)(void);
__declspec(allocate(".CRT$XCA")) _PVFV __xc_a[1] = { 0 };
__declspec(allocate(".CRT$XCZ")) _PVFV __xc_z[1] = { 0 };
//
#pragma comment(linker, "/merge:.CRT=.rdata")
//
void crtStartUp()
{_PVFV *pbegin;
 
_asm {fninit};
 
for ( pbegin = __xc_a; pbegin < __xc_z; pbegin++ )
{
//
if ( *pbegin != 0 )
(**pbegin)();
}
__argc = 2;
__argv[0] = *((char **)0x20);
__argv[1] = *((char **)0x1C);
main(__argc, __argv);
exit();
}
 
 
/programs/media/ac97snd/ac97snd/crt.h
0,0 → 1,13
typedef unsigned __int32 Dword;
typedef unsigned __int16 Word;
typedef unsigned __int8 Byte;
typedef unsigned __int32 size_t;
 
 
extern char *__argv[2];
 
void crtStartUp();
int __cdecl _purecall();
int __cdecl atexit( void (__cdecl *func )( void ));
void exit();
int main();
/programs/media/ac97snd/ac97snd/k_lib.asm
0,0 → 1,545
format MS COFF
 
include "proc32.inc"
 
section '.text' code readable executable
 
public _InitHeap@4
public _UserAlloc@4
public _CreateThread@8
public _GetMousePos@4
public _get_fileinfo@8
public _read_file@20
public _get_key@4
public _get_button_id
public _DrawWindow@36
public _make_button@24
public _draw_bar@20
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
 
struc FILEIO
{ .cmd dd ?
.offset dd ?
dd ?
.count dd ?
.buff dd ?
db ?
.name dd ?
};
 
align 4
_create_thread@12:
.thr_proc equ esp+4
.param equ esp+8
.stack_size equ esp+12
 
mov eax, 68
mov ebx, 12
mov ecx, [.stack_size]
add ecx, 4095
and ecx, -4096
int 0x40
test eax, eax
jz .fail
 
lea edx, [eax+ecx-12]
mov [edx], dword .exit_point
mov ebx, [.param]
mov [edx+4], ebx
mov [edx+8], ecx
 
mov eax, 51
mov ebx, 1
mov ecx, [.thr_proc]
int 0x40
ret 12
.fail:
not eax
ret 12
align 4
.exit_point:
pop ecx
mov eax, 68
mov ebx, 13
int 0x40
mov eax, -1
int 0x40
 
restore .thr_proc
restore .param
restore .stack_size
 
 
align 4
proc _get_button_id
mov eax,17
int 0x40
test al,al
jnz @F
shr eax,8
ret
@@:
xor eax,eax
dec eax
ret
endp
 
align 4
proc _get_fileinfo@8 stdcall, name:dword, info:dword
push ebx
push esi
push edi
xor eax, eax
mov ebx, [name]
mov ecx, [info]
 
mov [fileio.cmd], 5
mov [fileio.offset], eax
mov [fileio.offset+4], eax
mov [fileio.count], eax
mov [fileio.buff], ecx
mov byte [fileio.buff+4], al
mov [fileio.name], ebx
 
mov eax, 70
lea ebx, [fileio]
int 0x40
pop edi
pop esi
pop ebx
ret
endp
 
align 4
proc _read_file@20 stdcall,name:dword, buff:dword, offset:dword,\
count:dword,reads:dword
push ebx
push esi
push edi
xor eax, eax
mov ebx, [name]
mov edx, [offset]
mov esi, [buff]
mov edi, [count]
 
mov [fileio.cmd], eax
mov [fileio.offset], edx
mov [fileio.offset+4], eax
mov [fileio.count], edi
mov [fileio.buff], esi
mov byte [fileio.buff+4], al
mov [fileio.name], ebx
 
mov eax, 70
lea ebx, [fileio]
int 0x40
mov esi, [reads]
test esi, esi
jz @f
mov [esi], ebx
@@:
pop edi
pop esi
pop ebx
ret
endp
 
align 4
proc _get_key@4 stdcall, key:dword
push ebx
push ecx
mov eax, 2
int 0x40
mov ebx, [key]
mov ecx, eax
shr ecx, 8
mov [ebx], ecx
movzx eax, al
pop ecx
pop ebx
ret
endp
 
 
align 4
proc _InitHeap@4 stdcall, heap_size:dword
push ebx
mov eax, 68
mov ebx, 11
mov ecx, [heap_size]
int 0x40
pop ebx
ret
endp
 
align 4
proc _UserAlloc@4 stdcall, alloc_size:dword
push ebx
mov eax, 68
mov ebx, 12
mov ecx, [alloc_size]
int 0x40
pop ebx
ret
endp
 
align 4
proc _CreateThread@8 stdcall, fn:dword, p_stack:dword
push ebx
mov eax, 51
mov ebx, 1
mov ecx, [fn]
mov edx,[p_stack]
int 0x40
pop ebx
ret
endp
 
align 4
proc _GetMousePos@4 stdcall,rel_type:dword
push ebx
mov eax, 37
mov ebx, [rel_type]
int 0x40
pop ebx
ret
endp
 
 
align 4
proc _DrawWindow@36 stdcall, x:dword, y:dword, sx:dword, sy:dword,\
workcolor:dword, style:dword, captioncolor:dword,\
windowtype:dword, bordercolor:dword
push ebx edi esi
mov ebx, [x]
mov ecx, [y]
shl ebx, 16
shl ecx, 16
mov bx, word [sx]
mov cx, word [sy]
mov edx,[style]
shl edx,24
add edx,[workcolor]
mov esi,[windowtype]
shl esi,24
add esi,[captioncolor]
mov edi,[bordercolor]
xor eax,eax
int 0x40
pop esi edi ebx
ret
endp
 
align 4
_make_button@24:
;arg1 - x
;arg2 - y
;arg3 - xsize
;arg4 - ysize
;arg5 - id
;arg6 - color
 
push ebx esi
mov ebx,[esp+12]
shl ebx,16
mov bx,[esp+20]
mov ecx,[esp+16]
shl ecx,16
mov cx,[esp+24]
mov edx,[esp+28]
mov esi,[esp+32]
mov eax,8
int 0x40
pop esi ebx
ret 24
 
align 4
_draw_bar@20:
;arg1 - x
;arg2 - y
;arg3 - xsize
;arg4 - ysize
;arg5 - color
push ebx
mov eax,13
mov ebx,[esp+8]
shl ebx,16
mov bx,[esp+16]
mov ecx,[esp+12]
shl ecx,16
mov cx,[esp+20]
mov edx,[esp+24]
int 0x40
pop ebx
ret 20
 
_write_text@20:
;arg1 - x
;arg2 - y
;arg3 - color
;arg4 - text
;arg5 - len
push ebx esi
mov eax,4
mov ebx,[esp+12]
shl ebx,16
mov bx,[esp+16]
mov ecx,[esp+20]
mov edx,[esp+24]
mov esi,[esp+28]
int 0x40
pop esi ebx
ret 20
 
align 4
proc _debug_out@4 stdcall, val:dword
push ebx
mov ecx,[val]
mov ebx,1
mov eax,63
int 0x40
pop ebx
ret
endp
 
align 4
proc _debug_out_hex@4 stdcall val:dword
locals
count dd ?
endl
 
mov [count], 8
.new_char:
rol [val], 4
mov ecx, [val]
and ecx, 0x0f
mov cl,byte [__hexdigits+ecx]
mov eax, 63
mov ebx, 1
int 0x40
dec [count]
jnz .new_char
ret
endp
 
align 4
_memset:
mov edx,[esp + 0ch]
mov ecx,[esp + 4]
 
test edx,edx
jz short toend
 
xor eax,eax
mov al,[esp + 8]
 
push edi
mov edi,ecx
 
cmp edx,4
jb tail
 
neg ecx
and ecx,3
jz short dwords
 
sub edx,ecx
adjust_loop:
mov [edi],al
add edi,1
sub ecx,1
jnz adjust_loop
 
dwords:
mov ecx,eax
shl eax,8
add eax,ecx
mov ecx,eax
shl eax,10h
add eax,ecx
 
mov ecx,edx
and edx,3
shr ecx,2
jz tail
 
cld
rep stosd
main_loop_tail:
test edx,edx
jz finish
 
 
tail:
mov [edi],al
add edi,1
 
sub edx,1
jnz tail
 
finish:
mov eax,[esp + 8]
pop edi
 
ret
 
toend:
mov eax,[esp + 4]
 
ret
 
public _allmul
 
_allmul:
mov eax, [esp+8]
mov ecx, [esp+16]
or ecx,eax
mov ecx, [esp+12]
jnz .hard
mov eax, [esp+4]
mul ecx
ret 16
.hard:
push ebx
mul ecx
mov ebx,eax
mov eax, [esp+8]
mul dword [esp+20]
add ebx,eax
mov eax,[esp+8]
mul ecx
add edx,ebx
pop ebx
ret 16
 
align 4
_allshr:
cmp cl,64
jae .sign
 
cmp cl, 32
jae .MORE32
shrd eax,edx,cl
sar edx,cl
ret
.MORE32:
mov eax,edx
sar edx,31
and cl,31
sar eax,cl
ret
.sign:
sar edx,31
mov eax,edx
ret
 
public __ftol2_sse
 
align 4
__ftol2_sse:
push ebp
mov ebp, esp
sub esp, 20
and esp, 0xFFFFFFF0
fld st0
fst dword [esp+18]
fistp qword [esp+10]
fild qword [esp+10]
mov edx, [esp+18]
mov eax, [esp+10]
test eax, eax
jz .QnaNZ
 
.not_QnaNZ:
fsubp st1, st0
test edx, edx
jns .pos
fstp dword [esp]
mov ecx, [esp]
xor ecx, 0x80000000
add ecx, 0x7FFFFFFF
adc eax, 0
mov edx, [esp+14]
adc edx, 0
jmp .exit
.pos:
fstp dword [esp]
mov ecx, [esp]
add ecx, 0x7FFFFFFF
sbb eax, 0
jmp .exit
.QnaNZ:
mov edx, [esp+14]
test edx, 0x7FFFFFFF
jne .not_QnaNZ
fstp dword [esp+18]
fstp dword [esp+18]
.exit:
leave
ret
 
public __fltused
__fltused dd 0
 
align 4
__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
/programs/media/ac97snd/ac97snd/proc32.inc
0,0 → 1,268
 
; Macroinstructions for defining and calling procedures
 
macro stdcall proc,[arg] ; directly call STDCALL procedure
{ common
if ~ arg eq
reverse
pushd arg
common
end if
call proc }
 
macro invoke proc,[arg] ; indirectly call STDCALL procedure
{ common
if ~ arg eq
reverse
pushd arg
common
end if
call [proc] }
 
macro ccall proc,[arg] ; directly call CDECL procedure
{ common
size@ccall = 0
if ~ arg eq
reverse
pushd arg
size@ccall = size@ccall+4
common
end if
call proc
if size@ccall
add esp,size@ccall
end if }
 
macro cinvoke proc,[arg] ; indirectly call CDECL procedure
{ common
size@ccall = 0
if ~ arg eq
reverse
pushd arg
size@ccall = size@ccall+4
common
end if
call [proc]
if size@ccall
add esp,size@ccall
end if }
 
macro proc [args] ; define procedure
{ common
match name params, args>
\{ define@proc name,<params \} }
 
prologue@proc equ prologuedef
 
macro prologuedef procname,flag,parmbytes,localbytes,reglist
{ if parmbytes | localbytes
push ebp
mov ebp,esp
if localbytes
sub esp,localbytes
end if
end if
irps reg, reglist \{ push reg \} }
 
epilogue@proc equ epiloguedef
 
macro epiloguedef procname,flag,parmbytes,localbytes,reglist
{ irps reg, reglist \{ reverse pop reg \}
if parmbytes | localbytes
leave
end if
if flag and 10000b
retn
else
retn parmbytes
end if }
 
macro define@proc name,statement
{ local params,flag,regs,parmbytes,localbytes,current
if used name
name:
match =stdcall args, statement \{ params equ args
flag = 11b \}
match =stdcall, statement \{ params equ
flag = 11b \}
match =c args, statement \{ params equ args
flag = 10001b \}
match =c, statement \{ params equ
flag = 10001b \}
match =params, params \{ params equ statement
flag = 0 \}
virtual at ebp+8
match =uses reglist=,args, params \{ regs equ reglist
params equ args \}
match =regs =uses reglist, regs params \{ regs equ reglist
params equ \}
match =regs, regs \{ regs equ \}
match =,args, params \{ defargs@proc args \}
match =args@proc args, args@proc params \{ defargs@proc args \}
parmbytes = $ - (ebp+8)
end virtual
name # % = parmbytes/4
all@vars equ
current = 0
match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \}
macro locals
\{ virtual at ebp-localbytes+current
macro label . \\{ deflocal@proc .,:, \\}
struc db [val] \\{ \common deflocal@proc .,db,val \\}
struc dw [val] \\{ \common deflocal@proc .,dw,val \\}
struc dp [val] \\{ \common deflocal@proc .,dp,val \\}
struc dd [val] \\{ \common deflocal@proc .,dd,val \\}
struc dt [val] \\{ \common deflocal@proc .,dt,val \\}
struc dq [val] \\{ \common deflocal@proc .,dq,val \\}
struc rb cnt \\{ deflocal@proc .,rb cnt, \\}
struc rw cnt \\{ deflocal@proc .,rw cnt, \\}
struc rp cnt \\{ deflocal@proc .,rp cnt, \\}
struc rd cnt \\{ deflocal@proc .,rd cnt, \\}
struc rt cnt \\{ deflocal@proc .,rt cnt, \\}
struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \}
macro endl
\{ purge label
restruc db,dw,dp,dd,dt,dq
restruc rb,rw,rp,rd,rt,rq
restruc byte,word,dword,pword,tword,qword
current = $-(ebp-localbytes)
end virtual \}
macro ret operand
\{ match any, operand \\{ retn operand \\}
match , operand \\{ match epilogue:reglist, epilogue@proc:<regs>
\\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \}
macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2
end if \} }
 
macro defargs@proc [arg]
{ common
if ~ arg eq
forward
local ..arg,current@arg
match argname:type, arg
\{ current@arg equ argname
label ..arg type
argname equ ..arg
if dqword eq type
dd ?,?,?,?
else if tbyte eq type
dd ?,?,?
else if qword eq type | pword eq type
dd ?,?
else
dd ?
end if \}
match =current@arg,current@arg
\{ current@arg equ arg
arg equ ..arg
..arg dd ? \}
common
args@proc equ current@arg
forward
restore current@arg
common
end if }
 
macro deflocal@proc name,def,[val]
{ common
match vars, all@vars \{ all@vars equ all@vars, \}
all@vars equ all@vars name
forward
local ..var,..tmp
..var def val
match =?, val \{ ..tmp equ \}
match any =dup (=?), val \{ ..tmp equ \}
match tmp : value, ..tmp : val
\{ tmp: end virtual
initlocal@proc ..var,def value
virtual at tmp\}
common
match first rest, ..var, \{ name equ first \} }
 
macro initlocal@proc name,def
{ virtual at name
def
size@initlocal = $ - name
end virtual
position@initlocal = 0
while size@initlocal > position@initlocal
virtual at name
def
if size@initlocal - position@initlocal < 2
current@initlocal = 1
load byte@initlocal byte from name+position@initlocal
else if size@initlocal - position@initlocal < 4
current@initlocal = 2
load word@initlocal word from name+position@initlocal
else
current@initlocal = 4
load dword@initlocal dword from name+position@initlocal
end if
end virtual
if current@initlocal = 1
mov byte [name+position@initlocal],byte@initlocal
else if current@initlocal = 2
mov word [name+position@initlocal],word@initlocal
else
mov dword [name+position@initlocal],dword@initlocal
end if
position@initlocal = position@initlocal + current@initlocal
end while }
 
macro endp
{ purge ret,locals,endl
finish@proc
purge finish@proc
restore regs@proc
match all,args@proc \{ restore all \}
restore args@proc
match all,all@vars \{ restore all \} }
 
macro local [var]
{ common
locals
forward done@local equ
match varname[count]:vartype, var
\{ match =BYTE, vartype \\{ varname rb count
restore done@local \\}
match =WORD, vartype \\{ varname rw count
restore done@local \\}
match =DWORD, vartype \\{ varname rd count
restore done@local \\}
match =PWORD, vartype \\{ varname rp count
restore done@local \\}
match =QWORD, vartype \\{ varname rq count
restore done@local \\}
match =TBYTE, vartype \\{ varname rt count
restore done@local \\}
match =DQWORD, vartype \\{ label varname dqword
rq count+count
restore done@local \\}
match , done@local \\{ virtual
varname vartype
end virtual
rb count*sizeof.\#vartype
restore done@local \\} \}
match :varname:vartype, done@local:var
\{ match =BYTE, vartype \\{ varname db ?
restore done@local \\}
match =WORD, vartype \\{ varname dw ?
restore done@local \\}
match =DWORD, vartype \\{ varname dd ?
restore done@local \\}
match =PWORD, vartype \\{ varname dp ?
restore done@local \\}
match =QWORD, vartype \\{ varname dq ?
restore done@local \\}
match =TBYTE, vartype \\{ varname dt ?
restore done@local \\}
match =DQWORD, vartype \\{ label varname dqword
dq ?,?
restore done@local \\}
match , done@local \\{ varname vartype
restore done@local \\} \}
match ,done@local
\{ var
restore done@local \}
common
endl }
/programs/media/ac97snd/ac97snd/struct.inc
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
/programs/media/ac97snd/ac97snd.sln
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
/programs/media/ac97snd/fasm.rules
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>
/programs/media/ac97snd/kolibri.h
0,0 → 1,107
 
#ifdef __cplusplus
extern "C"
{
#endif
 
 
#define FONT0 0x00000000
#define FONT1 0x10000000
 
#define BT_NORMAL 0x00000000
#define BT_NOFRAME 0x20000000
#define BT_HIDE 0x40000000
#define BT_DEL 0x80000000
 
#define EV_REDRAW 1
#define EV_KEY 2
#define EV_BUTTON 3
#define EV_IPC 7
 
#define REL_SCREEN 0
#define REL_WINDOW 1
 
#define FILE_NOT_FOUND 5
#define FILE_EOF 6
 
 
typedef unsigned int DWORD;
typedef unsigned short int WORD;
 
typedef struct
{ DWORD pci_cmd;
DWORD irq;
DWORD glob_cntrl;
DWORD glob_sta;
DWORD codec_io_base;
DWORD ctrl_io_base;
DWORD codec_mem_base;
DWORD ctrl_mem_base;
DWORD codec_id;
} CTRL_INFO;
 
typedef struct
{ DWORD cmd;
DWORD offset;
DWORD r1;
DWORD count;
DWORD buff;
char r2;
char *name;
} FILEIO;
 
typedef struct
{ DWORD attr;
DWORD flags;
DWORD cr_time;
DWORD cr_date;
DWORD acc_time;
DWORD acc_date;
DWORD mod_time;
DWORD mod_date;
DWORD size;
DWORD size_high;
} FILEINFO;
 
void _stdcall InitHeap(int heap_size);
void* _stdcall UserAlloc(int size);
int _stdcall UserFree(void* p);
void _stdcall GetNotify(void *event);
 
void _stdcall CreateThread(void *fn, char *p_stack);
 
DWORD _stdcall GetMousePos(DWORD rel_type);
 
void _stdcall debug_out_hex(DWORD val);
void debug_out_str(char* str);
 
int _stdcall get_fileinfo(const char *name,FILEINFO* pinfo);
int _stdcall create_file(const char *name);
int _stdcall read_file (const char *name,char*buff,DWORD offset, DWORD count,DWORD *reads);
int _stdcall write_file(const char *name,char*buff,int offset,int count,int *writes);
 
//void exit();
int _stdcall get_key(int *key);
int _stdcall remap_key(int key);
 
int _cdecl get_button_id();
 
void delay(int val);
int wait_for_event(int time);
int wait_for_event_infinite();
void BeginDraw(void);
void EndDraw(void);
 
void _stdcall GetScreenSize(int *x, int*y);
void _stdcall DrawWindow(int x,int y, int sx, int sy,int workcolor,int style,
int captioncolor,int windowtype,int bordercolor);
void _stdcall debug_out(int ch);
void _stdcall make_button(int x, int y, int xsize, int ysize, int id, int color);
void _stdcall draw_bar(int x, int y, int xsize, int ysize, int color);
void _stdcall write_text(int x,int y,int color,char* text,int len);
 
#ifdef __cplusplus
extern "C"
}
#endif
/programs/media/ac97snd/mpg/dct64_i386.c
0,0 → 1,337
/*
dct64_i386.c: DCT64, a C variant for i386
 
copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
*/
 
/*
* Discrete Cosine Tansform (DCT) for subband synthesis
* optimized for machines with no auto-increment.
* The performance is highly compiler dependend. Maybe
* the dct64.c version for 'normal' processor may be faster
* even for Intel processors.
*/
 
//#include "config.h"
#include "mpg123.h"
 
static void dct64_1(real *out0,real *out1,real *b1,real *b2,real *samples)
{
{
register real *costab = pnts[0];
 
b1[0x00] = samples[0x00] + samples[0x1F];
b1[0x01] = samples[0x01] + samples[0x1E];
b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0];
b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1];
 
b1[0x02] = samples[0x02] + samples[0x1D];
b1[0x03] = samples[0x03] + samples[0x1C];
b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2];
b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3];
 
b1[0x04] = samples[0x04] + samples[0x1B];
b1[0x05] = samples[0x05] + samples[0x1A];
b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4];
b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5];
 
b1[0x06] = samples[0x06] + samples[0x19];
b1[0x07] = samples[0x07] + samples[0x18];
b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6];
b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7];
 
b1[0x08] = samples[0x08] + samples[0x17];
b1[0x09] = samples[0x09] + samples[0x16];
b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8];
b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9];
 
b1[0x0A] = samples[0x0A] + samples[0x15];
b1[0x0B] = samples[0x0B] + samples[0x14];
b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA];
b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB];
 
b1[0x0C] = samples[0x0C] + samples[0x13];
b1[0x0D] = samples[0x0D] + samples[0x12];
b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC];
b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD];
 
b1[0x0E] = samples[0x0E] + samples[0x11];
b1[0x0F] = samples[0x0F] + samples[0x10];
b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE];
b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF];
 
}
 
 
{
register real *costab = pnts[1];
 
b2[0x00] = b1[0x00] + b1[0x0F];
b2[0x01] = b1[0x01] + b1[0x0E];
b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0];
b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1];
 
b2[0x02] = b1[0x02] + b1[0x0D];
b2[0x03] = b1[0x03] + b1[0x0C];
b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2];
b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3];
 
b2[0x04] = b1[0x04] + b1[0x0B];
b2[0x05] = b1[0x05] + b1[0x0A];
b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4];
b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5];
 
b2[0x06] = b1[0x06] + b1[0x09];
b2[0x07] = b1[0x07] + b1[0x08];
b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6];
b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7];
 
/* */
 
b2[0x10] = b1[0x10] + b1[0x1F];
b2[0x11] = b1[0x11] + b1[0x1E];
b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0];
b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1];
 
b2[0x12] = b1[0x12] + b1[0x1D];
b2[0x13] = b1[0x13] + b1[0x1C];
b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2];
b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3];
 
b2[0x14] = b1[0x14] + b1[0x1B];
b2[0x15] = b1[0x15] + b1[0x1A];
b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4];
b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5];
 
b2[0x16] = b1[0x16] + b1[0x19];
b2[0x17] = b1[0x17] + b1[0x18];
b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6];
b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7];
}
 
{
register real *costab = pnts[2];
 
b1[0x00] = b2[0x00] + b2[0x07];
b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0];
b1[0x01] = b2[0x01] + b2[0x06];
b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1];
b1[0x02] = b2[0x02] + b2[0x05];
b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2];
b1[0x03] = b2[0x03] + b2[0x04];
b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3];
 
b1[0x08] = b2[0x08] + b2[0x0F];
b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0];
b1[0x09] = b2[0x09] + b2[0x0E];
b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1];
b1[0x0A] = b2[0x0A] + b2[0x0D];
b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2];
b1[0x0B] = b2[0x0B] + b2[0x0C];
b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3];
 
b1[0x10] = b2[0x10] + b2[0x17];
b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0];
b1[0x11] = b2[0x11] + b2[0x16];
b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1];
b1[0x12] = b2[0x12] + b2[0x15];
b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2];
b1[0x13] = b2[0x13] + b2[0x14];
b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3];
 
b1[0x18] = b2[0x18] + b2[0x1F];
b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0];
b1[0x19] = b2[0x19] + b2[0x1E];
b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1];
b1[0x1A] = b2[0x1A] + b2[0x1D];
b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2];
b1[0x1B] = b2[0x1B] + b2[0x1C];
b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3];
}
 
{
register real const cos0 = pnts[3][0];
register real const cos1 = pnts[3][1];
 
b2[0x00] = b1[0x00] + b1[0x03];
b2[0x03] = (b1[0x00] - b1[0x03]) * cos0;
b2[0x01] = b1[0x01] + b1[0x02];
b2[0x02] = (b1[0x01] - b1[0x02]) * cos1;
 
b2[0x04] = b1[0x04] + b1[0x07];
b2[0x07] = (b1[0x07] - b1[0x04]) * cos0;
b2[0x05] = b1[0x05] + b1[0x06];
b2[0x06] = (b1[0x06] - b1[0x05]) * cos1;
 
b2[0x08] = b1[0x08] + b1[0x0B];
b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0;
b2[0x09] = b1[0x09] + b1[0x0A];
b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1;
b2[0x0C] = b1[0x0C] + b1[0x0F];
b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0;
b2[0x0D] = b1[0x0D] + b1[0x0E];
b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1;
 
b2[0x10] = b1[0x10] + b1[0x13];
b2[0x13] = (b1[0x10] - b1[0x13]) * cos0;
b2[0x11] = b1[0x11] + b1[0x12];
b2[0x12] = (b1[0x11] - b1[0x12]) * cos1;
 
b2[0x14] = b1[0x14] + b1[0x17];
b2[0x17] = (b1[0x17] - b1[0x14]) * cos0;
b2[0x15] = b1[0x15] + b1[0x16];
b2[0x16] = (b1[0x16] - b1[0x15]) * cos1;
 
b2[0x18] = b1[0x18] + b1[0x1B];
b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0;
b2[0x19] = b1[0x19] + b1[0x1A];
b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1;
 
b2[0x1C] = b1[0x1C] + b1[0x1F];
b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0;
b2[0x1D] = b1[0x1D] + b1[0x1E];
b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1;
}
 
{
register real const cos0 = pnts[4][0];
 
b1[0x00] = b2[0x00] + b2[0x01];
b1[0x01] = (b2[0x00] - b2[0x01]) * cos0;
b1[0x02] = b2[0x02] + b2[0x03];
b1[0x03] = (b2[0x03] - b2[0x02]) * cos0;
b1[0x02] += b1[0x03];
 
b1[0x04] = b2[0x04] + b2[0x05];
b1[0x05] = (b2[0x04] - b2[0x05]) * cos0;
b1[0x06] = b2[0x06] + b2[0x07];
b1[0x07] = (b2[0x07] - b2[0x06]) * cos0;
b1[0x06] += b1[0x07];
b1[0x04] += b1[0x06];
b1[0x06] += b1[0x05];
b1[0x05] += b1[0x07];
 
b1[0x08] = b2[0x08] + b2[0x09];
b1[0x09] = (b2[0x08] - b2[0x09]) * cos0;
b1[0x0A] = b2[0x0A] + b2[0x0B];
b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0;
b1[0x0A] += b1[0x0B];
 
b1[0x0C] = b2[0x0C] + b2[0x0D];
b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0;
b1[0x0E] = b2[0x0E] + b2[0x0F];
b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0;
b1[0x0E] += b1[0x0F];
b1[0x0C] += b1[0x0E];
b1[0x0E] += b1[0x0D];
b1[0x0D] += b1[0x0F];
 
b1[0x10] = b2[0x10] + b2[0x11];
b1[0x11] = (b2[0x10] - b2[0x11]) * cos0;
b1[0x12] = b2[0x12] + b2[0x13];
b1[0x13] = (b2[0x13] - b2[0x12]) * cos0;
b1[0x12] += b1[0x13];
 
b1[0x14] = b2[0x14] + b2[0x15];
b1[0x15] = (b2[0x14] - b2[0x15]) * cos0;
b1[0x16] = b2[0x16] + b2[0x17];
b1[0x17] = (b2[0x17] - b2[0x16]) * cos0;
b1[0x16] += b1[0x17];
b1[0x14] += b1[0x16];
b1[0x16] += b1[0x15];
b1[0x15] += b1[0x17];
 
b1[0x18] = b2[0x18] + b2[0x19];
b1[0x19] = (b2[0x18] - b2[0x19]) * cos0;
b1[0x1A] = b2[0x1A] + b2[0x1B];
b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0;
b1[0x1A] += b1[0x1B];
 
b1[0x1C] = b2[0x1C] + b2[0x1D];
b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0;
b1[0x1E] = b2[0x1E] + b2[0x1F];
b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0;
b1[0x1E] += b1[0x1F];
b1[0x1C] += b1[0x1E];
b1[0x1E] += b1[0x1D];
b1[0x1D] += b1[0x1F];
}
 
out0[0x10*16] = b1[0x00];
out0[0x10*12] = b1[0x04];
out0[0x10* 8] = b1[0x02];
out0[0x10* 4] = b1[0x06];
out0[0x10* 0] = b1[0x01];
out1[0x10* 0] = b1[0x01];
out1[0x10* 4] = b1[0x05];
out1[0x10* 8] = b1[0x03];
out1[0x10*12] = b1[0x07];
 
#if 1
out0[0x10*14] = b1[0x08] + b1[0x0C];
out0[0x10*10] = b1[0x0C] + b1[0x0a];
out0[0x10* 6] = b1[0x0A] + b1[0x0E];
out0[0x10* 2] = b1[0x0E] + b1[0x09];
out1[0x10* 2] = b1[0x09] + b1[0x0D];
out1[0x10* 6] = b1[0x0D] + b1[0x0B];
out1[0x10*10] = b1[0x0B] + b1[0x0F];
out1[0x10*14] = b1[0x0F];
#else
b1[0x08] += b1[0x0C];
out0[0x10*14] = b1[0x08];
b1[0x0C] += b1[0x0a];
out0[0x10*10] = b1[0x0C];
b1[0x0A] += b1[0x0E];
out0[0x10* 6] = b1[0x0A];
b1[0x0E] += b1[0x09];
out0[0x10* 2] = b1[0x0E];
b1[0x09] += b1[0x0D];
out1[0x10* 2] = b1[0x09];
b1[0x0D] += b1[0x0B];
out1[0x10* 6] = b1[0x0D];
b1[0x0B] += b1[0x0F];
out1[0x10*10] = b1[0x0B];
out1[0x10*14] = b1[0x0F];
#endif
 
{
real tmp;
tmp = b1[0x18] + b1[0x1C];
out0[0x10*15] = tmp + b1[0x10];
out0[0x10*13] = tmp + b1[0x14];
tmp = b1[0x1C] + b1[0x1A];
out0[0x10*11] = tmp + b1[0x14];
out0[0x10* 9] = tmp + b1[0x12];
tmp = b1[0x1A] + b1[0x1E];
out0[0x10* 7] = tmp + b1[0x12];
out0[0x10* 5] = tmp + b1[0x16];
tmp = b1[0x1E] + b1[0x19];
out0[0x10* 3] = tmp + b1[0x16];
out0[0x10* 1] = tmp + b1[0x11];
tmp = b1[0x19] + b1[0x1D];
out1[0x10* 1] = tmp + b1[0x11];
out1[0x10* 3] = tmp + b1[0x15];
tmp = b1[0x1D] + b1[0x1B];
out1[0x10* 5] = tmp + b1[0x15];
out1[0x10* 7] = tmp + b1[0x13];
tmp = b1[0x1B] + b1[0x1F];
out1[0x10* 9] = tmp + b1[0x13];
out1[0x10*11] = tmp + b1[0x17];
out1[0x10*13] = b1[0x17] + b1[0x1F];
out1[0x10*15] = b1[0x1F];
}
}
 
/*
* the call via dct64 is a trick to force GCC to use
* (new) registers for the b1,b2 pointer to the bufs[xx] field
*/
void dct64(real *a,real *b,real *c)
{
real bufs[0x40];
dct64_1(a,b,bufs,bufs+0x20,c);
}
 
/programs/media/ac97snd/mpg/dct64_i486.c
0,0 → 1,342
/*
dct64_i486.c: DCT64, a plain C variant for i486
 
copyright 1998-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Fabrice Bellard
*/
 
/* Discrete Cosine Tansform (DCT) for subband synthesis.
*
* This code is optimized for 80486. It should be compiled with gcc
* 2.7.2 or higher.
*
* Note: This code does not give the necessary accuracy. Moreover, no
* overflow test are done.
*
* (c) 1998 Fabrice Bellard.
*/
 
#include "mpg123.h"
 
#define COS_0_0 16403
#define COS_0_1 16563
#define COS_0_2 16890
#define COS_0_3 17401
#define COS_0_4 18124
#define COS_0_5 19101
#define COS_0_6 20398
#define COS_0_7 22112
#define COS_0_8 24396
#define COS_0_9 27503
#define COS_0_10 31869
#define COS_0_11 38320
#define COS_0_12 48633
#define COS_0_13 67429
#define COS_0_14 111660
#define COS_0_15 333906
#define COS_1_0 16463
#define COS_1_1 17121
#define COS_1_2 18577
#define COS_1_3 21195
#define COS_1_4 25826
#define COS_1_5 34756
#define COS_1_6 56441
#define COS_1_7 167154
#define COS_2_0 16704
#define COS_2_1 19704
#define COS_2_2 29490
#define COS_2_3 83981
#define COS_3_0 17733
#define COS_3_1 42813
#define COS_4_0 23170
 
#define SETOUT(out,n,expr) out[FIR_BUFFER_SIZE*(n)]=(expr)
#define MULL(a,b) (((long)(a)*(long)(b)) >> 15)
#define MUL(a,b) \
(\
((!(b & 0x3F)) ? (((a)*(b >> 6)) >> 9) :\
((!(b & 0x1F)) ? (((a)*(b >> 5)) >> 10) :\
((!(b & 0x0F)) ? (((a)*(b >> 4)) >> 11) :\
((!(b & 0x07)) ? (((a)*(b >> 3)) >> 12) :\
((!(b & 0x03)) ? (((a)*(b >> 2)) >> 13) :\
((!(b & 0x01)) ? (((a)*(b >> 1)) >> 14) :\
(((a)*(b )) >> 15))))))))
 
 
void dct64_1_486(int *out0,int *out1,int *b1,int *b2)
{
b1[0x00] = b2[0x00] + b2[0x1F];
b1[0x1F] = MUL((b2[0x00] - b2[0x1F]),COS_0_0);
 
b1[0x01] = b2[0x01] + b2[0x1E];
b1[0x1E] = MUL((b2[0x01] - b2[0x1E]),COS_0_1);
 
b1[0x02] = b2[0x02] + b2[0x1D];
b1[0x1D] = MUL((b2[0x02] - b2[0x1D]),COS_0_2);
 
b1[0x03] = b2[0x03] + b2[0x1C];
b1[0x1C] = MUL((b2[0x03] - b2[0x1C]),COS_0_3);
 
b1[0x04] = b2[0x04] + b2[0x1B];
b1[0x1B] = MUL((b2[0x04] - b2[0x1B]),COS_0_4);
 
b1[0x05] = b2[0x05] + b2[0x1A];
b1[0x1A] = MUL((b2[0x05] - b2[0x1A]),COS_0_5);
 
b1[0x06] = b2[0x06] + b2[0x19];
b1[0x19] = MUL((b2[0x06] - b2[0x19]),COS_0_6);
 
b1[0x07] = b2[0x07] + b2[0x18];
b1[0x18] = MUL((b2[0x07] - b2[0x18]),COS_0_7);
 
b1[0x08] = b2[0x08] + b2[0x17];
b1[0x17] = MUL((b2[0x08] - b2[0x17]),COS_0_8);
 
b1[0x09] = b2[0x09] + b2[0x16];
b1[0x16] = MUL((b2[0x09] - b2[0x16]),COS_0_9);
 
b1[0x0A] = b2[0x0A] + b2[0x15];
b1[0x15] = MUL((b2[0x0A] - b2[0x15]),COS_0_10);
 
b1[0x0B] = b2[0x0B] + b2[0x14];
b1[0x14] = MUL((b2[0x0B] - b2[0x14]),COS_0_11);
 
b1[0x0C] = b2[0x0C] + b2[0x13];
b1[0x13] = MUL((b2[0x0C] - b2[0x13]),COS_0_12);
 
b1[0x0D] = b2[0x0D] + b2[0x12];
b1[0x12] = MULL((b2[0x0D] - b2[0x12]),COS_0_13);
 
b1[0x0E] = b2[0x0E] + b2[0x11];
b1[0x11] = MULL((b2[0x0E] - b2[0x11]),COS_0_14);
 
b1[0x0F] = b2[0x0F] + b2[0x10];
b1[0x10] = MULL((b2[0x0F] - b2[0x10]),COS_0_15);
 
 
b2[0x00] = b1[0x00] + b1[0x0F];
b2[0x0F] = MUL((b1[0x00] - b1[0x0F]),COS_1_0);
b2[0x01] = b1[0x01] + b1[0x0E];
b2[0x0E] = MUL((b1[0x01] - b1[0x0E]),COS_1_1);
b2[0x02] = b1[0x02] + b1[0x0D];
b2[0x0D] = MUL((b1[0x02] - b1[0x0D]),COS_1_2);
b2[0x03] = b1[0x03] + b1[0x0C];
b2[0x0C] = MUL((b1[0x03] - b1[0x0C]),COS_1_3);
b2[0x04] = b1[0x04] + b1[0x0B];
b2[0x0B] = MUL((b1[0x04] - b1[0x0B]),COS_1_4);
b2[0x05] = b1[0x05] + b1[0x0A];
b2[0x0A] = MUL((b1[0x05] - b1[0x0A]),COS_1_5);
b2[0x06] = b1[0x06] + b1[0x09];
b2[0x09] = MUL((b1[0x06] - b1[0x09]),COS_1_6);
b2[0x07] = b1[0x07] + b1[0x08];
b2[0x08] = MULL((b1[0x07] - b1[0x08]),COS_1_7);
 
b2[0x10] = b1[0x10] + b1[0x1F];
b2[0x1F] = MUL((b1[0x1F] - b1[0x10]),COS_1_0);
b2[0x11] = b1[0x11] + b1[0x1E];
b2[0x1E] = MUL((b1[0x1E] - b1[0x11]),COS_1_1);
b2[0x12] = b1[0x12] + b1[0x1D];
b2[0x1D] = MUL((b1[0x1D] - b1[0x12]),COS_1_2);
b2[0x13] = b1[0x13] + b1[0x1C];
b2[0x1C] = MUL((b1[0x1C] - b1[0x13]),COS_1_3);
b2[0x14] = b1[0x14] + b1[0x1B];
b2[0x1B] = MUL((b1[0x1B] - b1[0x14]),COS_1_4);
b2[0x15] = b1[0x15] + b1[0x1A];
b2[0x1A] = MUL((b1[0x1A] - b1[0x15]),COS_1_5);
b2[0x16] = b1[0x16] + b1[0x19];
b2[0x19] = MUL((b1[0x19] - b1[0x16]),COS_1_6);
b2[0x17] = b1[0x17] + b1[0x18];
b2[0x18] = MULL((b1[0x18] - b1[0x17]),COS_1_7);
 
 
b1[0x00] = b2[0x00] + b2[0x07];
b1[0x07] = MUL((b2[0x00] - b2[0x07]),COS_2_0);
b1[0x01] = b2[0x01] + b2[0x06];
b1[0x06] = MUL((b2[0x01] - b2[0x06]),COS_2_1);
b1[0x02] = b2[0x02] + b2[0x05];
b1[0x05] = MUL((b2[0x02] - b2[0x05]),COS_2_2);
b1[0x03] = b2[0x03] + b2[0x04];
b1[0x04] = MULL((b2[0x03] - b2[0x04]),COS_2_3);
 
b1[0x08] = b2[0x08] + b2[0x0F];
b1[0x0F] = MUL((b2[0x0F] - b2[0x08]),COS_2_0);
b1[0x09] = b2[0x09] + b2[0x0E];
b1[0x0E] = MUL((b2[0x0E] - b2[0x09]),COS_2_1);
b1[0x0A] = b2[0x0A] + b2[0x0D];
b1[0x0D] = MUL((b2[0x0D] - b2[0x0A]),COS_2_2);
b1[0x0B] = b2[0x0B] + b2[0x0C];
b1[0x0C] = MULL((b2[0x0C] - b2[0x0B]),COS_2_3);
 
b1[0x10] = b2[0x10] + b2[0x17];
b1[0x17] = MUL((b2[0x10] - b2[0x17]),COS_2_0);
b1[0x11] = b2[0x11] + b2[0x16];
b1[0x16] = MUL((b2[0x11] - b2[0x16]),COS_2_1);
b1[0x12] = b2[0x12] + b2[0x15];
b1[0x15] = MUL((b2[0x12] - b2[0x15]),COS_2_2);
b1[0x13] = b2[0x13] + b2[0x14];
b1[0x14] = MULL((b2[0x13] - b2[0x14]),COS_2_3);
 
b1[0x18] = b2[0x18] + b2[0x1F];
b1[0x1F] = MUL((b2[0x1F] - b2[0x18]),COS_2_0);
b1[0x19] = b2[0x19] + b2[0x1E];
b1[0x1E] = MUL((b2[0x1E] - b2[0x19]),COS_2_1);
b1[0x1A] = b2[0x1A] + b2[0x1D];
b1[0x1D] = MUL((b2[0x1D] - b2[0x1A]),COS_2_2);
b1[0x1B] = b2[0x1B] + b2[0x1C];
b1[0x1C] = MULL((b2[0x1C] - b2[0x1B]),COS_2_3);
 
 
b2[0x00] = b1[0x00] + b1[0x03];
b2[0x03] = MUL((b1[0x00] - b1[0x03]),COS_3_0);
b2[0x01] = b1[0x01] + b1[0x02];
b2[0x02] = MUL((b1[0x01] - b1[0x02]),COS_3_1);
 
b2[0x04] = b1[0x04] + b1[0x07];
b2[0x07] = MUL((b1[0x07] - b1[0x04]),COS_3_0);
b2[0x05] = b1[0x05] + b1[0x06];
b2[0x06] = MUL((b1[0x06] - b1[0x05]),COS_3_1);
 
b2[0x08] = b1[0x08] + b1[0x0B];
b2[0x0B] = MUL((b1[0x08] - b1[0x0B]),COS_3_0);
b2[0x09] = b1[0x09] + b1[0x0A];
b2[0x0A] = MUL((b1[0x09] - b1[0x0A]),COS_3_1);
b2[0x0C] = b1[0x0C] + b1[0x0F];
b2[0x0F] = MUL((b1[0x0F] - b1[0x0C]),COS_3_0);
b2[0x0D] = b1[0x0D] + b1[0x0E];
b2[0x0E] = MUL((b1[0x0E] - b1[0x0D]),COS_3_1);
 
b2[0x10] = b1[0x10] + b1[0x13];
b2[0x13] = MUL((b1[0x10] - b1[0x13]),COS_3_0);
b2[0x11] = b1[0x11] + b1[0x12];
b2[0x12] = MUL((b1[0x11] - b1[0x12]),COS_3_1);
 
b2[0x14] = b1[0x14] + b1[0x17];
b2[0x17] = MUL((b1[0x17] - b1[0x14]),COS_3_0);
b2[0x15] = b1[0x15] + b1[0x16];
b2[0x16] = MUL((b1[0x16] - b1[0x15]),COS_3_1);
 
b2[0x18] = b1[0x18] + b1[0x1B];
b2[0x1B] = MUL((b1[0x18] - b1[0x1B]),COS_3_0);
b2[0x19] = b1[0x19] + b1[0x1A];
b2[0x1A] = MUL((b1[0x19] - b1[0x1A]),COS_3_1);
 
b2[0x1C] = b1[0x1C] + b1[0x1F];
b2[0x1F] = MUL((b1[0x1F] - b1[0x1C]),COS_3_0);
b2[0x1D] = b1[0x1D] + b1[0x1E];
b2[0x1E] = MUL((b1[0x1E] - b1[0x1D]),COS_3_1);
 
{
int i;
for(i=0;i<32;i+=4) {
b1[i+0x00] = b2[i+0x00] + b2[i+0x01];
b1[i+0x01] = MUL((b2[i+0x00] - b2[i+0x01]),COS_4_0);
b1[i+0x02] = b2[i+0x02] + b2[i+0x03];
b1[i+0x03] = MUL((b2[i+0x03] - b2[i+0x02]),COS_4_0);
}
}
 
b1[0x02] += b1[0x03];
b1[0x06] += b1[0x07];
b1[0x04] += b1[0x06];
b1[0x06] += b1[0x05];
b1[0x05] += b1[0x07];
 
b1[0x0A] += b1[0x0B];
b1[0x0E] += b1[0x0F];
b1[0x0C] += b1[0x0E];
b1[0x0E] += b1[0x0D];
b1[0x0D] += b1[0x0F];
 
b1[0x12] += b1[0x13];
b1[0x16] += b1[0x17];
b1[0x14] += b1[0x16];
b1[0x16] += b1[0x15];
b1[0x15] += b1[0x17];
 
b1[0x1A] += b1[0x1B];
b1[0x1E] += b1[0x1F];
b1[0x1C] += b1[0x1E];
b1[0x1E] += b1[0x1D];
b1[0x1D] += b1[0x1F];
 
SETOUT(out0,16,b1[0x00]);
SETOUT(out0,12,b1[0x04]);
SETOUT(out0, 8,b1[0x02]);
SETOUT(out0, 4,b1[0x06]);
SETOUT(out0, 0,b1[0x01]);
SETOUT(out1, 0,b1[0x01]);
SETOUT(out1, 4,b1[0x05]);
SETOUT(out1, 8,b1[0x03]);
SETOUT(out1,12,b1[0x07]);
 
b1[0x08] += b1[0x0C];
SETOUT(out0,14,b1[0x08]);
b1[0x0C] += b1[0x0a];
SETOUT(out0,10,b1[0x0C]);
b1[0x0A] += b1[0x0E];
SETOUT(out0, 6,b1[0x0A]);
b1[0x0E] += b1[0x09];
SETOUT(out0, 2,b1[0x0E]);
b1[0x09] += b1[0x0D];
SETOUT(out1, 2,b1[0x09]);
b1[0x0D] += b1[0x0B];
SETOUT(out1, 6,b1[0x0D]);
b1[0x0B] += b1[0x0F];
SETOUT(out1,10,b1[0x0B]);
SETOUT(out1,14,b1[0x0F]);
 
b1[0x18] += b1[0x1C];
SETOUT(out0,15,b1[0x10] + b1[0x18]);
SETOUT(out0,13,b1[0x18] + b1[0x14]);
b1[0x1C] += b1[0x1a];
SETOUT(out0,11,b1[0x14] + b1[0x1C]);
SETOUT(out0, 9,b1[0x1C] + b1[0x12]);
b1[0x1A] += b1[0x1E];
SETOUT(out0, 7,b1[0x12] + b1[0x1A]);
SETOUT(out0, 5,b1[0x1A] + b1[0x16]);
b1[0x1E] += b1[0x19];
SETOUT(out0, 3,b1[0x16] + b1[0x1E]);
SETOUT(out0, 1,b1[0x1E] + b1[0x11]);
b1[0x19] += b1[0x1D];
SETOUT(out1, 1,b1[0x11] + b1[0x19]);
SETOUT(out1, 3,b1[0x19] + b1[0x15]);
b1[0x1D] += b1[0x1B];
SETOUT(out1, 5,b1[0x15] + b1[0x1D]);
SETOUT(out1, 7,b1[0x1D] + b1[0x13]);
b1[0x1B] += b1[0x1F];
SETOUT(out1, 9,b1[0x13] + b1[0x1B]);
SETOUT(out1,11,b1[0x1B] + b1[0x17]);
SETOUT(out1,13,b1[0x17] + b1[0x1F]);
SETOUT(out1,15,b1[0x1F]);
}
 
 
/*
* the call via dct64 is a trick to force GCC to use
* (new) registers for the b1,b2 pointer to the bufs[xx] field
*/
void dct64_486(int *a,int *b,real *samples)
{
int bufs[64];
int i;
 
#ifdef REAL_IS_FIXED
#define TOINT(a) ((a) * 32768 / (int)REAL_FACTOR)
 
for(i=0;i<32;i++) {
bufs[i]=TOINT(samples[i]);
}
#else
int *p = bufs;
register double const scale = ((65536.0 * 32) + 1) * 65536.0;
for(i=0;i<32;i++) {
*((double *) (p++)) = scale + *samples++; /* beware on bufs overrun: 8B store from x87 */
}
#endif
dct64_1_486(a,b,bufs+32,bufs);
}
 
/programs/media/ac97snd/mpg/decode_i386.c
0,0 → 1,269
/*
decode_i386.c: decode for i386 (really faster?)
 
copyright 1995-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
slighlty optimized for machines without autoincrement/decrement.
The performance is highly compiler dependend. Maybe
the decode.c version for 'normal' processor may be faster
even for Intel processors.
*/
 
//#include <stdlib.h>
#include <math.h>
//#include <string.h>
 
//#include "config.h"
#include "mpg123.h"
 
#if 0
/* old WRITE_SAMPLE */
#define WRITE_SAMPLE(samples,sum,clip) \
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \
else { *(samples) = sum; }
#else
/* new WRITE_SAMPLE */
/* keep in mind that we are on known little-endian i386 here and special tricks are allowed... */
#define WRITE_SAMPLE(samples,sum,clip) { \
double dtemp; int v; /* sizeof(int) == 4 */ \
dtemp = ((((65536.0 * 65536.0 * 16)+(65536.0 * 0.5))* 65536.0)) + (sum); \
v = ((*(int *)&dtemp) - 0x80000000); \
if( v > 32767) { *(samples) = 0x7fff; (clip)++; } \
else if( v < -32768) { *(samples) = -0x8000; (clip)++; } \
else { *(samples) = v; } \
}
#endif
 
#if 0
int synth_1to1_8bit(real *bandPtr,int channel,unsigned char *samples,int *pnt)
{
short samples_tmp[64];
short *tmp1 = samples_tmp + channel;
int i,ret;
int pnt1 = 0;
 
ret = synth_1to1(bandPtr,channel,(unsigned char *)samples_tmp,&pnt1);
samples += channel + *pnt;
 
for(i=0;i<32;i++) {
*samples = conv16to8[*tmp1>>AUSHIFT];
samples += 2;
tmp1 += 2;
}
*pnt += 64;
 
return ret;
}
 
int synth_1to1_8bit_mono(real *bandPtr,unsigned char *samples,int *pnt)
{
short samples_tmp[64];
short *tmp1 = samples_tmp;
int i,ret;
int pnt1 = 0;
 
ret = synth_1to1(bandPtr,0,(unsigned char *)samples_tmp,&pnt1);
samples += *pnt;
 
for(i=0;i<32;i++) {
*samples++ = conv16to8[*tmp1>>AUSHIFT];
tmp1+=2;
}
*pnt += 32;
 
return ret;
}
 
int synth_1to1_8bit_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
{
short samples_tmp[64];
short *tmp1 = samples_tmp;
int i,ret;
int pnt1 = 0;
 
ret = synth_1to1(bandPtr,0,(unsigned char *)samples_tmp,&pnt1);
samples += *pnt;
 
for(i=0;i<32;i++) {
*samples++ = conv16to8[*tmp1>>AUSHIFT];
*samples++ = conv16to8[*tmp1>>AUSHIFT];
tmp1 += 2;
}
*pnt += 64;
 
return ret;
}
 
int synth_1to1_mono(real *bandPtr,unsigned char *samples,int *pnt)
{
short samples_tmp[64];
short *tmp1 = samples_tmp;
int i,ret;
int pnt1 = 0;
 
ret = synth_1to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1);
samples += *pnt;
 
for(i=0;i<32;i++) {
*( (short *) samples) = *tmp1;
samples += 2;
tmp1 += 2;
}
*pnt += 64;
 
return ret;
}
#endif
 
int synth_1to1_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt)
{
int i,ret;
 
ret = synth_1to1(bandPtr,0,samples,pnt);
samples = samples + *pnt - 128;
 
for(i=0;i<32;i++) {
((short *)samples)[1] = ((short *)samples)[0];
samples+=4;
}
 
return ret;
}
 
 
static real buffs[2][2][0x110];
static const int step = 2;
static int bo = 1;
 
void init_dct()
{
bo = 1;
memset(buffs,0, sizeof(buffs));
 
};
 
 
int synth_1to1(real *bandPtr,int channel,unsigned char *out,int *pnt)
{
#ifndef PENTIUM_OPT
short *samples = (short *) (out + *pnt);
 
real *b0,(*buf)[0x110];
int clip = 0;
int bo1;
#endif
 
// if(have_eq_settings)
// do_equalizer(bandPtr,channel);
 
#ifndef PENTIUM_OPT
if(!channel) {
bo--;
bo &= 0xf;
buf = buffs[0];
}
else {
samples++;
buf = buffs[1];
}
 
if(bo & 0x1) {
b0 = buf[0];
bo1 = bo;
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr);
}
else {
b0 = buf[1];
bo1 = bo+1;
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr);
}
{
register int j;
real *window = decwin + 16 - bo1;
 
for (j=16;j;j--,b0+=0x10,window+=0x20,samples+=step)
{
real sum;
sum = window[0x0] * b0[0x0];
sum -= window[0x1] * b0[0x1];
sum += window[0x2] * b0[0x2];
sum -= window[0x3] * b0[0x3];
sum += window[0x4] * b0[0x4];
sum -= window[0x5] * b0[0x5];
sum += window[0x6] * b0[0x6];
sum -= window[0x7] * b0[0x7];
sum += window[0x8] * b0[0x8];
sum -= window[0x9] * b0[0x9];
sum += window[0xA] * b0[0xA];
sum -= window[0xB] * b0[0xB];
sum += window[0xC] * b0[0xC];
sum -= window[0xD] * b0[0xD];
sum += window[0xE] * b0[0xE];
sum -= window[0xF] * b0[0xF];
 
WRITE_SAMPLE(samples,sum,clip);
}
 
{
real sum;
sum = window[0x0] * b0[0x0];
sum += window[0x2] * b0[0x2];
sum += window[0x4] * b0[0x4];
sum += window[0x6] * b0[0x6];
sum += window[0x8] * b0[0x8];
sum += window[0xA] * b0[0xA];
sum += window[0xC] * b0[0xC];
sum += window[0xE] * b0[0xE];
WRITE_SAMPLE(samples,sum,clip);
b0-=0x10,window-=0x20,samples+=step;
}
window += bo1<<1;
 
for (j=15;j;j--,b0-=0x10,window-=0x20,samples+=step)
{
real sum;
sum = -window[-0x1] * b0[0x0];
sum -= window[-0x2] * b0[0x1];
sum -= window[-0x3] * b0[0x2];
sum -= window[-0x4] * b0[0x3];
sum -= window[-0x5] * b0[0x4];
sum -= window[-0x6] * b0[0x5];
sum -= window[-0x7] * b0[0x6];
sum -= window[-0x8] * b0[0x7];
sum -= window[-0x9] * b0[0x8];
sum -= window[-0xA] * b0[0x9];
sum -= window[-0xB] * b0[0xA];
sum -= window[-0xC] * b0[0xB];
sum -= window[-0xD] * b0[0xC];
sum -= window[-0xE] * b0[0xD];
sum -= window[-0xF] * b0[0xE];
sum -= window[-0x0] * b0[0xF];
 
WRITE_SAMPLE(samples,sum,clip);
}
}
*pnt += 128;
 
return clip;
#elif defined(USE_MMX)
{
static short buffs[2][2][0x110];
static int bo = 1;
short *samples = (short *) (out + *pnt);
synth_1to1_MMX(bandPtr, channel, samples, (short *) buffs, &bo);
*pnt += 128;
return 0;
}
#else
{
int ret;
ret = synth_1to1_pent(bandPtr,channel,out+*pnt);
*pnt += 128;
return ret;
}
#endif
}
/programs/media/ac97snd/mpg/decode_i486.c
0,0 → 1,255
/*
decode_i486.c: i486 decode
 
copyright 1998-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Fabrice Bellard
*/
 
/*
* Subband Synthesis for MPEG Audio.
*
* Version optimized for 80486 by using integer arithmetic,
* multiplications by shift and add, and by increasing locality in
* order to fit the 8KB L1 cache. This code should be compiled with gcc
* 2.7.2 or higher.
*
* Note: this version does not guaranty a good accuracy. The filter
* coefficients are quantified on 14 bits.
*
* (c) 1998 Fabrice Bellard
*/
 
//#include <stdlib.h>
#include "mpg123.h"
 
#define FIR_SIZE 16
 
#define FIR16_1(pos,c0,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15) \
{\
int sum;\
sum=(c0)*b0[0]+(c1)*b0[1]+(c2)*b0[2]+(c3)*b0[3]+\
(c4)*b0[4]+(c5)*b0[5]+(c6)*b0[6]+(c7)*b0[7]+\
(c8)*b0[8]+(c9)*b0[9]+(c10)*b0[10]+(c11)*b0[11]+\
(c12)*b0[12]+(c13)*b0[13]+(c14)*b0[14]+(c15)*b0[15];\
sum=(sum+(1 << 13))>>14;\
if (sum<-32768) sum=-32768;\
else if (sum>32767) sum=32767;\
samples[2*(pos)]=sum;\
b0+=FIR_BUFFER_SIZE;\
}
 
#define FIR16_2(pos1,c0,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,\
pos2,d0,d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15) \
{\
int sum1,sum2,v;\
\
v=b0[0];\
sum1=(c0)*v;\
sum2=(d0)*v;\
v=b0[1];\
sum1+=(c1)*v;\
sum2+=(d1)*v;\
v=b0[2];\
sum1+=(c2)*v;\
sum2+=(d2)*v;\
v=b0[3];\
sum1+=(c3)*v;\
sum2+=(d3)*v;\
v=b0[4];\
sum1+=(c4)*v;\
sum2+=(d4)*v;\
v=b0[5];\
sum1+=(c5)*v;\
sum2+=(d5)*v;\
v=b0[6];\
sum1+=(c6)*v;\
sum2+=(d6)*v;\
v=b0[7];\
sum1+=(c7)*v;\
sum2+=(d7)*v;\
v=b0[8];\
sum1+=(c8)*v;\
sum2+=(d8)*v;\
v=b0[9];\
sum1+=(c9)*v;\
sum2+=(d9)*v;\
v=b0[10];\
sum1+=(c10)*v;\
sum2+=(d10)*v;\
v=b0[11];\
sum1+=(c11)*v;\
sum2+=(d11)*v;\
v=b0[12];\
sum1+=(c12)*v;\
sum2+=(d12)*v;\
v=b0[13];\
sum1+=(c13)*v;\
sum2+=(d13)*v;\
v=b0[14];\
sum1+=(c14)*v;\
sum2+=(d14)*v;\
v=b0[15];\
sum1+=(c15)*v;\
sum2+=(d15)*v;\
\
sum1=(sum1+(1<<13))>>14;\
sum2=(sum2+(1<<13))>>14;\
\
if (sum1<-32768) sum1=-32768;\
else if (sum1>32767) sum1=32767;\
samples[(pos1)*2]=sum1;\
\
if (sum2<-32768) sum2=-32768;\
else if (sum2>32767) sum2=32767;\
samples[(pos2)*2]=sum2;\
b0+=FIR_BUFFER_SIZE;\
}
 
int synth_1to1_486(real *bandPtr,int channel,unsigned char *out,int nb_blocks)
{
static int buffs[2][2][17*FIR_BUFFER_SIZE];
static int bo[2] = { FIR_SIZE-1, FIR_SIZE-1 };
short *samples = (short *) out;
int *b0,(*buf)[17*FIR_BUFFER_SIZE];
int clip = 0;
int block,b,bo_start;
 
/* samples address */
samples+=channel;
 
bo_start=bo[channel];
buf = buffs[channel];
 
b=bo_start;
for(block=0;block<nb_blocks;block++) {
 
/* FIR offset */
b++;
if (b >= FIR_BUFFER_SIZE) {
int *p,*q;
int c,i,j;
/* we shift the buffers */
for(c=0;c<2;c++) {
p=&buf[c][0]+1;
q=p+(FIR_BUFFER_SIZE-FIR_SIZE);
for(i=0;i<17;i++) {
for(j=0;j<FIR_SIZE-1;j++) p[j]=q[j];
p+=FIR_BUFFER_SIZE;
q+=FIR_BUFFER_SIZE;
}
}
/* we update 'bo' accordingly */
b=bo[channel]=FIR_SIZE;
}
if(b & 1) {
dct64_486(buf[1]+b,buf[0]+b,bandPtr);
} else {
dct64_486(buf[0]+b,buf[1]+b,bandPtr);
}
bandPtr+=32;
}
bo[channel]=b;
 
/* filter bank: part 1 */
b=bo_start;
for(block=0;block<nb_blocks;block++) {
b++;
if (b >= FIR_BUFFER_SIZE) b=FIR_SIZE;
if(b & 1) {
b0 = buf[0] + b - (FIR_SIZE-1);
} else {
b0 = buf[1] + b - (FIR_SIZE-1);
}
 
FIR16_1(0,-7,53,-114,509,-1288,1643,-9372,18759,9372,1643,1288,509,114,53,7,0);
FIR16_2(1,-6,52,-100,515,-1197,1783,-8910,18748,9834,1489,1379,500,129,54,7,0,
31,0,-7,54,-129,500,-1379,1489,-9834,18748,8910,1783,1197,515,100,52,6);
FIR16_2(2,-6,50,-86,520,-1106,1910,-8447,18714,10294,1322,1469,488,145,55,8,0,
30,0,-8,55,-145,488,-1469,1322,-10294,18714,8447,1910,1106,520,86,50,6);
FIR16_2(3,-5,49,-73,521,-1015,2023,-7986,18657,10751,1140,1559,473,161,56,9,0,
29,0,-9,56,-161,473,-1559,1140,-10751,18657,7986,2023,1015,521,73,49,5);
samples+=64;
}
samples-=64*nb_blocks;
/* filter bank: part 2 */
 
b=bo_start;
for(block=0;block<nb_blocks;block++) {
b++;
if (b >= FIR_BUFFER_SIZE) b=FIR_SIZE;
if(b & 1) {
b0 = buf[0] + b - (FIR_SIZE-1) + 4*FIR_BUFFER_SIZE;
} else {
b0 = buf[1] + b - (FIR_SIZE-1) + 4*FIR_BUFFER_SIZE;
}
 
FIR16_2(4,-4,47,-61,521,-926,2123,-7528,18578,11205,944,1647,455,177,56,10,0,
28,0,-10,56,-177,455,-1647,944,-11205,18578,7528,2123,926,521,61,47,4);
FIR16_2(5,-4,45,-49,518,-837,2210,-7072,18477,11654,733,1733,434,194,57,11,0,
27,0,-11,57,-194,434,-1733,733,-11654,18477,7072,2210,837,518,49,45,4);
FIR16_2(6,-4,44,-38,514,-751,2284,-6620,18353,12097,509,1817,411,212,57,12,0,
26,0,-12,57,-212,411,-1817,509,-12097,18353,6620,2284,751,514,38,44,4);
FIR16_2(7,-3,42,-27,508,-665,2347,-6173,18208,12534,270,1899,383,229,56,13,0,
25,0,-13,56,-229,383,-1899,270,-12534,18208,6173,2347,665,508,27,42,3);
 
samples+=64;
}
samples-=64*nb_blocks;
 
/* filter bank: part 3 */
 
b=bo_start;
for(block=0;block<nb_blocks;block++) {
b++;
if (b >= FIR_BUFFER_SIZE) b=FIR_SIZE;
if(b & 1) {
b0 = buf[0] + b - (FIR_SIZE-1) + 8*FIR_BUFFER_SIZE;
} else {
b0 = buf[1] + b - (FIR_SIZE-1) + 8*FIR_BUFFER_SIZE;
}
 
FIR16_2(8,-3,40,-18,500,-582,2398,-5732,18042,12963,17,1977,353,247,56,14,0,
24,0,-14,56,-247,353,-1977,17,-12963,18042,5732,2398,582,500,18,40,3);
FIR16_2(9,-2,38,-9,490,-501,2437,-5297,17855,13383,-249,2052,320,266,55,15,0,
23,0,-15,55,-266,320,-2052,-249,-13383,17855,5297,2437,501,490,9,38,2);
FIR16_2(10,-2,36,0,479,-423,2465,-4869,17647,13794,-530,2122,282,284,53,17,0,
22,0,-17,53,-284,282,-2122,-530,-13794,17647,4869,2465,423,479,0,36,2);
FIR16_2(11,-2,34,7,467,-347,2483,-4449,17419,14194,-825,2188,242,302,52,18,0,
21,0,-18,52,-302,242,-2188,-825,-14194,17419,4449,2483,347,467,-7,34,2);
 
samples+=64;
}
samples-=64*nb_blocks;
 
/* filter bank: part 4 */
 
b=bo_start;
for(block=0;block<nb_blocks;block++) {
b++;
if (b >= FIR_BUFFER_SIZE) b=FIR_SIZE;
if(b & 1) {
b0 = buf[0] + b - (FIR_SIZE-1) + 12*FIR_BUFFER_SIZE;
} else {
b0 = buf[1] + b - (FIR_SIZE-1) + 12*FIR_BUFFER_SIZE;
}
 
FIR16_2(12,-2,33,14,454,-273,2491,-4038,17173,14583,-1133,2249,198,320,50,19,0,
20,0,-19,50,-320,198,-2249,-1133,-14583,17173,4038,2491,273,454,-14,33,2);
FIR16_2(13,-1,31,20,439,-203,2489,-3637,16907,14959,-1454,2304,151,339,47,21,-1,
19,-1,-21,47,-339,151,-2304,-1454,-14959,16907,3637,2489,203,439,-20,31,1);
FIR16_2(14,-1,29,26,424,-136,2479,-3245,16623,15322,-1788,2354,100,357,44,22,-1,
18,-1,-22,44,-357,100,-2354,-1788,-15322,16623,3245,2479,136,424,-26,29,1);
FIR16_2(15,-1,27,31,408,-72,2459,-2863,16322,15671,-2135,2396,46,374,40,24,-1,
17,-1,-24,40,-374,46,-2396,-2135,-15671,16322,2863,2459,72,408,-31,27,1);
FIR16_1(16,-1,0,36,0,-11,0,-2493,0,16004,0,2431,0,391,0,26,0);
 
samples+=64;
}
 
return clip;
}
 
/programs/media/ac97snd/mpg/e_pow.c
0,0 → 1,358
/* @(#)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 _cdecl 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;
}
/programs/media/ac97snd/mpg/getbits.c
0,0 → 1,134
/*
getbits
 
copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
*/
 
#include "mpg123.h"
 
#if 0
static void check_buffer_range(int size)
{
int pos = (bsi.wordpointer-bsbuf) + (size>>3);
 
if( pos >= fsizeold) {
fprintf(stderr,"Pointer out of range (%d,%d)!\n",pos,fsizeold);
}
}
#endif
 
void backbits(int number_of_bits)
{
bsi.bitindex -= number_of_bits;
bsi.wordpointer += (bsi.bitindex>>3);
bsi.bitindex &= 0x7;
}
 
int getbitoffset(void)
{
return (-bsi.bitindex)&0x7;
}
 
int getbyte(void)
{
#ifdef DEBUG_GETBITS
if(bsi.bitindex)
fprintf(stderr,"getbyte called unsynched!\n");
#endif
return *bsi.wordpointer++;
}
 
unsigned int getbits(int number_of_bits)
{
unsigned long rval;
 
#ifdef DEBUG_GETBITS
fprintf(stderr,"g%d",number_of_bits);
#endif
 
if(!number_of_bits)
return 0;
 
#if 0
check_buffer_range(number_of_bits+bsi.bitindex);
#endif
 
{
rval = bsi.wordpointer[0];
rval <<= 8;
rval |= bsi.wordpointer[1];
rval <<= 8;
rval |= bsi.wordpointer[2];
 
rval <<= bsi.bitindex;
rval &= 0xffffff;
 
bsi.bitindex += number_of_bits;
 
rval >>= (24-number_of_bits);
 
bsi.wordpointer += (bsi.bitindex>>3);
bsi.bitindex &= 7;
}
 
#ifdef DEBUG_GETBITS
fprintf(stderr,":%x ",rval);
#endif
 
return rval;
}
 
unsigned int getbits_fast(int number_of_bits)
{
unsigned int rval;
#ifdef DEBUG_GETBITS
fprintf(stderr,"g%d",number_of_bits);
#endif
 
#if 0
check_buffer_range(number_of_bits+bsi.bitindex);
#endif
 
rval = (unsigned char) (bsi.wordpointer[0] << bsi.bitindex);
rval |= ((unsigned int) bsi.wordpointer[1]<<bsi.bitindex)>>8;
rval <<= number_of_bits;
rval >>= 8;
 
bsi.bitindex += number_of_bits;
 
bsi.wordpointer += (bsi.bitindex>>3);
bsi.bitindex &= 7;
 
#ifdef DEBUG_GETBITS
fprintf(stderr,":%x ",rval);
#endif
return rval;
}
 
unsigned int get1bit(void)
{
unsigned char rval;
 
#ifdef DEBUG_GETBITS
fprintf(stderr,"g%d",1);
#endif
 
#if 0
check_buffer_range(1+bsi.bitindex);
#endif
 
rval = *bsi.wordpointer << bsi.bitindex;
 
bsi.bitindex++;
bsi.wordpointer += (bsi.bitindex>>3);
bsi.bitindex &= 7;
 
#ifdef DEBUG_GETBITS
fprintf(stderr,":%d ",rval>>7);
#endif
 
return rval>>7;
}
 
/programs/media/ac97snd/mpg/getbits.h
0,0 → 1,45
/*
getbits
 
copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
*/
 
#ifndef _MPG123_GETBITS_H_
#define _MPG123_GETBITS_H_
 
/* that's the same file as getits.c but with defines to
force inlining */
 
static unsigned long rval;
static unsigned char rval_uc;
 
#define backbits(nob) ((void)( \
bsi.bitindex -= nob, \
bsi.wordpointer += (bsi.bitindex>>3), \
bsi.bitindex &= 0x7 ))
 
#define getbitoffset() ((-bsi.bitindex)&0x7)
#define getbyte() (*bsi.wordpointer++)
 
#define getbits(nob) ( \
rval = bsi.wordpointer[0], rval <<= 8, rval |= bsi.wordpointer[1], \
rval <<= 8, rval |= bsi.wordpointer[2], rval <<= bsi.bitindex, \
rval &= 0xffffff, bsi.bitindex += nob, \
rval >>= (24-nob), bsi.wordpointer += (bsi.bitindex>>3), \
bsi.bitindex &= 7,rval)
 
#define getbits_fast(nob) ( \
rval = (unsigned char) (bsi.wordpointer[0] << bsi.bitindex), \
rval |= ((unsigned long) bsi.wordpointer[1]<<bsi.bitindex)>>8, \
rval <<= nob, rval >>= 8, \
bsi.bitindex += nob, bsi.wordpointer += (bsi.bitindex>>3), \
bsi.bitindex &= 7, rval )
 
#define get1bit() ( \
rval_uc = *bsi.wordpointer << bsi.bitindex, bsi.bitindex++, \
bsi.wordpointer += (bsi.bitindex>>3), bsi.bitindex &= 7, rval_uc>>7 )
 
 
#endif
/programs/media/ac97snd/mpg/huffman.h
0,0 → 1,340
/*
huffman.h: huffman tables ... recalcualted to work with optimzed decoder scheme (MH)
 
copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
probably we could save a few bytes of memory, because the
smaller tables are often the part of a bigger table
*/
 
 
#ifndef _MPG123_HUFFMAN_H_
#define _MPG123_HUFFMAN_H_
 
struct newhuff
{
unsigned int linbits;
short *table;
};
 
static short tab0[] =
{
0
};
 
static short tab1[] =
{
-5, -3, -1, 17, 1, 16, 0
};
 
static short tab2[] =
{
-15, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 17, -1, 1,
16, 0
};
 
static short tab3[] =
{
-13, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 16, 17, -1,
1, 0
};
 
static short tab5[] =
{
-29, -25, -23, -15, -7, -5, -3, -1, 51, 35, 50, 49, -3, -1, 19,
3, -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, 17, -1, 1, 16,
0
};
 
static short tab6[] =
{
-25, -19, -13, -9, -5, -3, -1, 51, 3, 35, -1, 50, 48, -1, 19,
49, -3, -1, 34, 2, 18, -3, -1, 33, 32, 1, -1, 17, -1, 16,
0
};
 
static short tab7[] =
{
-69, -65, -57, -39, -29, -17, -11, -7, -3, -1, 85, 69, -1, 84, 83,
-1, 53, 68, -3, -1, 37, 82, 21, -5, -1, 81, -1, 5, 52, -1,
80, -1, 67, 51, -5, -3, -1, 36, 66, 20, -1, 65, 64, -11, -7,
-3, -1, 4, 35, -1, 50, 3, -1, 19, 49, -3, -1, 48, 34, 18,
-5, -1, 33, -1, 2, 32, 17, -1, 1, 16, 0
};
 
static short tab8[] =
{
-65, -63, -59, -45, -31, -19, -13, -7, -5, -3, -1, 85, 84, 69, 83,
-3, -1, 53, 68, 37, -3, -1, 82, 5, 21, -5, -1, 81, -1, 52,
67, -3, -1, 80, 51, 36, -5, -3, -1, 66, 20, 65, -3, -1, 4,
64, -1, 35, 50, -9, -7, -3, -1, 19, 49, -1, 3, 48, 34, -1,
2, 32, -1, 18, 33, 17, -3, -1, 1, 16, 0
};
 
static short tab9[] =
{
-63, -53, -41, -29, -19, -11, -5, -3, -1, 85, 69, 53, -1, 83, -1,
84, 5, -3, -1, 68, 37, -1, 82, 21, -3, -1, 81, 52, -1, 67,
-1, 80, 4, -7, -3, -1, 36, 66, -1, 51, 64, -1, 20, 65, -5,
-3, -1, 35, 50, 19, -1, 49, -1, 3, 48, -5, -3, -1, 34, 2,
18, -1, 33, 32, -3, -1, 17, 1, -1, 16, 0
};
 
static short tab10[] =
{
-125,-121,-111, -83, -55, -35, -21, -13, -7, -3, -1, 119, 103, -1, 118,
87, -3, -1, 117, 102, 71, -3, -1, 116, 86, -1, 101, 55, -9, -3,
-1, 115, 70, -3, -1, 85, 84, 99, -1, 39, 114, -11, -5, -3, -1,
100, 7, 112, -1, 98, -1, 69, 53, -5, -1, 6, -1, 83, 68, 23,
-17, -5, -1, 113, -1, 54, 38, -5, -3, -1, 37, 82, 21, -1, 81,
-1, 52, 67, -3, -1, 22, 97, -1, 96, -1, 5, 80, -19, -11, -7,
-3, -1, 36, 66, -1, 51, 4, -1, 20, 65, -3, -1, 64, 35, -1,
50, 3, -3, -1, 19, 49, -1, 48, 34, -7, -3, -1, 18, 33, -1,
2, 32, 17, -1, 1, 16, 0
};
 
static short tab11[] =
{
-121,-113, -89, -59, -43, -27, -17, -7, -3, -1, 119, 103, -1, 118, 117,
-3, -1, 102, 71, -1, 116, -1, 87, 85, -5, -3, -1, 86, 101, 55,
-1, 115, 70, -9, -7, -3, -1, 69, 84, -1, 53, 83, 39, -1, 114,
-1, 100, 7, -5, -1, 113, -1, 23, 112, -3, -1, 54, 99, -1, 96,
-1, 68, 37, -13, -7, -5, -3, -1, 82, 5, 21, 98, -3, -1, 38,
6, 22, -5, -1, 97, -1, 81, 52, -5, -1, 80, -1, 67, 51, -1,
36, 66, -15, -11, -7, -3, -1, 20, 65, -1, 4, 64, -1, 35, 50,
-1, 19, 49, -5, -3, -1, 3, 48, 34, 33, -5, -1, 18, -1, 2,
32, 17, -3, -1, 1, 16, 0
};
 
static short tab12[] =
{
-115, -99, -73, -45, -27, -17, -9, -5, -3, -1, 119, 103, 118, -1, 87,
117, -3, -1, 102, 71, -1, 116, 101, -3, -1, 86, 55, -3, -1, 115,
85, 39, -7, -3, -1, 114, 70, -1, 100, 23, -5, -1, 113, -1, 7,
112, -1, 54, 99, -13, -9, -3, -1, 69, 84, -1, 68, -1, 6, 5,
-1, 38, 98, -5, -1, 97, -1, 22, 96, -3, -1, 53, 83, -1, 37,
82, -17, -7, -3, -1, 21, 81, -1, 52, 67, -5, -3, -1, 80, 4,
36, -1, 66, 20, -3, -1, 51, 65, -1, 35, 50, -11, -7, -5, -3,
-1, 64, 3, 48, 19, -1, 49, 34, -1, 18, 33, -7, -5, -3, -1,
2, 32, 0, 17, -1, 1, 16
};
 
static short tab13[] =
{
-509,-503,-475,-405,-333,-265,-205,-153,-115, -83, -53, -35, -21, -13, -9,
-7, -5, -3, -1, 254, 252, 253, 237, 255, -1, 239, 223, -3, -1, 238,
207, -1, 222, 191, -9, -3, -1, 251, 206, -1, 220, -1, 175, 233, -1,
236, 221, -9, -5, -3, -1, 250, 205, 190, -1, 235, 159, -3, -1, 249,
234, -1, 189, 219, -17, -9, -3, -1, 143, 248, -1, 204, -1, 174, 158,
-5, -1, 142, -1, 127, 126, 247, -5, -1, 218, -1, 173, 188, -3, -1,
203, 246, 111, -15, -7, -3, -1, 232, 95, -1, 157, 217, -3, -1, 245,
231, -1, 172, 187, -9, -3, -1, 79, 244, -3, -1, 202, 230, 243, -1,
63, -1, 141, 216, -21, -9, -3, -1, 47, 242, -3, -1, 110, 156, 15,
-5, -3, -1, 201, 94, 171, -3, -1, 125, 215, 78, -11, -5, -3, -1,
200, 214, 62, -1, 185, -1, 155, 170, -1, 31, 241, -23, -13, -5, -1,
240, -1, 186, 229, -3, -1, 228, 140, -1, 109, 227, -5, -1, 226, -1,
46, 14, -1, 30, 225, -15, -7, -3, -1, 224, 93, -1, 213, 124, -3,
-1, 199, 77, -1, 139, 184, -7, -3, -1, 212, 154, -1, 169, 108, -1,
198, 61, -37, -21, -9, -5, -3, -1, 211, 123, 45, -1, 210, 29, -5,
-1, 183, -1, 92, 197, -3, -1, 153, 122, 195, -7, -5, -3, -1, 167,
151, 75, 209, -3, -1, 13, 208, -1, 138, 168, -11, -7, -3, -1, 76,
196, -1, 107, 182, -1, 60, 44, -3, -1, 194, 91, -3, -1, 181, 137,
28, -43, -23, -11, -5, -1, 193, -1, 152, 12, -1, 192, -1, 180, 106,
-5, -3, -1, 166, 121, 59, -1, 179, -1, 136, 90, -11, -5, -1, 43,
-1, 165, 105, -1, 164, -1, 120, 135, -5, -1, 148, -1, 119, 118, 178,
-11, -3, -1, 27, 177, -3, -1, 11, 176, -1, 150, 74, -7, -3, -1,
58, 163, -1, 89, 149, -1, 42, 162, -47, -23, -9, -3, -1, 26, 161,
-3, -1, 10, 104, 160, -5, -3, -1, 134, 73, 147, -3, -1, 57, 88,
-1, 133, 103, -9, -3, -1, 41, 146, -3, -1, 87, 117, 56, -5, -1,
131, -1, 102, 71, -3, -1, 116, 86, -1, 101, 115, -11, -3, -1, 25,
145, -3, -1, 9, 144, -1, 72, 132, -7, -5, -1, 114, -1, 70, 100,
40, -1, 130, 24, -41, -27, -11, -5, -3, -1, 55, 39, 23, -1, 113,
-1, 85, 7, -7, -3, -1, 112, 54, -1, 99, 69, -3, -1, 84, 38,
-1, 98, 53, -5, -1, 129, -1, 8, 128, -3, -1, 22, 97, -1, 6,
96, -13, -9, -5, -3, -1, 83, 68, 37, -1, 82, 5, -1, 21, 81,
-7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, -19, -11,
-5, -1, 65, -1, 4, 64, -3, -1, 35, 50, 19, -3, -1, 49, 3,
-1, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16,
0
};
 
static short tab15[] =
{
-495,-445,-355,-263,-183,-115, -77, -43, -27, -13, -7, -3, -1, 255, 239,
-1, 254, 223, -1, 238, -1, 253, 207, -7, -3, -1, 252, 222, -1, 237,
191, -1, 251, -1, 206, 236, -7, -3, -1, 221, 175, -1, 250, 190, -3,
-1, 235, 205, -1, 220, 159, -15, -7, -3, -1, 249, 234, -1, 189, 219,
-3, -1, 143, 248, -1, 204, 158, -7, -3, -1, 233, 127, -1, 247, 173,
-3, -1, 218, 188, -1, 111, -1, 174, 15, -19, -11, -3, -1, 203, 246,
-3, -1, 142, 232, -1, 95, 157, -3, -1, 245, 126, -1, 231, 172, -9,
-3, -1, 202, 187, -3, -1, 217, 141, 79, -3, -1, 244, 63, -1, 243,
216, -33, -17, -9, -3, -1, 230, 47, -1, 242, -1, 110, 240, -3, -1,
31, 241, -1, 156, 201, -7, -3, -1, 94, 171, -1, 186, 229, -3, -1,
125, 215, -1, 78, 228, -15, -7, -3, -1, 140, 200, -1, 62, 109, -3,
-1, 214, 227, -1, 155, 185, -7, -3, -1, 46, 170, -1, 226, 30, -5,
-1, 225, -1, 14, 224, -1, 93, 213, -45, -25, -13, -7, -3, -1, 124,
199, -1, 77, 139, -1, 212, -1, 184, 154, -7, -3, -1, 169, 108, -1,
198, 61, -1, 211, 210, -9, -5, -3, -1, 45, 13, 29, -1, 123, 183,
-5, -1, 209, -1, 92, 208, -1, 197, 138, -17, -7, -3, -1, 168, 76,
-1, 196, 107, -5, -1, 182, -1, 153, 12, -1, 60, 195, -9, -3, -1,
122, 167, -1, 166, -1, 192, 11, -1, 194, -1, 44, 91, -55, -29, -15,
-7, -3, -1, 181, 28, -1, 137, 152, -3, -1, 193, 75, -1, 180, 106,
-5, -3, -1, 59, 121, 179, -3, -1, 151, 136, -1, 43, 90, -11, -5,
-1, 178, -1, 165, 27, -1, 177, -1, 176, 105, -7, -3, -1, 150, 74,
-1, 164, 120, -3, -1, 135, 58, 163, -17, -7, -3, -1, 89, 149, -1,
42, 162, -3, -1, 26, 161, -3, -1, 10, 160, 104, -7, -3, -1, 134,
73, -1, 148, 57, -5, -1, 147, -1, 119, 9, -1, 88, 133, -53, -29,
-13, -7, -3, -1, 41, 103, -1, 118, 146, -1, 145, -1, 25, 144, -7,
-3, -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 71, -7,
-3, -1, 40, 130, -1, 24, 129, -7, -3, -1, 116, 8, -1, 128, 86,
-3, -1, 101, 55, -1, 115, 70, -17, -7, -3, -1, 39, 114, -1, 100,
23, -3, -1, 85, 113, -3, -1, 7, 112, 54, -7, -3, -1, 99, 69,
-1, 84, 38, -3, -1, 98, 22, -3, -1, 6, 96, 53, -33, -19, -9,
-5, -1, 97, -1, 83, 68, -1, 37, 82, -3, -1, 21, 81, -3, -1,
5, 80, 52, -7, -3, -1, 67, 36, -1, 66, 51, -1, 65, -1, 20,
4, -9, -3, -1, 35, 50, -3, -1, 64, 3, 19, -3, -1, 49, 48,
34, -9, -7, -3, -1, 18, 33, -1, 2, 32, 17, -3, -1, 1, 16,
0
};
 
static short tab16[] =
{
-509,-503,-461,-323,-103, -37, -27, -15, -7, -3, -1, 239, 254, -1, 223,
253, -3, -1, 207, 252, -1, 191, 251, -5, -1, 175, -1, 250, 159, -3,
-1, 249, 248, 143, -7, -3, -1, 127, 247, -1, 111, 246, 255, -9, -5,
-3, -1, 95, 245, 79, -1, 244, 243, -53, -1, 240, -1, 63, -29, -19,
-13, -7, -5, -1, 206, -1, 236, 221, 222, -1, 233, -1, 234, 217, -1,
238, -1, 237, 235, -3, -1, 190, 205, -3, -1, 220, 219, 174, -11, -5,
-1, 204, -1, 173, 218, -3, -1, 126, 172, 202, -5, -3, -1, 201, 125,
94, 189, 242, -93, -5, -3, -1, 47, 15, 31, -1, 241, -49, -25, -13,
-5, -1, 158, -1, 188, 203, -3, -1, 142, 232, -1, 157, 231, -7, -3,
-1, 187, 141, -1, 216, 110, -1, 230, 156, -13, -7, -3, -1, 171, 186,
-1, 229, 215, -1, 78, -1, 228, 140, -3, -1, 200, 62, -1, 109, -1,
214, 155, -19, -11, -5, -3, -1, 185, 170, 225, -1, 212, -1, 184, 169,
-5, -1, 123, -1, 183, 208, 227, -7, -3, -1, 14, 224, -1, 93, 213,
-3, -1, 124, 199, -1, 77, 139, -75, -45, -27, -13, -7, -3, -1, 154,
108, -1, 198, 61, -3, -1, 92, 197, 13, -7, -3, -1, 138, 168, -1,
153, 76, -3, -1, 182, 122, 60, -11, -5, -3, -1, 91, 137, 28, -1,
192, -1, 152, 121, -1, 226, -1, 46, 30, -15, -7, -3, -1, 211, 45,
-1, 210, 209, -5, -1, 59, -1, 151, 136, 29, -7, -3, -1, 196, 107,
-1, 195, 167, -1, 44, -1, 194, 181, -23, -13, -7, -3, -1, 193, 12,
-1, 75, 180, -3, -1, 106, 166, 179, -5, -3, -1, 90, 165, 43, -1,
178, 27, -13, -5, -1, 177, -1, 11, 176, -3, -1, 105, 150, -1, 74,
164, -5, -3, -1, 120, 135, 163, -3, -1, 58, 89, 42, -97, -57, -33,
-19, -11, -5, -3, -1, 149, 104, 161, -3, -1, 134, 119, 148, -5, -3,
-1, 73, 87, 103, 162, -5, -1, 26, -1, 10, 160, -3, -1, 57, 147,
-1, 88, 133, -9, -3, -1, 41, 146, -3, -1, 118, 9, 25, -5, -1,
145, -1, 144, 72, -3, -1, 132, 117, -1, 56, 131, -21, -11, -5, -3,
-1, 102, 40, 130, -3, -1, 71, 116, 24, -3, -1, 129, 128, -3, -1,
8, 86, 55, -9, -5, -1, 115, -1, 101, 70, -1, 39, 114, -5, -3,
-1, 100, 85, 7, 23, -23, -13, -5, -1, 113, -1, 112, 54, -3, -1,
99, 69, -1, 84, 38, -3, -1, 98, 22, -1, 97, -1, 6, 96, -9,
-5, -1, 83, -1, 53, 68, -1, 37, 82, -1, 81, -1, 21, 5, -33,
-23, -13, -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20,
-5, -1, 65, -1, 4, 64, -1, 35, 50, -3, -1, 19, 49, -3, -1,
3, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16,
0
};
 
static short tab24[] =
{
-451,-117, -43, -25, -15, -7, -3, -1, 239, 254, -1, 223, 253, -3, -1,
207, 252, -1, 191, 251, -5, -1, 250, -1, 175, 159, -1, 249, 248, -9,
-5, -3, -1, 143, 127, 247, -1, 111, 246, -3, -1, 95, 245, -1, 79,
244, -71, -7, -3, -1, 63, 243, -1, 47, 242, -5, -1, 241, -1, 31,
240, -25, -9, -1, 15, -3, -1, 238, 222, -1, 237, 206, -7, -3, -1,
236, 221, -1, 190, 235, -3, -1, 205, 220, -1, 174, 234, -15, -7, -3,
-1, 189, 219, -1, 204, 158, -3, -1, 233, 173, -1, 218, 188, -7, -3,
-1, 203, 142, -1, 232, 157, -3, -1, 217, 126, -1, 231, 172, 255,-235,
-143, -77, -45, -25, -15, -7, -3, -1, 202, 187, -1, 141, 216, -5, -3,
-1, 14, 224, 13, 230, -5, -3, -1, 110, 156, 201, -1, 94, 186, -9,
-5, -1, 229, -1, 171, 125, -1, 215, 228, -3, -1, 140, 200, -3, -1,
78, 46, 62, -15, -7, -3, -1, 109, 214, -1, 227, 155, -3, -1, 185,
170, -1, 226, 30, -7, -3, -1, 225, 93, -1, 213, 124, -3, -1, 199,
77, -1, 139, 184, -31, -15, -7, -3, -1, 212, 154, -1, 169, 108, -3,
-1, 198, 61, -1, 211, 45, -7, -3, -1, 210, 29, -1, 123, 183, -3,
-1, 209, 92, -1, 197, 138, -17, -7, -3, -1, 168, 153, -1, 76, 196,
-3, -1, 107, 182, -3, -1, 208, 12, 60, -7, -3, -1, 195, 122, -1,
167, 44, -3, -1, 194, 91, -1, 181, 28, -57, -35, -19, -7, -3, -1,
137, 152, -1, 193, 75, -5, -3, -1, 192, 11, 59, -3, -1, 176, 10,
26, -5, -1, 180, -1, 106, 166, -3, -1, 121, 151, -3, -1, 160, 9,
144, -9, -3, -1, 179, 136, -3, -1, 43, 90, 178, -7, -3, -1, 165,
27, -1, 177, 105, -1, 150, 164, -17, -9, -5, -3, -1, 74, 120, 135,
-1, 58, 163, -3, -1, 89, 149, -1, 42, 162, -7, -3, -1, 161, 104,
-1, 134, 119, -3, -1, 73, 148, -1, 57, 147, -63, -31, -15, -7, -3,
-1, 88, 133, -1, 41, 103, -3, -1, 118, 146, -1, 25, 145, -7, -3,
-1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 40, -17, -7,
-3, -1, 130, 24, -1, 71, 116, -5, -1, 129, -1, 8, 128, -1, 86,
101, -7, -5, -1, 23, -1, 7, 112, 115, -3, -1, 55, 39, 114, -15,
-7, -3, -1, 70, 100, -1, 85, 113, -3, -1, 54, 99, -1, 69, 84,
-7, -3, -1, 38, 98, -1, 22, 97, -5, -3, -1, 6, 96, 53, -1,
83, 68, -51, -37, -23, -15, -9, -3, -1, 37, 82, -1, 21, -1, 5,
80, -1, 81, -1, 52, 67, -3, -1, 36, 66, -1, 51, 20, -9, -5,
-1, 65, -1, 4, 64, -1, 35, 50, -1, 19, 49, -7, -5, -3, -1,
3, 48, 34, 18, -1, 33, -1, 2, 32, -3, -1, 17, 1, -1, 16,
0
};
 
static short tab_c0[] =
{
-29, -21, -13, -7, -3, -1, 11, 15, -1, 13, 14, -3, -1, 7, 5,
9, -3, -1, 6, 3, -1, 10, 12, -3, -1, 2, 1, -1, 4, 8,
0
};
 
static short tab_c1[] =
{
-15, -7, -3, -1, 15, 14, -1, 13, 12, -3, -1, 11, 10, -1, 9,
8, -7, -3, -1, 7, 6, -1, 5, 4, -3, -1, 3, 2, -1, 1,
0
};
 
 
 
static struct newhuff ht[] =
{
{ /* 0 */ 0 , tab0 } ,
{ /* 2 */ 0 , tab1 } ,
{ /* 3 */ 0 , tab2 } ,
{ /* 3 */ 0 , tab3 } ,
{ /* 0 */ 0 , tab0 } ,
{ /* 4 */ 0 , tab5 } ,
{ /* 4 */ 0 , tab6 } ,
{ /* 6 */ 0 , tab7 } ,
{ /* 6 */ 0 , tab8 } ,
{ /* 6 */ 0 , tab9 } ,
{ /* 8 */ 0 , tab10 } ,
{ /* 8 */ 0 , tab11 } ,
{ /* 8 */ 0 , tab12 } ,
{ /* 16 */ 0 , tab13 } ,
{ /* 0 */ 0 , tab0 } ,
{ /* 16 */ 0 , tab15 } ,
 
{ /* 16 */ 1 , tab16 } ,
{ /* 16 */ 2 , tab16 } ,
{ /* 16 */ 3 , tab16 } ,
{ /* 16 */ 4 , tab16 } ,
{ /* 16 */ 6 , tab16 } ,
{ /* 16 */ 8 , tab16 } ,
{ /* 16 */ 10, tab16 } ,
{ /* 16 */ 13, tab16 } ,
{ /* 16 */ 4 , tab24 } ,
{ /* 16 */ 5 , tab24 } ,
{ /* 16 */ 6 , tab24 } ,
{ /* 16 */ 7 , tab24 } ,
{ /* 16 */ 8 , tab24 } ,
{ /* 16 */ 9 , tab24 } ,
{ /* 16 */ 11, tab24 } ,
{ /* 16 */ 13, tab24 }
};
 
static struct newhuff htc[] =
{
{ /* 1 , 1 , */ 0 , tab_c0 } ,
{ /* 1 , 1 , */ 0 , tab_c1 }
};
 
 
#endif
/programs/media/ac97snd/mpg/l2tables.h
0,0 → 1,164
/*
l2tables.h: Layer 2 Alloc tables
 
copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
most other tables are calculated on program start (which is (of course) not ISO-conform)
Layer-3 huffman table is in huffman.h
*/
 
 
#ifndef _MPG123_L2TABLES_H_
#define _MPG123_L2TABLES_H_
 
struct al_table alloc_0[] = {
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767} };
 
struct al_table alloc_1[] = {
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511},
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767},
{2,0},{5,3},{7,5},{16,-32767} };
 
struct al_table alloc_2[] = {
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} };
 
struct al_table alloc_3[] = {
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} };
 
struct al_table alloc_4[] = {
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9},
{2,0},{5,3},{7,5},{10,9} };
 
#endif
 
/programs/media/ac97snd/mpg/layer1.c
0,0 → 1,151
/*
layer1.c: the layer 1 decoder
 
copyright 1995-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
may have a few bugs after last optimization ...
*/
 
#include "mpg123.h"
 
void I_step_one(unsigned int balloc[], unsigned int scale_index[2][SBLIMIT],struct frame *fr)
{
unsigned int *ba=balloc;
unsigned int *sca = (unsigned int *) scale_index;
 
if(fr->stereo == 2) {
int i;
int jsbound = fr->jsbound;
for (i=0;i<jsbound;i++) {
*ba++ = getbits(4);
*ba++ = getbits(4);
}
for (i=jsbound;i<SBLIMIT;i++)
*ba++ = getbits(4);
 
ba = balloc;
 
for (i=0;i<jsbound;i++) {
if ((*ba++))
*sca++ = getbits(6);
if ((*ba++))
*sca++ = getbits(6);
}
for (i=jsbound;i<SBLIMIT;i++)
if ((*ba++)) {
*sca++ = getbits(6);
*sca++ = getbits(6);
}
}
else {
int i;
for (i=0;i<SBLIMIT;i++)
*ba++ = getbits(4);
ba = balloc;
for (i=0;i<SBLIMIT;i++)
if ((*ba++))
*sca++ = getbits(6);
}
}
 
void I_step_two(real fraction[2][SBLIMIT],unsigned int balloc[2*SBLIMIT],
unsigned int scale_index[2][SBLIMIT],struct frame *fr)
{
int i,n;
int smpb[2*SBLIMIT]; /* values: 0-65535 */
int *sample;
register unsigned int *ba;
register unsigned int *sca = (unsigned int *) scale_index;
 
if(fr->stereo == 2) {
int jsbound = fr->jsbound;
register real *f0 = fraction[0];
register real *f1 = fraction[1];
ba = balloc;
for (sample=smpb,i=0;i<jsbound;i++) {
if ((n = *ba++))
*sample++ = getbits(n+1);
if ((n = *ba++))
*sample++ = getbits(n+1);
}
for (i=jsbound;i<SBLIMIT;i++)
if ((n = *ba++))
*sample++ = getbits(n+1);
 
ba = balloc;
for (sample=smpb,i=0;i<jsbound;i++) {
if((n=*ba++))
*f0++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++];
else
*f0++ = 0.0;
if((n=*ba++))
*f1++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++];
else
*f1++ = 0.0;
}
for (i=jsbound;i<SBLIMIT;i++) {
if ((n=*ba++)) {
real samp = ( ((-1)<<n) + (*sample++) + 1);
*f0++ = samp * muls[n+1][*sca++];
*f1++ = samp * muls[n+1][*sca++];
}
else
*f0++ = *f1++ = 0.0;
}
for(i=fr->down_sample_sblimit;i<32;i++)
fraction[0][i] = fraction[1][i] = 0.0;
}
else {
register real *f0 = fraction[0];
ba = balloc;
for (sample=smpb,i=0;i<SBLIMIT;i++)
if ((n = *ba++))
*sample++ = getbits(n+1);
ba = balloc;
for (sample=smpb,i=0;i<SBLIMIT;i++) {
if((n=*ba++))
*f0++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++];
else
*f0++ = 0.0;
}
for(i=fr->down_sample_sblimit;i<32;i++)
fraction[0][i] = 0.0;
}
}
 
int do_layer1(struct frame *fr,byte *pcm_sample, int *pcm_point)
{
int clip=0;
int i,stereo = fr->stereo;
unsigned int balloc[2*SBLIMIT];
unsigned int scale_index[2][SBLIMIT];
real fraction[2][SBLIMIT];
int single = fr->single;
 
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? (fr->mode_ext<<2)+4 : 32;
 
if(stereo == 1 || single == 3)
single = 0;
 
I_step_one(balloc,scale_index,fr);
 
for (i=0;i<SCALE_BLOCK;i++)
{
I_step_two(fraction,balloc,scale_index,fr);
 
if(single >= 0)
{
clip += (fr->synth_mono)( (real *) fraction[single],pcm_sample,pcm_point);
}
else {
int p1=*pcm_point;
clip += (fr->synth)( (real *) fraction[0],0,pcm_sample,&p1);
clip += (fr->synth)( (real *) fraction[1],1,pcm_sample,pcm_point);
}
}
return clip;
}
 
 
/programs/media/ac97snd/mpg/layer2.c
0,0 → 1,306
/*
layer2.c: the layer 2 decoder, root of mpg123
 
copyright 1994-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
mpg123 started as mp2 decoder a long time ago...
*/
 
#include "mpg123.h"
#include "l2tables.h"
 
static int grp_3tab[32 * 3] = { 0, }; /* used: 27 */
static int grp_5tab[128 * 3] = { 0, }; /* used: 125 */
static int grp_9tab[1024 * 3] = { 0, }; /* used: 729 */
 
real muls[27][64]; /* also used by layer 1 */
 
void init_layer2(void)
{
static double mulmul[27] = {
0.0 , -2.0/3.0 , 2.0/3.0 ,
2.0/7.0 , 2.0/15.0 , 2.0/31.0, 2.0/63.0 , 2.0/127.0 , 2.0/255.0 ,
2.0/511.0 , 2.0/1023.0 , 2.0/2047.0 , 2.0/4095.0 , 2.0/8191.0 ,
2.0/16383.0 , 2.0/32767.0 , 2.0/65535.0 ,
-4.0/5.0 , -2.0/5.0 , 2.0/5.0, 4.0/5.0 ,
-8.0/9.0 , -4.0/9.0 , -2.0/9.0 , 2.0/9.0 , 4.0/9.0 , 8.0/9.0 };
static int base[3][9] = {
{ 1 , 0, 2 , } ,
{ 17, 18, 0 , 19, 20 , } ,
{ 21, 1, 22, 23, 0, 24, 25, 2, 26 } };
int i,j,k,l,len;
real *table;
static int tablen[3] = { 3 , 5 , 9 };
static int *itable,*tables[3] = { grp_3tab , grp_5tab , grp_9tab };
 
for(i=0;i<3;i++)
{
itable = tables[i];
len = tablen[i];
for(j=0;j<len;j++)
for(k=0;k<len;k++)
for(l=0;l<len;l++)
{
*itable++ = base[i][l];
*itable++ = base[i][k];
*itable++ = base[i][j];
}
}
 
for(k=0;k<27;k++)
{
double m=mulmul[k];
table = muls[k];
#ifdef USE_MMX
if(!param.down_sample)
for(j=3,i=0;i<63;i++,j--)
*table++ = 16384 * m * pow(2.0,(double) j / 3.0);
else
#endif
for(j=3,i=0;i<63;i++,j--)
*table++ = m * pow_test(2.0,(double) j / 3.0);
*table++ = 0.0;
}
}
 
 
void II_step_one(unsigned int *bit_alloc,int *scale,struct frame *fr)
{
int stereo = fr->stereo-1;
int sblimit = fr->II_sblimit;
int jsbound = fr->jsbound;
int sblimit2 = fr->II_sblimit<<stereo;
struct al_table *alloc1 = fr->alloc;
int i;
static unsigned int scfsi_buf[64];
unsigned int *scfsi,*bita;
int sc,step;
 
bita = bit_alloc;
if(stereo)
{
for (i=jsbound;i;i--,alloc1+=(1<<step))
{
*bita++ = (char) getbits(step=alloc1->bits);
*bita++ = (char) getbits(step);
}
for (i=sblimit-jsbound;i;i--,alloc1+=(1<<step))
{
bita[0] = (char) getbits(step=alloc1->bits);
bita[1] = bita[0];
bita+=2;
}
bita = bit_alloc;
scfsi=scfsi_buf;
for (i=sblimit2;i;i--)
if (*bita++)
*scfsi++ = (char) getbits_fast(2);
}
else /* mono */
{
for (i=sblimit;i;i--,alloc1+=(1<<step))
*bita++ = (char) getbits(step=alloc1->bits);
bita = bit_alloc;
scfsi=scfsi_buf;
for (i=sblimit;i;i--)
if (*bita++)
*scfsi++ = (char) getbits_fast(2);
}
 
bita = bit_alloc;
scfsi=scfsi_buf;
for (i=sblimit2;i;i--)
if (*bita++)
switch (*scfsi++)
{
case 0:
*scale++ = getbits_fast(6);
*scale++ = getbits_fast(6);
*scale++ = getbits_fast(6);
break;
case 1 :
*scale++ = sc = getbits_fast(6);
*scale++ = sc;
*scale++ = getbits_fast(6);
break;
case 2:
*scale++ = sc = getbits_fast(6);
*scale++ = sc;
*scale++ = sc;
break;
default: /* case 3 */
*scale++ = getbits_fast(6);
*scale++ = sc = getbits_fast(6);
*scale++ = sc;
break;
}
 
}
 
void II_step_two(unsigned int *bit_alloc,real fraction[2][4][SBLIMIT],int *scale,struct frame *fr,int x1)
{
int i,j,k,ba;
int stereo = fr->stereo;
int sblimit = fr->II_sblimit;
int jsbound = fr->jsbound;
struct al_table *alloc2,*alloc1 = fr->alloc;
unsigned int *bita=bit_alloc;
int d1,step;
 
for (i=0;i<jsbound;i++,alloc1+=(1<<step))
{
step = alloc1->bits;
for (j=0;j<stereo;j++)
{
if ( (ba=*bita++) )
{
k=(alloc2 = alloc1+ba)->bits;
if( (d1=alloc2->d) < 0)
{
real cm=muls[k][scale[x1]];
fraction[j][0][i] = ((real) ((int)getbits(k) + d1)) * cm;
fraction[j][1][i] = ((real) ((int)getbits(k) + d1)) * cm;
fraction[j][2][i] = ((real) ((int)getbits(k) + d1)) * cm;
}
else
{
static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
unsigned int idx,*tab,m=scale[x1];
idx = (unsigned int) getbits(k);
tab = (unsigned int *) (table[d1] + idx + idx + idx);
fraction[j][0][i] = muls[*tab++][m];
fraction[j][1][i] = muls[*tab++][m];
fraction[j][2][i] = muls[*tab][m];
}
scale+=3;
}
else
fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
}
}
 
for (i=jsbound;i<sblimit;i++,alloc1+=(1<<step))
{
step = alloc1->bits;
bita++; /* channel 1 and channel 2 bitalloc are the same */
if ( (ba=*bita++) )
{
k=(alloc2 = alloc1+ba)->bits;
if( (d1=alloc2->d) < 0)
{
real cm;
cm=muls[k][scale[x1+3]];
fraction[1][0][i] = (fraction[0][0][i] = (real) ((int)getbits(k) + d1) ) * cm;
fraction[1][1][i] = (fraction[0][1][i] = (real) ((int)getbits(k) + d1) ) * cm;
fraction[1][2][i] = (fraction[0][2][i] = (real) ((int)getbits(k) + d1) ) * cm;
cm=muls[k][scale[x1]];
fraction[0][0][i] *= cm; fraction[0][1][i] *= cm; fraction[0][2][i] *= cm;
}
else
{
static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
unsigned int idx,*tab,m1,m2;
m1 = scale[x1]; m2 = scale[x1+3];
idx = (unsigned int) getbits(k);
tab = (unsigned int *) (table[d1] + idx + idx + idx);
fraction[0][0][i] = muls[*tab][m1]; fraction[1][0][i] = muls[*tab++][m2];
fraction[0][1][i] = muls[*tab][m1]; fraction[1][1][i] = muls[*tab++][m2];
fraction[0][2][i] = muls[*tab][m1]; fraction[1][2][i] = muls[*tab][m2];
}
scale+=6;
}
else {
fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] =
fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0;
}
/*
should we use individual scalefac for channel 2 or
is the current way the right one , where we just copy channel 1 to
channel 2 ??
The current 'strange' thing is, that we throw away the scalefac
values for the second channel ...!!
-> changed .. now we use the scalefac values of channel one !!
*/
}
 
if(sblimit > (fr->down_sample_sblimit) )
sblimit = fr->down_sample_sblimit;
 
for(i=sblimit;i<SBLIMIT;i++)
for (j=0;j<stereo;j++)
fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
 
}
 
static void II_select_table(struct frame *fr)
{
static int translate[3][2][16] =
{ { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } ,
{ 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } ,
{ { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } ,
{ 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } ,
{ { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } ,
{ 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } };
 
int table,sblim;
static struct al_table *tables[5] =
{ alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 };
static int sblims[5] = { 27 , 30 , 8, 12 , 30 };
 
if(fr->sampling_frequency >= 3) /* Or equivalent: (fr->lsf == 1) */
table = 4;
else
table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index];
sblim = sblims[table];
 
fr->alloc = tables[table];
fr->II_sblimit = sblim;
}
 
 
int do_layer2(struct frame *fr,byte *pcm_sample,int *pcm_point)
{
int clip=0;
int i,j;
int stereo = fr->stereo;
real fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */
unsigned int bit_alloc[64];
int scale[192];
int single = fr->single;
 
II_select_table(fr);
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
(fr->mode_ext<<2)+4 : fr->II_sblimit;
 
if (fr->jsbound > fr->II_sblimit) {
fr->jsbound=fr->II_sblimit;
}
if(stereo == 1 || single == 3)
single = 0;
 
II_step_one(bit_alloc, scale, fr);
 
for (i=0;i<SCALE_BLOCK;i++)
{
II_step_two(bit_alloc,fraction,scale,fr,i>>2);
for (j=0;j<3;j++)
{
if(single >= 0)
{
clip += (fr->synth_mono) (fraction[single][j],pcm_sample,pcm_point);
}
else {
int p1=*pcm_point;
clip += (fr->synth) (fraction[0][j],0,pcm_sample, &p1);
clip += (fr->synth) (fraction[1][j],1,pcm_sample,pcm_point);
}
}
}
 
return clip;
}
 
 
/programs/media/ac97snd/mpg/layer3.c
0,0 → 1,1961
/*
leyer3.c: the layer 3 decoder
 
copyright 1995-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
Optimize-TODO: put short bands into the band-field without the stride of 3 reals
Length-optimze: unify long and short band code where it is possible
 
The int-vs-pointer situation has to be cleaned up.
*/
 
//#include <stdlib.h>
//#include "config.h"
#include "mpg123.h"
#include "huffman.h"
 
//#include "common.h"
//#include "debug.h"
 
#include "getbits.h"
 
static real ispow[8207];
static real aa_ca[8],aa_cs[8];
static real COS1[12][6];
static real win[4][36];
static real win1[4][36];
static real gainpow2[256+118+4];
#ifdef USE_3DNOW
real COS9[9];
static real COS6_1,COS6_2;
real tfcos36[9];
#else
static real COS9[9];
static real COS6_1,COS6_2;
static real tfcos36[9];
#endif
static real tfcos12[3];
#define NEW_DCT9
#ifdef NEW_DCT9
static real cos9[3],cos18[3];
#endif
 
struct bandInfoStruct {
int longIdx[23];
int longDiff[22];
int shortIdx[14];
int shortDiff[13];
};
 
int longLimit[9][23];
int shortLimit[9][14];
 
struct bandInfoStruct bandInfo[9] = {
 
/* MPEG 1.0 */
{ {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
{4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
{0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},
{4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
 
{ {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
{4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
{0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},
{4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
 
{ {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
{4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
{0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,
{4,4,4,4,6,8,12,16,20,26,34,42,12} } ,
 
/* MPEG 2.0 */
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
{0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,
{4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
 
/* mhipp trunk has 330 -> 332 without further explanation ... */
{ {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
{6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } ,
{0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,
{4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
 
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
{0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},
{4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
/* MPEG 2.5 */
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
{0,12,24,36,54,78,108,144,186,240,312,402,522,576},
{4,4,4,6,8,10,12,14,18,24,30,40,18} },
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
{0,12,24,36,54,78,108,144,186,240,312,402,522,576},
{4,4,4,6,8,10,12,14,18,24,30,40,18} },
{ {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
{12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
{0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
{8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
};
 
static int mapbuf0[9][152];
static int mapbuf1[9][156];
static int mapbuf2[9][44];
static int *map[9][3];
static int *mapend[9][3];
 
static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
 
static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
 
#ifdef GAPLESS
/* still a dirty hack, places in bytes (zero-based)... */
static unsigned long position; /* position in raw decoder bytestream */
static unsigned long begin; /* first byte to play == number to skip */
static unsigned long end; /* last byte to play */
static unsigned long ignore; /* forcedly ignore stuff in between */
static int bytified;
 
/* input in bytes already */
void layer3_gapless_init(unsigned long b, unsigned long e)
{
bytified = 0;
position = 0;
ignore = 0;
begin = b;
end = e;
debug2("layer3_gapless_init: from %lu to %lu samples", begin, end);
}
 
void layer3_gapless_set_position(unsigned long frames, struct frame* fr, struct audio_info_struct *ai)
{
position = samples_to_bytes(frames*spf(fr), fr, ai);
debug1("set; position now %lu", position);
}
 
void layer3_gapless_bytify(struct frame *fr, struct audio_info_struct *ai)
{
if(!bytified)
{
begin = samples_to_bytes(begin, fr, ai);
end = samples_to_bytes(end, fr, ai);
bytified = 1;
debug2("bytified: begin=%lu; end=%5lu", begin, end);
}
}
 
/* I need initialized fr here! */
void layer3_gapless_set_ignore(unsigned long frames, struct frame *fr, struct audio_info_struct *ai)
{
ignore = samples_to_bytes(frames*spf(fr), fr, ai);
}
 
/*
take the (partially or fully) filled and remove stuff for gapless mode if needed
pcm_point may then be smaller than before...
*/
void layer3_gapless_buffercheck()
{
/* pcm_point bytes added since last position... */
unsigned long new_pos = position + pcm_point;
if(begin && (position < begin))
{
debug4("new_pos %lu (old: %lu), begin %lu, pcm_point %i", new_pos, position, begin, pcm_point);
if(new_pos < begin)
{
if(ignore > pcm_point) ignore -= pcm_point;
else ignore = 0;
pcm_point = 0; /* full of padding/delay */
}
else
{
unsigned long ignored = begin-position;
/* we need to shift the memory to the left... */
debug3("old pcm_point: %i, begin %lu; good bytes: %i", pcm_point, begin, (int)(new_pos-begin));
if(ignore > ignored) ignore -= ignored;
else ignore = 0;
pcm_point -= ignored;
debug3("shifting %i bytes from %p to %p", pcm_point, pcm_sample+(int)(begin-position), pcm_sample);
memmove(pcm_sample, pcm_sample+(int)(begin-position), pcm_point);
}
}
/* I don't cover the case with both end and begin in chunk! */
else if(end && (new_pos > end))
{
ignore = 0;
/* either end in current chunk or chunk totally out */
debug2("ending at position %lu / point %i", new_pos, pcm_point);
if(position < end) pcm_point -= new_pos-end;
else pcm_point = 0;
debug1("set pcm_point to %i", pcm_point);
}
else if(ignore)
{
if(pcm_point < ignore)
{
ignore -= pcm_point;
debug2("ignored %i bytes; pcm_point = 0; %lu bytes left", pcm_point, ignore);
pcm_point = 0;
}
else
{
/* we need to shift the memory to the left... */
debug3("old pcm_point: %i, to ignore: %lu; good bytes: %i", pcm_point, ignore, pcm_point-(int)ignore);
pcm_point -= ignore;
debug3("shifting %i bytes from %p to %p", pcm_point, pcm_sample+ignore, pcm_sample);
memmove(pcm_sample, pcm_sample+ignore, pcm_point);
ignore = 0;
}
}
position = new_pos;
}
#endif
 
/*
* init tables for layer-3
*/
 
real hybridIn [2][SBLIMIT][SSLIMIT];
real hybridOut[2][SSLIMIT][SBLIMIT];
static real block[2][2][SBLIMIT*SSLIMIT] = { { { 0, } } };
static int blc[2]={0,0};
 
void reset_mpg()
{
memset(block,0,sizeof(block));
blc[0]=0;
blc[1]=0;
init_dct();
};
 
 
#pragma warning(disable:4244)
void init_layer3(int down_sample_sblimit)
{
int i,j,k,l;
 
for(i=-256;i<118+4;i++)
#ifdef USE_MMX
if(!param.down_sample)
gainpow2[i+256] = 16384.0 * pow((double)2.0,-0.25 * (double) (i+210) );
else
#endif
gainpow2[i+256] = DOUBLE_TO_REAL(pow_test((double)2.0,-0.25 * (double) (i+210)));
 
for(i=0;i<8207;i++)
ispow[i] = DOUBLE_TO_REAL(pow_test((double)i,(double)4.0/3.0));
 
for (i=0;i<8;i++) {
static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
double sq=sqrt(1.0+Ci[i]*Ci[i]);
aa_cs[i] = DOUBLE_TO_REAL(1.0/sq);
aa_ca[i] = DOUBLE_TO_REAL(Ci[i]/sq);
}
 
for(i=0;i<18;i++) {
win[0][i] = win[1][i] = DOUBLE_TO_REAL(0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 ));
win[0][i+18] = win[3][i+18] = DOUBLE_TO_REAL(0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ));
}
for(i=0;i<6;i++) {
win[1][i+18] = DOUBLE_TO_REAL(0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ));
win[3][i+12] = DOUBLE_TO_REAL(0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 ));
win[1][i+24] = DOUBLE_TO_REAL(0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 ));
win[1][i+30] = win[3][i] = DOUBLE_TO_REAL(0.0);
win[3][i+6 ] = DOUBLE_TO_REAL(0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 ));
}
 
for(i=0;i<9;i++)
COS9[i] = DOUBLE_TO_REAL(cos( M_PI / 18.0 * (double) i));
 
for(i=0;i<9;i++)
tfcos36[i] = DOUBLE_TO_REAL(0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 ));
for(i=0;i<3;i++)
tfcos12[i] = DOUBLE_TO_REAL(0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 ));
 
COS6_1 = DOUBLE_TO_REAL(cos( M_PI / 6.0 * (double) 1));
COS6_2 = DOUBLE_TO_REAL(cos( M_PI / 6.0 * (double) 2));
 
#ifdef NEW_DCT9
cos9[0] = DOUBLE_TO_REAL(cos(1.0*M_PI/9.0));
cos9[1] = DOUBLE_TO_REAL(cos(5.0*M_PI/9.0));
cos9[2] = DOUBLE_TO_REAL(cos(7.0*M_PI/9.0));
cos18[0] = DOUBLE_TO_REAL(cos(1.0*M_PI/18.0));
cos18[1] = DOUBLE_TO_REAL(cos(11.0*M_PI/18.0));
cos18[2] = DOUBLE_TO_REAL(cos(13.0*M_PI/18.0));
#endif
 
for(i=0;i<12;i++) {
win[2][i] = DOUBLE_TO_REAL(0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 ));
for(j=0;j<6;j++)
COS1[i][j] = DOUBLE_TO_REAL(cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) ));
}
 
for(j=0;j<4;j++) {
static int len[4] = { 36,36,12,36 };
for(i=0;i<len[j];i+=2)
win1[j][i] = + win[j][i];
for(i=1;i<len[j];i+=2)
win1[j][i] = - win[j][i];
}
 
for(i=0;i<16;i++) {
double t = tan( (double) i * M_PI / 12.0 );
tan1_1[i] = DOUBLE_TO_REAL(t / (1.0+t));
tan2_1[i] = DOUBLE_TO_REAL(1.0 / (1.0 + t));
tan1_2[i] = DOUBLE_TO_REAL(M_SQRT2 * t / (1.0+t));
tan2_2[i] = DOUBLE_TO_REAL(M_SQRT2 / (1.0 + t));
 
for(j=0;j<2;j++) {
double base = pow_test(2.0,-0.25*(j+1.0));
double p1=1.0,p2=1.0;
if(i > 0) {
if( i & 1 )
p1 = pow_test(base,(i+1.0)*0.5);
else
p2 = pow_test(base,i*0.5);
}
pow1_1[j][i] = DOUBLE_TO_REAL(p1);
pow2_1[j][i] = DOUBLE_TO_REAL(p2);
pow1_2[j][i] = DOUBLE_TO_REAL(M_SQRT2 * p1);
pow2_2[j][i] = DOUBLE_TO_REAL(M_SQRT2 * p2);
}
}
 
for(j=0;j<9;j++) {
struct bandInfoStruct *bi = &bandInfo[j];
int *mp;
int cb,lwin;
int *bdf;
 
mp = map[j][0] = mapbuf0[j];
bdf = bi->longDiff;
for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
*mp++ = (*bdf) >> 1;
*mp++ = i;
*mp++ = 3;
*mp++ = cb;
}
bdf = bi->shortDiff+3;
for(cb=3;cb<13;cb++) {
int l = (*bdf++) >> 1;
for(lwin=0;lwin<3;lwin++) {
*mp++ = l;
*mp++ = i + lwin;
*mp++ = lwin;
*mp++ = cb;
}
i += 6*l;
}
mapend[j][0] = mp;
 
mp = map[j][1] = mapbuf1[j];
bdf = bi->shortDiff+0;
for(i=0,cb=0;cb<13;cb++) {
int l = (*bdf++) >> 1;
for(lwin=0;lwin<3;lwin++) {
*mp++ = l;
*mp++ = i + lwin;
*mp++ = lwin;
*mp++ = cb;
}
i += 6*l;
}
mapend[j][1] = mp;
 
mp = map[j][2] = mapbuf2[j];
bdf = bi->longDiff;
for(cb = 0; cb < 22 ; cb++) {
*mp++ = (*bdf++) >> 1;
*mp++ = cb;
}
mapend[j][2] = mp;
 
}
 
for(j=0;j<9;j++) {
for(i=0;i<23;i++) {
longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
if(longLimit[j][i] > (down_sample_sblimit) )
longLimit[j][i] = down_sample_sblimit;
}
for(i=0;i<14;i++) {
shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
if(shortLimit[j][i] > (down_sample_sblimit) )
shortLimit[j][i] = down_sample_sblimit;
}
}
 
for(i=0;i<5;i++) {
for(j=0;j<6;j++) {
for(k=0;k<6;k++) {
int n = k + j * 6 + i * 36;
i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
}
}
}
for(i=0;i<4;i++) {
for(j=0;j<4;j++) {
for(k=0;k<4;k++) {
int n = k + j * 4 + i * 16;
i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
}
}
}
for(i=0;i<4;i++) {
for(j=0;j<3;j++) {
int n = j + i * 3;
i_slen2[n+244] = i|(j<<3) | (5<<12);
n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
}
}
 
for(i=0;i<5;i++) {
for(j=0;j<5;j++) {
for(k=0;k<4;k++) {
for(l=0;l<4;l++) {
int n = l + k * 4 + j * 16 + i * 80;
n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
}
}
}
}
for(i=0;i<5;i++) {
for(j=0;j<5;j++) {
for(k=0;k<4;k++) {
int n = k + j * 4 + i * 20;
n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
}
}
}
}
 
/*
* read additional side information (for MPEG 1 and MPEG 2)
*/
static int III_get_side_info(struct III_sideinfo *si,int stereo,
int ms_stereo,long sfreq,int single,int lsf)
{
int ch, gr;
int powdiff = (single == 3) ? 4 : 0;
 
static const int tabs[2][5] = { { 2,9,5,3,4 } , { 1,8,1,2,9 } };
const int *tab = tabs[lsf];
si->main_data_begin = getbits(tab[1]);
if (stereo == 1)
si->private_bits = getbits_fast(tab[2]);
else
si->private_bits = getbits_fast(tab[3]);
 
if(!lsf) {
for (ch=0; ch<stereo; ch++) {
si->ch[ch].gr[0].scfsi = -1;
si->ch[ch].gr[1].scfsi = getbits_fast(4);
}
}
 
for (gr=0; gr<tab[0]; gr++) {
for (ch=0; ch<stereo; ch++) {
register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
 
gr_info->part2_3_length = getbits(12);
gr_info->big_values = getbits(9);
if(gr_info->big_values > 288) {
gr_info->big_values = 288;
}
gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff;
if(ms_stereo)
gr_info->pow2gain += 2;
gr_info->scalefac_compress = getbits(tab[4]);
 
if(get1bit()) { /* window switch flag */
int i;
gr_info->block_type = getbits_fast(2);
gr_info->mixed_block_flag = get1bit();
gr_info->table_select[0] = getbits_fast(5);
gr_info->table_select[1] = getbits_fast(5);
/*
* table_select[2] not needed, because there is no region2,
* but to satisfy some verifications tools we set it either.
*/
gr_info->table_select[2] = 0;
for(i=0;i<3;i++)
gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3);
 
if(gr_info->block_type == 0) {
/* exit(1); */
return 1;
}
/* region_count/start parameters are implicit in this case. */
if(!lsf || gr_info->block_type == 2)
gr_info->region1start = 36>>1;
else {
/* check this again for 2.5 and sfreq=8 */
if(sfreq == 8)
gr_info->region1start = 108>>1;
else
gr_info->region1start = 54>>1;
}
gr_info->region2start = 576>>1;
}
else {
int i,r0c,r1c;
for (i=0; i<3; i++)
gr_info->table_select[i] = getbits_fast(5);
r0c = getbits_fast(4);
r1c = getbits_fast(3);
gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
gr_info->block_type = 0;
gr_info->mixed_block_flag = 0;
}
if(!lsf)
gr_info->preflag = get1bit();
gr_info->scalefac_scale = get1bit();
gr_info->count1table_select = get1bit();
}
}
return 0;
}
 
/*
* read scalefactors
*/
static int III_get_scale_factors_1(int *scf,struct gr_info_s *gr_info,int ch,int gr)
{
static const unsigned char slen[2][16] = {
{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
{0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
};
int numbits;
int num0 = slen[0][gr_info->scalefac_compress];
int num1 = slen[1][gr_info->scalefac_compress];
 
if (gr_info->block_type == 2) {
int i=18;
numbits = (num0 + num1) * 18;
 
if (gr_info->mixed_block_flag) {
for (i=8;i;i--)
*scf++ = getbits_fast(num0);
i = 9;
numbits -= num0; /* num0 * 17 + num1 * 18 */
}
 
for (;i;i--)
*scf++ = getbits_fast(num0);
for (i = 18; i; i--)
*scf++ = getbits_fast(num1);
*scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */
}
else {
int i;
int scfsi = gr_info->scfsi;
 
if(scfsi < 0) { /* scfsi < 0 => granule == 0 */
for(i=11;i;i--)
*scf++ = getbits_fast(num0);
for(i=10;i;i--)
*scf++ = getbits_fast(num1);
numbits = (num0 + num1) * 10 + num0;
*scf++ = 0;
}
else {
numbits = 0;
if(!(scfsi & 0x8)) {
for (i=0;i<6;i++)
*scf++ = getbits_fast(num0);
numbits += num0 * 6;
}
else {
scf += 6;
}
 
if(!(scfsi & 0x4)) {
for (i=0;i<5;i++)
*scf++ = getbits_fast(num0);
numbits += num0 * 5;
}
else {
scf += 5;
}
 
if(!(scfsi & 0x2)) {
for(i=0;i<5;i++)
*scf++ = getbits_fast(num1);
numbits += num1 * 5;
}
else {
scf += 5;
}
 
if(!(scfsi & 0x1)) {
for (i=0;i<5;i++)
*scf++ = getbits_fast(num1);
numbits += num1 * 5;
}
else {
scf += 5;
}
*scf++ = 0; /* no l[21] in original sources */
}
}
return numbits;
}
 
static int III_get_scale_factors_2(int *scf,struct gr_info_s *gr_info,int i_stereo)
{
unsigned char *pnt;
int i,j,n=0,numbits=0;
unsigned int slen;
 
static const unsigned char stab[3][6][4] = {
{ { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
{ 7, 7, 7,0 } , { 6, 6, 6,3 } , { 8, 8,5,0} } ,
{ { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
{12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
{ { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
{ 6,15,12,0 } , { 6,12, 9,6 } , { 6,18,9,0} } };
 
if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */
slen = i_slen2[gr_info->scalefac_compress>>1];
else
slen = n_slen2[gr_info->scalefac_compress];
 
gr_info->preflag = (slen>>15) & 0x1;
 
n = 0;
if( gr_info->block_type == 2 ) {
n++;
if(gr_info->mixed_block_flag)
n++;
}
 
pnt = stab[n][(slen>>12)&0x7];
 
for(i=0;i<4;i++) {
int num = slen & 0x7;
slen >>= 3;
if(num) {
for(j=0;j<(int)(pnt[i]);j++)
*scf++ = getbits_fast(num);
numbits += pnt[i] * num;
}
else {
for(j=0;j<(int)(pnt[i]);j++)
*scf++ = 0;
}
}
n = (n << 1) + 1;
for(i=0;i<n;i++)
*scf++ = 0;
 
return numbits;
}
 
static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
/*
* Dequantize samples (includes huffman decoding)
*/
/* 24 is enough because tab13 has max. a 19 bit huffvector */
#define BITSHIFT ((sizeof(long)-1)*8)
#define REFRESH_MASK \
while(num < BITSHIFT) { \
mask |= ((unsigned long)getbyte())<<(BITSHIFT-num); \
num += 8; \
part2remain -= 8; }
 
static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf,
struct gr_info_s *gr_info,int sfreq,int part2bits)
{
int shift = 1 + gr_info->scalefac_scale;
real *xrpnt = (real *) xr;
int l[3],l3;
int part2remain = gr_info->part2_3_length - part2bits;
int *me;
 
/* mhipp tree has this split up a bit... */
int num=getbitoffset();
long mask = (long) getbits(num)<<(BITSHIFT+8-num);
part2remain -= num;
 
{
int bv = gr_info->big_values;
int region1 = gr_info->region1start;
int region2 = gr_info->region2start;
if(region1 > region2)
{
return 1;
}
l3 = ((576>>1)-bv)>>1;
/*
* we may lose the 'odd' bit here !!
* check this later again
*/
if(bv <= region1) {
l[0] = bv; l[1] = 0; l[2] = 0;
}
else {
l[0] = region1;
if(bv <= region2) {
l[1] = bv - l[0]; l[2] = 0;
}
else {
l[1] = region2 - l[0]; l[2] = bv - region2;
}
}
}
if(gr_info->block_type == 2) {
/*
* decoding with short or mixed mode BandIndex table
*/
int i,max[4];
int step=0,lwin=3,cb=0;
register real v = 0.0;
register int *m,mc;
 
if(gr_info->mixed_block_flag) {
max[3] = -1;
max[0] = max[1] = max[2] = 2;
m = map[sfreq][0];
me = mapend[sfreq][0];
}
else {
max[0] = max[1] = max[2] = max[3] = -1;
/* max[3] not really needed in this case */
m = map[sfreq][1];
me = mapend[sfreq][1];
}
 
mc = 0;
for(i=0;i<2;i++) {
int lp = l[i];
struct newhuff *h = ht+gr_info->table_select[i];
for(;lp;lp--,mc--) {
register int x,y;
if( (!mc) ) {
mc = *m++;
xrpnt = ((real *) xr) + (*m++);
lwin = *m++;
cb = *m++;
if(lwin == 3) {
v = gr_info->pow2gain[(*scf++) << shift];
step = 1;
}
else {
v = gr_info->full_gain[lwin][(*scf++) << shift];
step = 3;
}
}
{
register short *val = h->table;
REFRESH_MASK;
while((y=*val++)<0) {
if (mask < 0)
val -= y;
num--;
mask <<= 1;
}
x = y >> 4;
y &= 0xf;
}
if(x == 15 && h->linbits) {
max[lwin] = cb;
REFRESH_MASK;
x += ((unsigned long) mask) >> (BITSHIFT+8-h->linbits);
num -= h->linbits+1;
mask <<= h->linbits;
if(mask < 0)
*xrpnt = REAL_MUL(-ispow[x], v);
else
*xrpnt = REAL_MUL(ispow[x], v);
mask <<= 1;
}
else if(x) {
max[lwin] = cb;
if(mask < 0)
*xrpnt = REAL_MUL(-ispow[x], v);
else
*xrpnt = REAL_MUL(ispow[x], v);
num--;
mask <<= 1;
}
else
*xrpnt = DOUBLE_TO_REAL(0.0);
xrpnt += step;
if(y == 15 && h->linbits) {
max[lwin] = cb;
REFRESH_MASK;
y += ((unsigned long) mask) >> (BITSHIFT+8-h->linbits);
num -= h->linbits+1;
mask <<= h->linbits;
if(mask < 0)
*xrpnt = REAL_MUL(-ispow[y], v);
else
*xrpnt = REAL_MUL(ispow[y], v);
mask <<= 1;
}
else if(y) {
max[lwin] = cb;
if(mask < 0)
*xrpnt = REAL_MUL(-ispow[y], v);
else
*xrpnt = REAL_MUL(ispow[y], v);
num--;
mask <<= 1;
}
else
*xrpnt = DOUBLE_TO_REAL(0.0);
xrpnt += step;
}
}
 
for(;l3 && (part2remain+num > 0);l3--) {
/* not mixing code and declarations to keep C89 happy */
struct newhuff* h;
register short* val;
register short a;
/* This is only a humble hack to prevent a special segfault. */
/* More insight into the real workings is still needed. */
/* especially why there are (valid?) files that make xrpnt exceed the array with 4 bytes without segfaulting, more seems to be really bad, though. */
#ifdef DEBUG
if(!(xrpnt < &xr[SBLIMIT][0]))
{
if(param.verbose) debug2("attempted soft xrpnt overflow (%p !< %p) ?", (void*) xrpnt, (void*) &xr[SBLIMIT][0]);
}
#endif
if(!(xrpnt < &xr[SBLIMIT][0]+5))
{
return 2;
}
h = htc+gr_info->count1table_select;
val = h->table;
 
REFRESH_MASK;
while((a=*val++)<0) {
if (mask < 0)
val -= a;
num--;
mask <<= 1;
}
if(part2remain+num <= 0) {
num -= part2remain+num;
break;
}
 
for(i=0;i<4;i++) {
if(!(i & 1)) {
if(!mc) {
mc = *m++;
xrpnt = ((real *) xr) + (*m++);
lwin = *m++;
cb = *m++;
if(lwin == 3) {
v = gr_info->pow2gain[(*scf++) << shift];
step = 1;
}
else {
v = gr_info->full_gain[lwin][(*scf++) << shift];
step = 3;
}
}
mc--;
}
if( (a & (0x8>>i)) ) {
max[lwin] = cb;
if(part2remain+num <= 0) {
break;
}
if(mask < 0)
*xrpnt = -v;
else
*xrpnt = v;
num--;
mask <<= 1;
}
else
*xrpnt = DOUBLE_TO_REAL(0.0);
xrpnt += step;
}
}
 
if(lwin < 3) { /* short band? */
while(1) {
for(;mc > 0;mc--) {
*xrpnt = DOUBLE_TO_REAL(0.0); xrpnt += 3; /* short band -> step=3 */
*xrpnt = DOUBLE_TO_REAL(0.0); xrpnt += 3;
}
if(m >= me)
break;
mc = *m++;
xrpnt = ((real *) xr) + *m++;
if(*m++ == 0)
break; /* optimize: field will be set to zero at the end of the function */
m++; /* cb */
}
}
 
gr_info->maxband[0] = max[0]+1;
gr_info->maxband[1] = max[1]+1;
gr_info->maxband[2] = max[2]+1;
gr_info->maxbandl = max[3]+1;
 
{
int rmax = max[0] > max[1] ? max[0] : max[1];
rmax = (rmax > max[2] ? rmax : max[2]) + 1;
gr_info->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];
}
 
}
else {
/*
* decoding with 'long' BandIndex table (block_type != 2)
*/
int *pretab = gr_info->preflag ? pretab1 : pretab2;
int i,max = -1;
int cb = 0;
int *m = map[sfreq][2];
register real v = 0.0;
int mc = 0;
 
/*
* long hash table values
*/
for(i=0;i<3;i++) {
int lp = l[i];
struct newhuff *h = ht+gr_info->table_select[i];
 
for(;lp;lp--,mc--) {
int x,y;
if(!mc) {
mc = *m++;
cb = *m++;
if(cb == 21)
v = 0.0;
else
v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
 
}
{
register short *val = h->table;
REFRESH_MASK;
while((y=*val++)<0) {
if (mask < 0)
val -= y;
num--;
mask <<= 1;
}
x = y >> 4;
y &= 0xf;
}
 
if (x == 15 && h->linbits) {
max = cb;
REFRESH_MASK;
x += ((unsigned long) mask) >> (BITSHIFT+8-h->linbits);
num -= h->linbits+1;
mask <<= h->linbits;
if(mask < 0)
*xrpnt++ = REAL_MUL(-ispow[x], v);
else
*xrpnt++ = REAL_MUL(ispow[x], v);
mask <<= 1;
}
else if(x) {
max = cb;
if(mask < 0)
*xrpnt++ = REAL_MUL(-ispow[x], v);
else
*xrpnt++ = REAL_MUL(ispow[x], v);
num--;
mask <<= 1;
}
else
*xrpnt++ = DOUBLE_TO_REAL(0.0);
 
if (y == 15 && h->linbits) {
max = cb;
REFRESH_MASK;
y += ((unsigned long) mask) >> (BITSHIFT+8-h->linbits);
num -= h->linbits+1;
mask <<= h->linbits;
if(mask < 0)
*xrpnt++ = REAL_MUL(-ispow[y], v);
else
*xrpnt++ = REAL_MUL(ispow[y], v);
mask <<= 1;
}
else if(y) {
max = cb;
if(mask < 0)
*xrpnt++ = REAL_MUL(-ispow[y], v);
else
*xrpnt++ = REAL_MUL(ispow[y], v);
num--;
mask <<= 1;
}
else
*xrpnt++ = DOUBLE_TO_REAL(0.0);
}
}
 
/*
* short (count1table) values
*/
for(;l3 && (part2remain+num > 0);l3--) {
struct newhuff *h = htc+gr_info->count1table_select;
register short *val = h->table,a;
 
REFRESH_MASK;
while((a=*val++)<0) {
if (mask < 0)
val -= a;
num--;
mask <<= 1;
}
if(part2remain+num <= 0) {
num -= part2remain+num;
break;
}
 
for(i=0;i<4;i++) {
if(!(i & 1)) {
if(!mc) {
mc = *m++;
cb = *m++;
if(cb == 21)
v = 0.0;
else
v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
}
mc--;
}
if ( (a & (0x8>>i)) ) {
max = cb;
if(part2remain+num <= 0) {
break;
}
if(mask < 0)
*xrpnt++ = -v;
else
*xrpnt++ = v;
num--;
mask <<= 1;
}
else
*xrpnt++ = DOUBLE_TO_REAL(0.0);
}
}
 
gr_info->maxbandl = max+1;
gr_info->maxb = longLimit[sfreq][gr_info->maxbandl];
}
 
part2remain += num;
backbits(num);
num = 0;
 
while(xrpnt < &xr[SBLIMIT][0])
*xrpnt++ = DOUBLE_TO_REAL(0.0);
 
while( part2remain > 16 ) {
getbits(16); /* Dismiss stuffing Bits */
part2remain -= 16;
}
if(part2remain > 0)
getbits(part2remain);
else if(part2remain < 0) {
return 1; /* -> error */
}
return 0;
}
 
/*
* III_stereo: calculate real channel values for Joint-I-Stereo-mode
*/
static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
struct gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf)
{
real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
struct bandInfoStruct *bi = &bandInfo[sfreq];
 
const real *tab1,*tab2;
 
#if 1
int tab;
/* TODO: optimize as static */
static const real *tabs[3][2][2] = {
{ { tan1_1,tan2_1 } , { tan1_2,tan2_2 } },
{ { pow1_1[0],pow2_1[0] } , { pow1_2[0],pow2_2[0] } } ,
{ { pow1_1[1],pow2_1[1] } , { pow1_2[1],pow2_2[1] } }
};
 
tab = lsf + (gr_info->scalefac_compress & lsf);
tab1 = tabs[tab][ms_stereo][0];
tab2 = tabs[tab][ms_stereo][1];
#else
if(lsf) {
int p = gr_info->scalefac_compress & 0x1;
if(ms_stereo) {
tab1 = pow1_2[p]; tab2 = pow2_2[p];
}
else {
tab1 = pow1_1[p]; tab2 = pow2_1[p];
}
}
else {
if(ms_stereo) {
tab1 = tan1_2; tab2 = tan2_2;
}
else {
tab1 = tan1_1; tab2 = tan2_1;
}
}
#endif
 
if (gr_info->block_type == 2) {
int lwin,do_l = 0;
if( gr_info->mixed_block_flag )
do_l = 1;
 
for (lwin=0;lwin<3;lwin++) { /* process each window */
/* get first band with zero values */
int is_p,sb,idx,sfb = gr_info->maxband[lwin]; /* sfb is minimal 3 for mixed mode */
if(sfb > 3)
do_l = 0;
 
for(;sfb<12;sfb++) {
is_p = scalefac[sfb*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
if(is_p != 7) {
real t1,t2;
sb = bi->shortDiff[sfb];
idx = bi->shortIdx[sfb] + lwin;
t1 = tab1[is_p]; t2 = tab2[is_p];
for (; sb > 0; sb--,idx+=3) {
real v = xr[0][idx];
xr[0][idx] = REAL_MUL(v, t1);
xr[1][idx] = REAL_MUL(v, t2);
}
}
}
 
#if 1
/* in the original: copy 10 to 11 , here: copy 11 to 12
maybe still wrong??? (copy 12 to 13?) */
is_p = scalefac[11*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
sb = bi->shortDiff[12];
idx = bi->shortIdx[12] + lwin;
#else
is_p = scalefac[10*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
sb = bi->shortDiff[11];
idx = bi->shortIdx[11] + lwin;
#endif
if(is_p != 7) {
real t1,t2;
t1 = tab1[is_p]; t2 = tab2[is_p];
for ( ; sb > 0; sb--,idx+=3 ) {
real v = xr[0][idx];
xr[0][idx] = REAL_MUL(v, t1);
xr[1][idx] = REAL_MUL(v, t2);
}
}
} /* end for(lwin; .. ; . ) */
 
/* also check l-part, if ALL bands in the three windows are 'empty'
* and mode = mixed_mode
*/
if (do_l) {
int sfb = gr_info->maxbandl;
int idx;
if(sfb > 21) return; /* similarity fix related to CVE-2006-1655 */
idx = bi->longIdx[sfb];
for ( ; sfb<8; sfb++ ) {
int sb = bi->longDiff[sfb];
int is_p = scalefac[sfb]; /* scale: 0-15 */
if(is_p != 7) {
real t1,t2;
t1 = tab1[is_p]; t2 = tab2[is_p];
for ( ; sb > 0; sb--,idx++) {
real v = xr[0][idx];
xr[0][idx] = REAL_MUL(v, t1);
xr[1][idx] = REAL_MUL(v, t2);
}
}
else
idx += sb;
}
}
}
else { /* ((gr_info->block_type != 2)) */
int sfb = gr_info->maxbandl;
int is_p,idx;
if(sfb > 21) return; /* tightened fix for CVE-2006-1655 */
idx = bi->longIdx[sfb];
for ( ; sfb<21; sfb++) {
int sb = bi->longDiff[sfb];
is_p = scalefac[sfb]; /* scale: 0-15 */
if(is_p != 7) {
real t1,t2;
t1 = tab1[is_p]; t2 = tab2[is_p];
for ( ; sb > 0; sb--,idx++) {
real v = xr[0][idx];
xr[0][idx] = REAL_MUL(v, t1);
xr[1][idx] = REAL_MUL(v, t2);
}
}
else
idx += sb;
}
 
is_p = scalefac[20];
if(is_p != 7) { /* copy l-band 20 to l-band 21 */
int sb;
real t1 = tab1[is_p],t2 = tab2[is_p];
 
for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ ) {
real v = xr[0][idx];
xr[0][idx] = REAL_MUL(v, t1);
xr[1][idx] = REAL_MUL(v, t2);
}
}
} /* ... */
}
 
static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_info) {
int sblim;
 
if(gr_info->block_type == 2) {
if(!gr_info->mixed_block_flag)
return;
sblim = 1;
}
else {
sblim = gr_info->maxb-1;
}
 
/* 31 alias-reduction operations between each pair of sub-bands */
/* with 8 butterflies between each pair */
 
{
int sb;
real *xr1=(real *) xr[1];
 
for(sb=sblim;sb;sb--,xr1+=10) {
int ss;
real *cs=aa_cs,*ca=aa_ca;
real *xr2 = xr1;
 
for(ss=7;ss>=0;ss--)
{ /* upper and lower butterfly inputs */
register real bu = *--xr2,bd = *xr1;
*xr2 = REAL_MUL(bu, *cs) - REAL_MUL(bd, *ca);
*xr1++ = REAL_MUL(bd, *cs++) + REAL_MUL(bu, *ca++);
}
}
}
}
 
/*
// This is an optimized DCT from Jeff Tsay's maplay 1.2+ package.
// Saved one multiplication by doing the 'twiddle factor' stuff
// together with the window mul. (MH)
//
// This uses Byeong Gi Lee's Fast Cosine Transform algorithm, but the
// 9 point IDCT needs to be reduced further. Unfortunately, I don't
// know how to do that, because 9 is not an even number. - Jeff.
//
//////////////////////////////////////////////////////////////////
//
// 9 Point Inverse Discrete Cosine Transform
//
// This piece of code is Copyright 1997 Mikko Tommila and is freely usable
// by anybody. The algorithm itself is of course in the public domain.
//
// Again derived heuristically from the 9-point WFTA.
//
// The algorithm is optimized (?) for speed, not for small rounding errors or
// good readability.
//
// 36 additions, 11 multiplications
//
// Again this is very likely sub-optimal.
//
// The code is optimized to use a minimum number of temporary variables,
// so it should compile quite well even on 8-register Intel x86 processors.
// This makes the code quite obfuscated and very difficult to understand.
//
// References:
// [1] S. Winograd: "On Computing the Discrete Fourier Transform",
// Mathematics of Computation, Volume 32, Number 141, January 1978,
// Pages 175-199
*/
 
/*------------------------------------------------------------------*/
/* */
/* Function: Calculation of the inverse MDCT */
/* */
/*------------------------------------------------------------------*/
#ifdef USE_3DNOW
void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
#else
static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
#endif
{
#ifdef NEW_DCT9
real tmp[18];
#endif
 
{
register real *in = inbuf;
 
in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
in[11]+=in[10]; in[10]+=in[9]; in[9] +=in[8];
in[8] +=in[7]; in[7] +=in[6]; in[6] +=in[5];
in[5] +=in[4]; in[4] +=in[3]; in[3] +=in[2];
in[2] +=in[1]; in[1] +=in[0];
 
in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
in[9] +=in[7]; in[7] +=in[5]; in[5] +=in[3]; in[3] +=in[1];
 
 
#ifdef NEW_DCT9
#if 1
{
real t3;
{
real t0, t1, t2;
 
t0 = REAL_MUL(COS6_2, (in[8] + in[16] - in[4]));
t1 = REAL_MUL(COS6_2, in[12]);
 
t3 = in[0];
t2 = t3 - t1 - t1;
tmp[1] = tmp[7] = t2 - t0;
tmp[4] = t2 + t0 + t0;
t3 += t1;
 
t2 = REAL_MUL(COS6_1, (in[10] + in[14] - in[2]));
tmp[1] -= t2;
tmp[7] += t2;
}
{
real t0, t1, t2;
 
t0 = REAL_MUL(cos9[0], (in[4] + in[8] ));
t1 = REAL_MUL(cos9[1], (in[8] - in[16]));
t2 = REAL_MUL(cos9[2], (in[4] + in[16]));
 
tmp[2] = tmp[6] = t3 - t0 - t2;
tmp[0] = tmp[8] = t3 + t0 + t1;
tmp[3] = tmp[5] = t3 - t1 + t2;
}
}
{
real t1, t2, t3;
 
t1 = REAL_MUL(cos18[0], (in[2] + in[10]));
t2 = REAL_MUL(cos18[1], (in[10] - in[14]));
t3 = REAL_MUL(COS6_1, in[6]);
 
{
real t0 = t1 + t2 + t3;
tmp[0] += t0;
tmp[8] -= t0;
}
 
t2 -= t3;
t1 -= t3;
 
t3 = REAL_MUL(cos18[2], (in[2] + in[14]));
 
t1 += t3;
tmp[3] += t1;
tmp[5] -= t1;
 
t2 -= t3;
tmp[2] += t2;
tmp[6] -= t2;
}
 
#else
{
real t0, t1, t2, t3, t4, t5, t6, t7;
 
t1 = REAL_MUL(COS6_2, in[12]);
t2 = REAL_MUL(COS6_2, (in[8] + in[16] - in[4]));
 
t3 = in[0] + t1;
t4 = in[0] - t1 - t1;
t5 = t4 - t2;
tmp[4] = t4 + t2 + t2;
 
t0 = REAL_MUL(cos9[0], (in[4] + in[8]));
t1 = REAL_MUL(cos9[1], (in[8] - in[16]));
 
t2 = REAL_MUL(cos9[2], (in[4] + in[16]));
 
t6 = t3 - t0 - t2;
t0 += t3 + t1;
t3 += t2 - t1;
 
t2 = REAL_MUL(cos18[0], (in[2] + in[10]));
t4 = REAL_MUL(cos18[1], (in[10] - in[14]));
t7 = REAL_MUL(COS6_1, in[6]);
 
t1 = t2 + t4 + t7;
tmp[0] = t0 + t1;
tmp[8] = t0 - t1;
t1 = REAL_MUL(cos18[2], (in[2] + in[14]));
t2 += t1 - t7;
 
tmp[3] = t3 + t2;
t0 = REAL_MUL(COS6_1, (in[10] + in[14] - in[2]));
tmp[5] = t3 - t2;
 
t4 -= t1 + t7;
 
tmp[1] = t5 - t0;
tmp[7] = t5 + t0;
tmp[2] = t6 + t4;
tmp[6] = t6 - t4;
}
#endif
 
{
real t0, t1, t2, t3, t4, t5, t6, t7;
 
t1 = REAL_MUL(COS6_2, in[13]);
t2 = REAL_MUL(COS6_2, (in[9] + in[17] - in[5]));
 
t3 = in[1] + t1;
t4 = in[1] - t1 - t1;
t5 = t4 - t2;
 
t0 = REAL_MUL(cos9[0], (in[5] + in[9]));
t1 = REAL_MUL(cos9[1], (in[9] - in[17]));
 
tmp[13] = REAL_MUL((t4 + t2 + t2), tfcos36[17-13]);
t2 = REAL_MUL(cos9[2], (in[5] + in[17]));
 
t6 = t3 - t0 - t2;
t0 += t3 + t1;
t3 += t2 - t1;
 
t2 = REAL_MUL(cos18[0], (in[3] + in[11]));
t4 = REAL_MUL(cos18[1], (in[11] - in[15]));
t7 = REAL_MUL(COS6_1, in[7]);
 
t1 = t2 + t4 + t7;
tmp[17] = REAL_MUL((t0 + t1), tfcos36[17-17]);
tmp[9] = REAL_MUL((t0 - t1), tfcos36[17-9]);
t1 = REAL_MUL(cos18[2], (in[3] + in[15]));
t2 += t1 - t7;
 
tmp[14] = REAL_MUL((t3 + t2), tfcos36[17-14]);
t0 = REAL_MUL(COS6_1, (in[11] + in[15] - in[3]));
tmp[12] = REAL_MUL((t3 - t2), tfcos36[17-12]);
 
t4 -= t1 + t7;
 
tmp[16] = REAL_MUL((t5 - t0), tfcos36[17-16]);
tmp[10] = REAL_MUL((t5 + t0), tfcos36[17-10]);
tmp[15] = REAL_MUL((t6 + t4), tfcos36[17-15]);
tmp[11] = REAL_MUL((t6 - t4), tfcos36[17-11]);
}
 
#define MACRO(v) { \
real tmpval; \
tmpval = tmp[(v)] + tmp[17-(v)]; \
out2[9+(v)] = REAL_MUL(tmpval, w[27+(v)]); \
out2[8-(v)] = REAL_MUL(tmpval, w[26-(v)]); \
tmpval = tmp[(v)] - tmp[17-(v)]; \
ts[SBLIMIT*(8-(v))] = out1[8-(v)] + REAL_MUL(tmpval, w[8-(v)]); \
ts[SBLIMIT*(9+(v))] = out1[9+(v)] + REAL_MUL(tmpval, w[9+(v)]); }
 
{
register real *out2 = o2;
register real *w = wintab;
register real *out1 = o1;
register real *ts = tsbuf;
 
MACRO(0);
MACRO(1);
MACRO(2);
MACRO(3);
MACRO(4);
MACRO(5);
MACRO(6);
MACRO(7);
MACRO(8);
}
 
#else
 
{
 
#define MACRO0(v) { \
real tmp; \
out2[9+(v)] = REAL_MUL((tmp = sum0 + sum1), w[27+(v)]); \
out2[8-(v)] = REAL_MUL(tmp, w[26-(v)]); } \
sum0 -= sum1; \
ts[SBLIMIT*(8-(v))] = out1[8-(v)] + REAL_MUL(sum0, w[8-(v)]); \
ts[SBLIMIT*(9+(v))] = out1[9+(v)] + REAL_MUL(sum0, w[9+(v)]);
#define MACRO1(v) { \
real sum0,sum1; \
sum0 = tmp1a + tmp2a; \
sum1 = REAL_MUL((tmp1b + tmp2b), tfcos36[(v)]); \
MACRO0(v); }
#define MACRO2(v) { \
real sum0,sum1; \
sum0 = tmp2a - tmp1a; \
sum1 = REAL_MUL((tmp2b - tmp1b), tfcos36[(v)]); \
MACRO0(v); }
 
register const real *c = COS9;
register real *out2 = o2;
register real *w = wintab;
register real *out1 = o1;
register real *ts = tsbuf;
 
real ta33,ta66,tb33,tb66;
 
ta33 = REAL_MUL(in[2*3+0], c[3]);
ta66 = REAL_MUL(in[2*6+0], c[6]);
tb33 = REAL_MUL(in[2*3+1], c[3]);
tb66 = REAL_MUL(in[2*6+1], c[6]);
 
{
real tmp1a,tmp2a,tmp1b,tmp2b;
tmp1a = REAL_MUL(in[2*1+0], c[1]) + ta33 + REAL_MUL(in[2*5+0], c[5]) + REAL_MUL(in[2*7+0], c[7]);
tmp1b = REAL_MUL(in[2*1+1], c[1]) + tb33 + REAL_MUL(in[2*5+1], c[5]) + REAL_MUL(in[2*7+1], c[7]);
tmp2a = REAL_MUL(in[2*2+0], c[2]) + REAL_MUL(in[2*4+0], c[4]) + ta66 + REAL_MUL(in[2*8+0], c[8]);
tmp2b = REAL_MUL(in[2*2+1], c[2]) + REAL_MUL(in[2*4+1], c[4]) + tb66 + REAL_MUL(in[2*8+1], c[8]);
 
MACRO1(0);
MACRO2(8);
}
 
{
real tmp1a,tmp2a,tmp1b,tmp2b;
tmp1a = REAL_MUL(( in[2*1+0] - in[2*5+0] - in[2*7+0] ), c[3]);
tmp1b = REAL_MUL(( in[2*1+1] - in[2*5+1] - in[2*7+1] ), c[3]);
tmp2a = REAL_MUL(( in[2*2+0] - in[2*4+0] - in[2*8+0] ), c[6]) - in[2*6+0] + in[2*0+0];
tmp2b = REAL_MUL(( in[2*2+1] - in[2*4+1] - in[2*8+1] ), c[6]) - in[2*6+1] + in[2*0+1];
 
MACRO1(1);
MACRO2(7);
}
 
{
real tmp1a,tmp2a,tmp1b,tmp2b;
tmp1a = REAL_MUL(in[2*1+0], c[5]) - ta33 - REAL_MUL(in[2*5+0], c[7]) + REAL_MUL(in[2*7+0], c[1]);
tmp1b = REAL_MUL(in[2*1+1], c[5]) - tb33 - REAL_MUL(in[2*5+1], c[7]) + REAL_MUL(in[2*7+1], c[1]);
tmp2a = - REAL_MUL(in[2*2+0], c[8]) - REAL_MUL(in[2*4+0], c[2]) + ta66 + REAL_MUL(in[2*8+0], c[4]);
tmp2b = - REAL_MUL(in[2*2+1], c[8]) - REAL_MUL(in[2*4+1], c[2]) + tb66 + REAL_MUL(in[2*8+1], c[4]);
 
MACRO1(2);
MACRO2(6);
}
 
{
real tmp1a,tmp2a,tmp1b,tmp2b;
tmp1a = REAL_MUL(in[2*1+0], c[7]) - ta33 + REAL_MUL(in[2*5+0], c[1]) - REAL_MUL(in[2*7+0], c[5]);
tmp1b = REAL_MUL(in[2*1+1], c[7]) - tb33 + REAL_MUL(in[2*5+1], c[1]) - REAL_MUL(in[2*7+1], c[5]);
tmp2a = - REAL_MUL(in[2*2+0], c[4]) + REAL_MUL(in[2*4+0], c[8]) + ta66 - REAL_MUL(in[2*8+0], c[2]);
tmp2b = - REAL_MUL(in[2*2+1], c[4]) + REAL_MUL(in[2*4+1], c[8]) + tb66 - REAL_MUL(in[2*8+1], c[2]);
 
MACRO1(3);
MACRO2(5);
}
 
{
real sum0,sum1;
sum0 = in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
sum1 = REAL_MUL((in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ), tfcos36[4]);
MACRO0(4);
}
}
#endif
 
}
}
 
/*
* new DCT12
*/
static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)
{
#define DCT12_PART1 \
in5 = in[5*3]; \
in5 += (in4 = in[4*3]); \
in4 += (in3 = in[3*3]); \
in3 += (in2 = in[2*3]); \
in2 += (in1 = in[1*3]); \
in1 += (in0 = in[0*3]); \
\
in5 += in3; in3 += in1; \
\
in2 = REAL_MUL(in2, COS6_1); \
in3 = REAL_MUL(in3, COS6_1); \
 
#define DCT12_PART2 \
in0 += REAL_MUL(in4, COS6_2); \
\
in4 = in0 + in2; \
in0 -= in2; \
\
in1 += REAL_MUL(in5, COS6_2); \
\
in5 = REAL_MUL((in1 + in3), tfcos12[0]); \
in1 = REAL_MUL((in1 - in3), tfcos12[2]); \
\
in3 = in4 + in5; \
in4 -= in5; \
\
in2 = in0 + in1; \
in0 -= in1;
 
 
{
real in0,in1,in2,in3,in4,in5;
register real *out1 = rawout1;
ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
DCT12_PART1
 
{
real tmp0,tmp1 = (in0 - in4);
{
real tmp2 = REAL_MUL((in1 - in5), tfcos12[1]);
tmp0 = tmp1 + tmp2;
tmp1 -= tmp2;
}
ts[(17-1)*SBLIMIT] = out1[17-1] + REAL_MUL(tmp0, wi[11-1]);
ts[(12+1)*SBLIMIT] = out1[12+1] + REAL_MUL(tmp0, wi[6+1]);
ts[(6 +1)*SBLIMIT] = out1[6 +1] + REAL_MUL(tmp1, wi[1]);
ts[(11-1)*SBLIMIT] = out1[11-1] + REAL_MUL(tmp1, wi[5-1]);
}
 
DCT12_PART2
 
ts[(17-0)*SBLIMIT] = out1[17-0] + REAL_MUL(in2, wi[11-0]);
ts[(12+0)*SBLIMIT] = out1[12+0] + REAL_MUL(in2, wi[6+0]);
ts[(12+2)*SBLIMIT] = out1[12+2] + REAL_MUL(in3, wi[6+2]);
ts[(17-2)*SBLIMIT] = out1[17-2] + REAL_MUL(in3, wi[11-2]);
 
ts[(6 +0)*SBLIMIT] = out1[6+0] + REAL_MUL(in0, wi[0]);
ts[(11-0)*SBLIMIT] = out1[11-0] + REAL_MUL(in0, wi[5-0]);
ts[(6 +2)*SBLIMIT] = out1[6+2] + REAL_MUL(in4, wi[2]);
ts[(11-2)*SBLIMIT] = out1[11-2] + REAL_MUL(in4, wi[5-2]);
}
 
in++;
 
{
real in0,in1,in2,in3,in4,in5;
register real *out2 = rawout2;
DCT12_PART1
 
{
real tmp0,tmp1 = (in0 - in4);
{
real tmp2 = REAL_MUL((in1 - in5), tfcos12[1]);
tmp0 = tmp1 + tmp2;
tmp1 -= tmp2;
}
out2[5-1] = REAL_MUL(tmp0, wi[11-1]);
out2[0+1] = REAL_MUL(tmp0, wi[6+1]);
ts[(12+1)*SBLIMIT] += REAL_MUL(tmp1, wi[1]);
ts[(17-1)*SBLIMIT] += REAL_MUL(tmp1, wi[5-1]);
}
 
DCT12_PART2
 
out2[5-0] = REAL_MUL(in2, wi[11-0]);
out2[0+0] = REAL_MUL(in2, wi[6+0]);
out2[0+2] = REAL_MUL(in3, wi[6+2]);
out2[5-2] = REAL_MUL(in3, wi[11-2]);
 
ts[(12+0)*SBLIMIT] += REAL_MUL(in0, wi[0]);
ts[(17-0)*SBLIMIT] += REAL_MUL(in0, wi[5-0]);
ts[(12+2)*SBLIMIT] += REAL_MUL(in4, wi[2]);
ts[(17-2)*SBLIMIT] += REAL_MUL(in4, wi[5-2]);
}
 
in++;
 
{
real in0,in1,in2,in3,in4,in5;
register real *out2 = rawout2;
out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
 
DCT12_PART1
 
{
real tmp0,tmp1 = (in0 - in4);
{
real tmp2 = REAL_MUL((in1 - in5), tfcos12[1]);
tmp0 = tmp1 + tmp2;
tmp1 -= tmp2;
}
out2[11-1] = REAL_MUL(tmp0, wi[11-1]);
out2[6 +1] = REAL_MUL(tmp0, wi[6+1]);
out2[0+1] += REAL_MUL(tmp1, wi[1]);
out2[5-1] += REAL_MUL(tmp1, wi[5-1]);
}
 
DCT12_PART2
 
out2[11-0] = REAL_MUL(in2, wi[11-0]);
out2[6 +0] = REAL_MUL(in2, wi[6+0]);
out2[6 +2] = REAL_MUL(in3, wi[6+2]);
out2[11-2] = REAL_MUL(in3, wi[11-2]);
 
out2[0+0] += REAL_MUL(in0, wi[0]);
out2[5-0] += REAL_MUL(in0, wi[5-0]);
out2[0+2] += REAL_MUL(in4, wi[2]);
out2[5-2] += REAL_MUL(in4, wi[5-2]);
}
}
 
/*
* III_hybrid
*/
#ifdef USE_3DNOW
static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],int ch,struct gr_info_s *gr_info,struct frame *fr)
#else
static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
int ch,struct gr_info_s *gr_info)
#endif
{
real *tspnt = (real *) tsOut;
real *rawout1,*rawout2;
int bt,sb = 0;
 
{
int b = blc[ch];
rawout1=block[b][ch];
b=-b+1;
rawout2=block[b][ch];
blc[ch] = b;
}
if(gr_info->mixed_block_flag) {
sb = 2;
#ifdef USE_3DNOW
(fr->dct36)(fsIn[0],rawout1,rawout2,win[0],tspnt);
(fr->dct36)(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
#else
dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
#endif
rawout1 += 36; rawout2 += 36; tspnt += 2;
}
bt = gr_info->block_type;
if(bt == 2) {
for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
dct12(fsIn[sb] ,rawout1 ,rawout2 ,win[2] ,tspnt);
dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
}
}
else {
for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
#ifdef USE_3DNOW
(fr->dct36)(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
(fr->dct36)(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
#else
dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
#endif
}
}
 
for(;sb<SBLIMIT;sb++,tspnt++) {
int i;
for(i=0;i<SSLIMIT;i++) {
tspnt[i*SBLIMIT] = *rawout1++;
*rawout2++ = DOUBLE_TO_REAL(0.0);
}
}
}
 
int do_layer3(struct frame *fr,byte *pcm_sample,int *pcm_point)
{
int gr, ch, ss,clip=0;
int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
struct III_sideinfo sideinfo;
int stereo = fr->stereo;
int single = fr->single;
int ms_stereo,i_stereo;
int sfreq = fr->sampling_frequency;
int stereo1,granules;
 
if(stereo == 1) { /* stream is mono */
stereo1 = 1;
single = 0;
}
else if(single >= 0) /* stream is stereo, but force to mono */
stereo1 = 1;
else
stereo1 = 2;
 
if(fr->mode == MPG_MD_JOINT_STEREO) {
ms_stereo = (fr->mode_ext & 0x2)>>1;
i_stereo = fr->mode_ext & 0x1;
}
else
ms_stereo = i_stereo = 0;
 
if(fr->lsf) {
granules = 1;
#if 0
III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single);
#endif
}
else {
granules = 2;
}
/* quick hack to keep the music playing */
/* after having seen this nasty test file... */
if(III_get_side_info(&sideinfo,stereo,ms_stereo,sfreq,single,fr->lsf))
{
return clip;
}
 
set_pointer(sideinfo.main_data_begin);
 
for (gr=0;gr<granules;gr++)
{
 
{
struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
long part2bits;
if(fr->lsf)
part2bits = III_get_scale_factors_2(scalefacs[0],gr_info,0);
else
part2bits = III_get_scale_factors_1(scalefacs[0],gr_info,0,gr);
 
if(III_dequantize_sample(hybridIn[0], scalefacs[0],gr_info,sfreq,part2bits))
return clip;
}
 
if(stereo == 2) {
struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
long part2bits;
if(fr->lsf)
part2bits = III_get_scale_factors_2(scalefacs[1],gr_info,i_stereo);
else
part2bits = III_get_scale_factors_1(scalefacs[1],gr_info,1,gr);
 
if(III_dequantize_sample(hybridIn[1],scalefacs[1],gr_info,sfreq,part2bits))
return clip;
 
if(ms_stereo) {
int i;
int maxb = sideinfo.ch[0].gr[gr].maxb;
if(sideinfo.ch[1].gr[gr].maxb > maxb)
maxb = sideinfo.ch[1].gr[gr].maxb;
for(i=0;i<SSLIMIT*maxb;i++) {
real tmp0 = ((real *)hybridIn[0])[i];
real tmp1 = ((real *)hybridIn[1])[i];
((real *)hybridIn[0])[i] = tmp0 + tmp1;
((real *)hybridIn[1])[i] = tmp0 - tmp1;
}
}
 
if(i_stereo)
III_i_stereo(hybridIn,scalefacs[1],gr_info,sfreq,ms_stereo,fr->lsf);
 
if(ms_stereo || i_stereo || (single == 3) ) {
if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb)
sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
else
gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
}
 
switch(single) {
case 3:
{
register int i;
register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
for(i=0;i<SSLIMIT*gr_info->maxb;i++,in0++)
*in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */
}
break;
case 1:
{
register int i;
register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
for(i=0;i<SSLIMIT*gr_info->maxb;i++)
*in0++ = *in1++;
}
break;
}
}
 
for(ch=0;ch<stereo1;ch++) {
struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
III_antialias(hybridIn[ch],gr_info);
#ifdef USE_3DNOW
III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_info,fr);
#else
III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_info);
#endif
}
 
#ifdef I486_OPT
if (fr->synth != synth_1to1 || single >= 0) {
#endif
for(ss=0;ss<SSLIMIT;ss++) {
if(single >= 0) {
clip += (fr->synth_mono)(hybridOut[0][ss],pcm_sample,pcm_point);
}
else {
int p1=*pcm_point;
clip += (fr->synth)(hybridOut[0][ss],0,pcm_sample,&p1);
clip += (fr->synth)(hybridOut[1][ss],1,pcm_sample,pcm_point);
}
 
#ifdef VARMODESUPPORT
if (playlimit < 128) {
pcm_point -= playlimit >> 1;
playlimit = 0;
}
else
playlimit -= 128;
#endif
}
#ifdef I486_OPT
} else {
/* Only stereo, 16 bits benefit from the 486 optimization. */
ss=0;
while (ss < SSLIMIT) {
int n;
n=(0x40000 - *pcm_point) / (2*2*32);
if (n > (SSLIMIT-ss)) n=SSLIMIT-ss;
synth_1to1_486(hybridOut[0][ss],0,pcm_sample+*pcm_point,n);
synth_1to1_486(hybridOut[1][ss],1,pcm_sample+*pcm_point,n);
ss+=n;
*pcm_point+=(2*2*32)*n;
}
}
#endif
}
return clip;
}
/programs/media/ac97snd/mpg/layer3.h
0,0 → 1,17
/*
layer3.h: some functions for interfacing to layer3 (gapless support)
 
copyright 2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Thomas Orgis.
*/
 
/* init part 1; set start/end in samples_*/
void layer3_gapless_init(unsigned long b, unsigned long e);
/* init part 2; transform to byte addresses with new info */
void layer3_gapless_bytify(struct frame *fr, struct audio_info_struct *ai);
/* after some seeking action to a new frame, the decoder needs to know which one is coming next */
void layer3_gapless_set_position(unsigned long frames, struct frame* fr, struct audio_info_struct *ai);
void layer3_gapless_set_ignore(unsigned long frames, struct frame* fr, struct audio_info_struct *ai);
/* removing the gaps from buffer */
void layer3_gapless_buffercheck();
/programs/media/ac97snd/mpg/math_private.h
0,0 → 1,209
/*
* ====================================================
* 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_ */
/programs/media/ac97snd/mpg/mpg.vcproj
0,0 → 1,281
<?xml version="1.0" encoding="windows-1251"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="mpg"
ProjectGUID="{6BB005B0-3277-4C8C-950F-38E15A4E440C}"
RootNamespace="mpg"
Keyword="Win32Proj"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
<ToolFile
RelativePath="../fasm.rules"
/>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="0"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="FASM"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
UseUnicodeResponseFiles="false"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
MinimalRebuild="false"
ExceptionHandling="0"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
FloatingPointModel="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
UseUnicodeResponseFiles="false"
IgnoreAllDefaultLibraries="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
UseUnicodeResponseFiles="false"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="4"
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"
EnableIntrinsicFunctions="true"
FavorSizeOrSpeed="2"
OmitFramePointers="true"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
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="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"
>
</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=".\getbits.c"
>
</File>
<File
RelativePath=".\layer1.c"
>
</File>
<File
RelativePath=".\layer2.c"
>
</File>
<File
RelativePath=".\layer3.c"
>
</File>
<File
RelativePath=".\pow.asm"
>
</File>
<File
RelativePath=".\readers.c"
>
</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=".\math_private.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}"
>
</Filter>
<File
RelativePath=".\ReadMe.txt"
>
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
/programs/media/ac97snd/mpg/mpg123.h
0,0 → 1,362
/*
mpg123: main code of the program (not of the decoder...)
 
copyright 1995-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
 
mpg123 defines
used source: musicout.h from mpegaudio package
*/
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>
#include <math.h>
#ifndef _AUDIO_H_
#define _AUDIO_H_
 
typedef unsigned char byte;
#define off_t long
 
//#define I486_OPT 1
 
#define SKIP_JUNK 1
# define M_PI 3.14159265358979323846
# define M_SQRT2 1.41421356237309504880
# define REAL_IS_FLOAT
# define NEW_DCT9
 
#ifdef REAL_IS_FLOAT
# define real float
# define REAL_SCANF "%f"
# define REAL_PRINTF "%f"
#else
# define real double
# define REAL_SCANF "%lf"
# define REAL_PRINTF "%f"
#endif
 
#ifndef DOUBLE_TO_REAL
# define DOUBLE_TO_REAL(x) (x)
#endif
#ifndef REAL_TO_SHORT
# define REAL_TO_SHORT(x) (x)
#endif
#ifndef REAL_PLUS_32767
# define REAL_PLUS_32767 32767.0
#endif
#ifndef REAL_MINUS_32768
# define REAL_MINUS_32768 -32768.0
#endif
#ifndef REAL_MUL
# define REAL_MUL(x, y) ((x) * (y))
#endif
 
#define INLINE
/* AUDIOBUFSIZE = n*64 with n=1,2,3 ... */
#define AUDIOBUFSIZE 16384
 
#define FALSE 0
#define TRUE 1
 
#define MAX_NAME_SIZE 81
#define SBLIMIT 32
#define SCALE_BLOCK 12
#define SSLIMIT 18
 
#define MPG_MD_STEREO 0
#define MPG_MD_JOINT_STEREO 1
#define MPG_MD_DUAL_CHANNEL 2
#define MPG_MD_MONO 3
 
/* I suspect that 32767 would be a better idea here, but Michael put this in... */
#define MAXOUTBURST 32768
 
/* Pre Shift fo 16 to 8 bit converter table */
#define AUSHIFT (3)
 
struct bitstream_info
{ int bitindex;
unsigned char *wordpointer;
};
extern struct bitstream_info bsi;
 
struct reader
{
char *hFile;
unsigned char *buffer;
unsigned char *stream;
int strpos;
int strremain;
int filelen;
int filepos;
 
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;
short d;
};
 
struct frame {
struct al_table *alloc;
int (*synth)(real *,int,unsigned char *,int *);
int (*synth_mono)(real *,unsigned char *,int *);
int stereo; /* I _think_ 1 for mono and 2 for stereo */
int jsbound;
int single;
int II_sblimit;
int down_sample_sblimit;
int lsf; /* 0: MPEG 1.0; 1: MPEG 2.0/2.5 -- both used as bool and array index! */
int mpeg25;
int down_sample;
int header_change;
int lay;
int (*do_layer)(struct frame *fr,byte *pcm_out, int *pcm_size);
int error_protection;
int bitrate_index;
int sampling_frequency;
int padding;
int extension;
int mode;
int mode_ext;
int copyright;
int original;
int emphasis;
int framesize; /* computed framesize */
int vbr; /* 1 if variable bitrate was detected */
unsigned long num; /* the nth frame in some stream... */
};
 
#if 0
struct parameter {
int aggressive; /* renice to max. priority */
int shuffle; /* shuffle/random play */
int remote; /* remote operation */
int remote_err; /* remote operation to stderr */
int outmode; /* where to out the decoded sampels */
int quiet; /* shut up! */
int xterm_title; /* Change xterm title to song names? */
long usebuffer; /* second level buffer size */
int tryresync; /* resync stream after error */
int verbose; /* verbose level */
int force_mono;
int force_stereo;
int force_8bit;
long force_rate;
int down_sample;
int checkrange;
long doublespeed;
long halfspeed;
int force_reopen;
long realtime;
char filename[256];
long listentry; /* possibility to choose playback of one entry in playlist (0: off, > 0 : select, < 0; just show list*/
int rva; /* (which) rva to do: <0: nothing, 0: radio/mix/track 1: album/audiophile */
char* listname; /* name of playlist */
int long_id3;
};
#endif
 
#if 0
struct reader {
int (*init)(struct reader *);
void (*close)(struct reader *);
int (*head_read)(struct reader *,unsigned long *newhead);
int (*head_shift)(struct reader *,unsigned long *head);
long (*skip_bytes)(struct reader *,off_t len);
int (*read_frame_body)(struct reader *,unsigned char *,int size);
int (*back_bytes)(struct reader *,off_t bytes);
int (*back_frame)(struct reader *,struct frame *,long num);
off_t (*tell)(struct reader *);
void (*rewind)(struct reader *);
off_t filelen;
off_t filepos;
int filept;
int flags;
unsigned char id3buf[128];
};
#endif
 
#define READER_FD_OPENED 0x1
#define READER_ID3TAG 0x2
#define READER_SEEKABLE 0x4
 
//extern void audio_flush(int, struct audio_info_struct *);
 
//extern void print_header(struct frame *);
//extern void print_header_compact(struct frame *);
//extern void print_id3_tag(unsigned char *buf);
 
//extern int split_dir_file(const char *path, char **dname, char **fname);
 
extern unsigned int get1bit(void);
extern unsigned int getbits(int);
extern unsigned int getbits_fast(int);
//extern void backbits(int);
//extern int getbitoffset(void);
//extern int getbyte(void);
 
//extern void set_pointer(long);
 
//extern unsigned char *pcm_sample;
//extern int pcm_point;
//extern int audiobufsize;
 
//extern int OutputDescriptor;
 
#ifdef VARMODESUPPORT
extern int varmode;
extern int playlimit;
#endif
 
struct gr_info_s {
int scfsi;
unsigned part2_3_length;
unsigned big_values;
unsigned scalefac_compress;
unsigned block_type;
unsigned mixed_block_flag;
unsigned table_select[3];
unsigned subblock_gain[3];
unsigned maxband[3];
unsigned maxbandl;
unsigned maxb;
unsigned region1start;
unsigned region2start;
unsigned preflag;
unsigned scalefac_scale;
unsigned count1table_select;
real *full_gain[3];
real *pow2gain;
};
 
struct III_sideinfo
{
unsigned main_data_begin;
unsigned private_bits;
struct {
struct gr_info_s gr[2];
} ch[2];
};
 
extern int open_stream(char *,int fd);
extern void read_frame_init (struct frame* fr);
int read_frame(struct reader *rd, struct frame *fr);
 
 
/* why extern? */
void prepare_audioinfo(struct frame *fr, struct audio_info_struct *nai);
int play_frame(int init,struct frame *fr);
int do_layer1(struct frame *fr,byte *pcm_sample, int *pcm_point);
int do_layer2(struct frame *fr,byte *pcm_sample, int *pcm_point);
int do_layer3(struct frame *fr,byte *pcm_sample, int *pcm_point);
extern void do_equalizer(real *bandPtr,int channel);
 
#ifdef PENTIUM_OPT
extern int synth_1to1_pent (real *,int,unsigned char *);
#endif
extern int synth_1to1 (real *,int,unsigned char *,int *);
extern int synth_1to1_8bit (real *,int,unsigned char *,int *);
extern int synth_1to1_mono (real *,unsigned char *,int *);
extern int synth_1to1_mono2stereo (real *,unsigned char *,int *);
extern int synth_1to1_8bit_mono (real *,unsigned char *,int *);
extern int synth_1to1_8bit_mono2stereo (real *,unsigned char *,int *);
 
extern int synth_2to1 (real *,int,unsigned char *,int *);
extern int synth_2to1_8bit (real *,int,unsigned char *,int *);
extern int synth_2to1_mono (real *,unsigned char *,int *);
extern int synth_2to1_mono2stereo (real *,unsigned char *,int *);
extern int synth_2to1_8bit_mono (real *,unsigned char *,int *);
extern int synth_2to1_8bit_mono2stereo (real *,unsigned char *,int *);
 
extern int synth_4to1 (real *,int,unsigned char *,int *);
extern int synth_4to1_8bit (real *,int,unsigned char *,int *);
extern int synth_4to1_mono (real *,unsigned char *,int *);
extern int synth_4to1_mono2stereo (real *,unsigned char *,int *);
extern int synth_4to1_8bit_mono (real *,unsigned char *,int *);
extern int synth_4to1_8bit_mono2stereo (real *,unsigned char *,int *);
 
extern int synth_ntom (real *,int,unsigned char *,int *);
extern int synth_ntom_8bit (real *,int,unsigned char *,int *);
extern int synth_ntom_mono (real *,unsigned char *,int *);
extern int synth_ntom_mono2stereo (real *,unsigned char *,int *);
extern int synth_ntom_8bit_mono (real *,unsigned char *,int *);
extern int synth_ntom_8bit_mono2stereo (real *,unsigned char *,int *);
 
extern void rewindNbits(int bits);
extern int hsstell(void);
extern void set_pointer(long);
extern void huffman_decoder(int ,int *);
extern void huffman_count1(int,int *);
extern void print_stat(struct frame *fr,unsigned long no,long buffsize,struct audio_info_struct *ai);
extern int get_songlen(struct frame *fr,int no);
 
extern void init_layer3(int);
extern void init_layer2(void);
extern void make_decode_tables(long scale);
extern int make_conv16to8_table(int);
extern void dct64(real *,real *,real *);
 
#ifdef USE_MMX
extern void dct64_MMX(short *a,short *b,real *c);
extern int synth_1to1_MMX(real *, int, short *, short *, int *);
#endif
 
extern int synth_ntom_set_step(long,long);
 
 
extern unsigned char *conv16to8;
extern long freqs[9];
extern real muls[27][64];
extern real decwin[512+32];
#ifndef USE_MMX
extern real *pnts[5];
#endif
 
extern real equalizer[2][32];
extern real equalizer_sum[2][32];
extern int equalizer_cnt;
 
extern struct audio_name audio_val2name[];
 
//extern struct parameter param;
 
/* 486 optimizations */
#define FIR_BUFFER_SIZE 128
extern void dct64_486(int *a,int *b,real *c);
extern int synth_1to1_486(real *bandPtr,int channel,unsigned char *out,int nb_blocks);
 
/* 3DNow! optimizations */
#ifdef USE_3DNOW
extern int getcpuflags(void);
extern void dct36(real *,real *,real *,real *,real *);
extern void dct36_3dnow(real *,real *,real *,real *,real *);
extern int synth_1to1_3dnow(real *,int,unsigned char *,int *);
#endif
 
/* avoid the SIGINT in terminal control */
void next_track(void);
extern long outscale;
 
#endif
 
void set_pointer(long backstep);
int __stdcall create_reader(struct reader *rd,byte *buffer, int buffsize);
int __stdcall init_reader(struct reader *rd, char *file);
int __stdcall decode_header(struct frame *fr,unsigned long newhead);
int __stdcall set_reader(struct reader *rd, unsigned int filepos);
double pow_test(double, double);
void * __cdecl mem_cpy(void * dst,const void * src,size_t count);
void init_dct();
void reset_mpg();
#ifdef __cplusplus
}
#endif
/programs/media/ac97snd/mpg/pow.asm
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
 
/programs/media/ac97snd/mpg/proc32.inc
0,0 → 1,268
 
; Macroinstructions for defining and calling procedures
 
macro stdcall proc,[arg] ; directly call STDCALL procedure
{ common
if ~ arg eq
reverse
pushd arg
common
end if
call proc }
 
macro invoke proc,[arg] ; indirectly call STDCALL procedure
{ common
if ~ arg eq
reverse
pushd arg
common
end if
call [proc] }
 
macro ccall proc,[arg] ; directly call CDECL procedure
{ common
size@ccall = 0
if ~ arg eq
reverse
pushd arg
size@ccall = size@ccall+4
common
end if
call proc
if size@ccall
add esp,size@ccall
end if }
 
macro cinvoke proc,[arg] ; indirectly call CDECL procedure
{ common
size@ccall = 0
if ~ arg eq
reverse
pushd arg
size@ccall = size@ccall+4
common
end if
call [proc]
if size@ccall
add esp,size@ccall
end if }
 
macro proc [args] ; define procedure
{ common
match name params, args>
\{ define@proc name,<params \} }
 
prologue@proc equ prologuedef
 
macro prologuedef procname,flag,parmbytes,localbytes,reglist
{ if parmbytes | localbytes
push ebp
mov ebp,esp
if localbytes
sub esp,localbytes
end if
end if
irps reg, reglist \{ push reg \} }
 
epilogue@proc equ epiloguedef
 
macro epiloguedef procname,flag,parmbytes,localbytes,reglist
{ irps reg, reglist \{ reverse pop reg \}
if parmbytes | localbytes
leave
end if
if flag and 10000b
retn
else
retn parmbytes
end if }
 
macro define@proc name,statement
{ local params,flag,regs,parmbytes,localbytes,current
if used name
name:
match =stdcall args, statement \{ params equ args
flag = 11b \}
match =stdcall, statement \{ params equ
flag = 11b \}
match =c args, statement \{ params equ args
flag = 10001b \}
match =c, statement \{ params equ
flag = 10001b \}
match =params, params \{ params equ statement
flag = 0 \}
virtual at ebp+8
match =uses reglist=,args, params \{ regs equ reglist
params equ args \}
match =regs =uses reglist, regs params \{ regs equ reglist
params equ \}
match =regs, regs \{ regs equ \}
match =,args, params \{ defargs@proc args \}
match =args@proc args, args@proc params \{ defargs@proc args \}
parmbytes = $ - (ebp+8)
end virtual
name # % = parmbytes/4
all@vars equ
current = 0
match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \}
macro locals
\{ virtual at ebp-localbytes+current
macro label . \\{ deflocal@proc .,:, \\}
struc db [val] \\{ \common deflocal@proc .,db,val \\}
struc dw [val] \\{ \common deflocal@proc .,dw,val \\}
struc dp [val] \\{ \common deflocal@proc .,dp,val \\}
struc dd [val] \\{ \common deflocal@proc .,dd,val \\}
struc dt [val] \\{ \common deflocal@proc .,dt,val \\}
struc dq [val] \\{ \common deflocal@proc .,dq,val \\}
struc rb cnt \\{ deflocal@proc .,rb cnt, \\}
struc rw cnt \\{ deflocal@proc .,rw cnt, \\}
struc rp cnt \\{ deflocal@proc .,rp cnt, \\}
struc rd cnt \\{ deflocal@proc .,rd cnt, \\}
struc rt cnt \\{ deflocal@proc .,rt cnt, \\}
struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \}
macro endl
\{ purge label
restruc db,dw,dp,dd,dt,dq
restruc rb,rw,rp,rd,rt,rq
restruc byte,word,dword,pword,tword,qword
current = $-(ebp-localbytes)
end virtual \}
macro ret operand
\{ match any, operand \\{ retn operand \\}
match , operand \\{ match epilogue:reglist, epilogue@proc:<regs>
\\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \}
macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2
end if \} }
 
macro defargs@proc [arg]
{ common
if ~ arg eq
forward
local ..arg,current@arg
match argname:type, arg
\{ current@arg equ argname
label ..arg type
argname equ ..arg
if dqword eq type
dd ?,?,?,?
else if tbyte eq type
dd ?,?,?
else if qword eq type | pword eq type
dd ?,?
else
dd ?
end if \}
match =current@arg,current@arg
\{ current@arg equ arg
arg equ ..arg
..arg dd ? \}
common
args@proc equ current@arg
forward
restore current@arg
common
end if }
 
macro deflocal@proc name,def,[val]
{ common
match vars, all@vars \{ all@vars equ all@vars, \}
all@vars equ all@vars name
forward
local ..var,..tmp
..var def val
match =?, val \{ ..tmp equ \}
match any =dup (=?), val \{ ..tmp equ \}
match tmp : value, ..tmp : val
\{ tmp: end virtual
initlocal@proc ..var,def value
virtual at tmp\}
common
match first rest, ..var, \{ name equ first \} }
 
macro initlocal@proc name,def
{ virtual at name
def
size@initlocal = $ - name
end virtual
position@initlocal = 0
while size@initlocal > position@initlocal
virtual at name
def
if size@initlocal - position@initlocal < 2
current@initlocal = 1
load byte@initlocal byte from name+position@initlocal
else if size@initlocal - position@initlocal < 4
current@initlocal = 2
load word@initlocal word from name+position@initlocal
else
current@initlocal = 4
load dword@initlocal dword from name+position@initlocal
end if
end virtual
if current@initlocal = 1
mov byte [name+position@initlocal],byte@initlocal
else if current@initlocal = 2
mov word [name+position@initlocal],word@initlocal
else
mov dword [name+position@initlocal],dword@initlocal
end if
position@initlocal = position@initlocal + current@initlocal
end while }
 
macro endp
{ purge ret,locals,endl
finish@proc
purge finish@proc
restore regs@proc
match all,args@proc \{ restore all \}
restore args@proc
match all,all@vars \{ restore all \} }
 
macro local [var]
{ common
locals
forward done@local equ
match varname[count]:vartype, var
\{ match =BYTE, vartype \\{ varname rb count
restore done@local \\}
match =WORD, vartype \\{ varname rw count
restore done@local \\}
match =DWORD, vartype \\{ varname rd count
restore done@local \\}
match =PWORD, vartype \\{ varname rp count
restore done@local \\}
match =QWORD, vartype \\{ varname rq count
restore done@local \\}
match =TBYTE, vartype \\{ varname rt count
restore done@local \\}
match =DQWORD, vartype \\{ label varname dqword
rq count+count
restore done@local \\}
match , done@local \\{ virtual
varname vartype
end virtual
rb count*sizeof.\#vartype
restore done@local \\} \}
match :varname:vartype, done@local:var
\{ match =BYTE, vartype \\{ varname db ?
restore done@local \\}
match =WORD, vartype \\{ varname dw ?
restore done@local \\}
match =DWORD, vartype \\{ varname dd ?
restore done@local \\}
match =PWORD, vartype \\{ varname dp ?
restore done@local \\}
match =QWORD, vartype \\{ varname dq ?
restore done@local \\}
match =TBYTE, vartype \\{ varname dt ?
restore done@local \\}
match =DQWORD, vartype \\{ label varname dqword
dq ?,?
restore done@local \\}
match , done@local \\{ varname vartype
restore done@local \\} \}
match ,done@local
\{ var
restore done@local \}
common
endl }
/programs/media/ac97snd/mpg/readers.c
0,0 → 1,955
#include "mpg123.h"
#include "..\kolibri.h"
 
#define MAXFRAMESIZE 3456
 
static int fsizeold=0,ssize;
static unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */
static unsigned char *bsbuf=bsspace[1],*bsbufold;
static int bsnum=0;
 
static unsigned long oldhead = 0;
unsigned long firsthead=0;
 
struct bitstream_info bsi;
 
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,} }
};
 
int freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 };
 
int stream_head_read(struct reader *rd,unsigned long *newhead);
int stream_read_raw(struct reader *rd,unsigned char *buf, int size);
 
void set_synth_functions(struct frame *fr)
{
#ifdef USE_3DNOW
static func_dct36 funcs_dct36[2] = {dct36 , dct36_3dnow};
#endif
 
fr->synth = synth_1to1;
fr->synth_mono = synth_1to1_mono2stereo;;
 
/* TODO: make autodetection for _all_ x86 optimizations (maybe just for i586+ and keep separate 486 build?) */
#ifdef USE_3DNOW
/* check cpuflags bit 31 (3DNow!) and 23 (MMX) */
if((param.stat_3dnow < 2) &&
((param.stat_3dnow == 1) ||
(getcpuflags() & 0x80800000) == 0x80800000))
{
fr->synth = funcs[2][ds]; /* 3DNow! optimized synth_1to1() */
fr->dct36 = funcs_dct36[1]; /* 3DNow! optimized dct36() */
}
else
{
fr->dct36 = funcs_dct36[0];
}
#endif
}
 
int __stdcall create_reader(struct reader *rd,byte *buffer, int buffsize)
{ rd->head_read = stream_head_read;
rd->read_frame_body = stream_read_raw;
 
rd->buffer = buffer;
rd->stream = buffer;
rd->strpos = 0;
rd->strremain = 0;
rd->filepos = 0;
return 1;
};
 
int __stdcall init_reader(struct reader *rd, char *file)
{ FILEINFO fileinfo;
int retval;
int bytes;
rd->hFile = file;
get_fileinfo(file, &fileinfo);
 
rd->filelen = fileinfo.size;
rd->strpos = 0;
retval=read_file (file,rd->buffer,0,0x10000,&bytes);
if (retval) return 0;
rd->strremain = bytes;
rd->filepos = bytes;
return 1;
};
 
static int fill_reader(struct reader *rd)
{ int retval;
int bytes;
mem_cpy(rd->buffer,rd->stream,rd->strremain);
rd->stream = rd->buffer;
retval=read_file (rd->hFile,rd->buffer+rd->strremain,rd->filepos,
0x10000-rd->strremain,&bytes);
if (retval) return 0;
if(!bytes) return 0;
rd->strremain+=bytes;
rd->filepos+=bytes;
rd->strpos = 0;
return 1;
};
 
int __stdcall set_reader(struct reader *rd, unsigned int filepos)
{ int retval;
unsigned int bytes;
retval=read_file (rd->hFile,rd->buffer,filepos,0x10000,&bytes);
if (retval) return 0;
rd->stream = rd->buffer;
rd->strremain=bytes;
rd->filepos=filepos+bytes;
rd->strpos = 0;
fsizeold=0;
firsthead=0;
bsbufold = 0;
bsbuf = bsspace[1];
bsnum = 0;
ssize=0;
oldhead=0;
memset(bsspace,0,sizeof(bsspace));
return 1;
};
static int stream_head_read(struct reader *rd,unsigned long *newhead)
{
if(rd->strremain < 4)
if( !fill_reader(rd))
return 0;
*newhead = (rd->stream[0]<<24)|(rd->stream[1] << 16)|
(rd->stream[2] << 8)| rd->stream[3];
rd->strpos+=4;
rd->stream+=4;
rd->strremain-=4;
return TRUE;
};
 
int stream_read_raw(struct reader *rd,unsigned char *buf, int size)
{
if(rd->strremain < size)
if( !fill_reader(rd))
return 0;
mem_cpy(buf,rd->stream,size);
rd->strpos+=size;
rd->stream+=size;
rd->strremain-=size;
return 1;
};
 
void set_pointer(long backstep)
{
bsi.wordpointer = bsbuf + ssize - backstep;
if (backstep)
mem_cpy(bsi.wordpointer,bsbufold+fsizeold-backstep,backstep);
bsi.bitindex = 0;
}
 
int head_check(unsigned long head)
{ if
(
/* first 11 bits are set to 1 for frame sync */
((head & 0xffe00000) != 0xffe00000)
||
/* layer: 01,10,11 is 1,2,3; 00 is reserved */
(!((head>>17)&3))
||
/* 1111 means bad bitrate */
(((head>>12)&0xf) == 0xf)
||
/* 0000 means free format... */
(((head>>12)&0xf) == 0x0)
||
/* sampling freq: 11 is reserved */
(((head>>10)&0x3) == 0x3 )
/* here used to be a mpeg 2.5 check... re-enabled 2.5 decoding due to lack of evidence that it is really not good */
)
{
return FALSE;
}
/* if no check failed, the header is valid (hopefully)*/
else
{
return TRUE;
}
}
 
int __stdcall decode_header(struct frame *fr,unsigned long newhead)
{
if(!head_check(newhead))
return 0;
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(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;
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;
 
oldhead = newhead;
 
if(!fr->bitrate_index)
return (0);
 
switch(fr->lay)
{ case 1:
fr->do_layer = do_layer1;
#ifdef VARMODESUPPORT
if (varmode) {
error("Sorry, layer-1 not supported in varmode.");
return (0);
}
#endif
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->do_layer = do_layer2;
#ifdef VARMODESUPPORT
if (varmode) {
error("Sorry, layer-2 not supported in varmode.");
return (0);
}
#endif
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);
}
if (fr->framesize > MAXFRAMESIZE)
return (0);
return 1;
}
 
 
int read_frame(struct reader *rd, struct frame *fr)
{ unsigned long newhead;
static unsigned char ssave[34];
//off_t framepos;
fsizeold=fr->framesize; /* for Layer3 */
 
read_again:
if(!rd->head_read(rd,&newhead))
return FALSE;
 
if(!decode_header(fr,newhead))
{
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;
};
 
#if 0
if(1 || oldhead != newhead || !oldhead)
{
 
init_resync:
 
#ifdef SKIP_JUNK
/* watch out for junk/tags on beginning of stream by invalid header */
if(!firsthead && !head_check(newhead) && !free_format_header(newhead)) {
int i;
 
/* check for id3v2; first three bytes (of 4) are "ID3" */
if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
{
int id3length = 0;
id3length = parse_new_id3(newhead, rd);
goto read_again;
}
else if(param.verbose > 1) fprintf(stderr,"Note: Junk at the beginning (0x%08lx)\n",newhead);
 
/* I even saw RIFF headers at the beginning of MPEG streams ;( */
if(newhead == ('R'<<24)+('I'<<16)+('F'<<8)+'F') {
if(param.verbose > 1) fprintf(stderr, "Note: Looks like a RIFF header.\n");
if(!rd->head_read(rd,&newhead))
return 0;
while(newhead != ('d'<<24)+('a'<<16)+('t'<<8)+'a') {
if(!rd->head_shift(rd,&newhead))
return 0;
}
if(!rd->head_read(rd,&newhead))
return 0;
if(param.verbose > 1) fprintf(stderr,"Note: Skipped RIFF header!\n");
goto read_again;
}
/* unhandled junk... just continue search for a header */
/* step in byte steps through next 64K */
for(i=0;i<65536;i++) {
if(!rd->head_shift(rd,&newhead))
return 0;
/* if(head_check(newhead)) */
if(head_check(newhead) && decode_header(fr, newhead))
break;
}
if(i == 65536) {
if(!param.quiet) error("Giving up searching valid MPEG header after 64K of junk.");
return 0;
}
/*
* should we additionaly check, whether a new frame starts at
* the next expected position? (some kind of read ahead)
* We could implement this easily, at least for files.
*/
}
#endif
 
/* first attempt of read ahead check to find the real first header; cannot believe what junk is out there! */
/* for now, a spurious first free format header screws up here; need free format support for detecting false free format headers... */
if(!firsthead && rd->flags & READER_SEEKABLE && head_check(newhead) && decode_header(fr, newhead))
{
unsigned long nexthead = 0;
int hd = 0;
off_t start = rd->tell(rd);
debug1("doing ahead check with BPF %d", fr->framesize+4);
/* step framesize bytes forward and read next possible header*/
if(rd->back_bytes(rd, -fr->framesize))
{
error("cannot seek!");
return 0;
}
hd = rd->head_read(rd,&nexthead);
if(rd->back_bytes(rd, rd->tell(rd)-start))
{
error("cannot seek!");
return 0;
}
if(!hd)
{
warning("cannot read next header, a one-frame stream? Duh...");
}
else
{
debug2("does next header 0x%08lx match first 0x%08lx?", nexthead, newhead);
/* not allowing free format yet */
if(!head_check(nexthead) || (nexthead & HDRCMPMASK) != (newhead & HDRCMPMASK))
{
debug("No, the header was not valid, start from beginning...");
/* try next byte for valid header */
if(rd->back_bytes(rd, 3))
{
error("cannot seek!");
return 0;
}
goto read_again;
}
}
}
 
/* why has this head check been avoided here before? */
if(!head_check(newhead))
{
if(!firsthead && free_format_header(newhead))
{
error1("Header 0x%08lx seems to indicate a free format stream; I do not handle that yet", newhead);
goto read_again;
return 0;
}
/* and those ugly ID3 tags */
if((newhead & 0xffffff00) == ('T'<<24)+('A'<<16)+('G'<<8)) {
rd->skip_bytes(rd,124);
if (param.verbose > 1) fprintf(stderr,"Note: Skipped ID3 Tag!\n");
goto read_again;
}
/* duplicated code from above! */
/* check for id3v2; first three bytes (of 4) are "ID3" */
if((newhead & (unsigned long) 0xffffff00) == (unsigned long) 0x49443300)
{
int id3length = 0;
id3length = parse_new_id3(newhead, rd);
goto read_again;
}
else if (give_note)
{
fprintf(stderr,"Note: Illegal Audio-MPEG-Header 0x%08lx at offset 0x%lx.\n", newhead,rd->tell(rd)-4);
}
 
if(give_note && (newhead & 0xffffff00) == ('b'<<24)+('m'<<16)+('p'<<8)) fprintf(stderr,"Note: Could be a BMP album art.\n");
if (param.tryresync || do_recover) {
int try = 0;
/* TODO: make this more robust, I'd like to cat two mp3 fragments together (in a dirty way) and still have mpg123 beign able to decode all it somehow. */
if(give_note) fprintf(stderr, "Note: Trying to resync...\n");
/* Read more bytes until we find something that looks
reasonably like a valid header. This is not a
perfect strategy, but it should get us back on the
track within a short time (and hopefully without
too much distortion in the audio output). */
do {
if(!rd->head_shift(rd,&newhead))
return 0;
/* debug2("resync try %i, got newhead 0x%08lx", try, newhead); */
if (!oldhead)
{
debug("going to init_resync...");
goto init_resync; /* "considered harmful", eh? */
}
/* we should perhaps collect a list of valid headers that occured in file... there can be more */
/* Michael's new resync routine seems to work better with the one frame readahead (and some input buffering?) */
} while
(
++try < RESYNC_LIMIT
&& (newhead & HDRCMPMASK) != (oldhead & HDRCMPMASK)
&& (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK)
);
/* too many false positives
}while (!(head_check(newhead) && decode_header(fr, newhead))); */
if(try == RESYNC_LIMIT)
{
error("giving up resync - your stream is not nice... perhaps an improved routine could catch up");
return 0;
}
 
if (give_note)
fprintf (stderr, "Note: Skipped %d bytes in input.\n", try);
}
else
{
error("not attempting to resync...");
return (0);
}
}
 
if (!firsthead) {
if(!decode_header(fr,newhead))
{
error("decode header failed before first valid one, going to read again");
goto read_again;
}
}
else
if(!decode_header(fr,newhead))
{
error("decode header failed - goto resync");
/* return 0; */
goto init_resync;
}
}
else
fr->header_change = 0;
#endif
 
bsbufold = bsbuf;
bsbuf = bsspace[bsnum]+512;
bsnum = (bsnum + 1) & 1;
/* if filepos is invalid, so is framepos */
//framepos = rd->filepos - 4;
/* read main data into memory */
/* 0 is error! */
if(!rd->read_frame_body(rd,bsbuf,fr->framesize))
return 0;
#if 0
if(!firsthead)
{
/* following stuff is actually layer3 specific (in practice, not in theory) */
if(fr->lay == 3)
{
/*
going to look for Xing or Info at some position after the header
MPEG 1 MPEG 2/2.5 (LSF)
Stereo, Joint Stereo, Dual Channel 32 17
Mono 17 9
Also, how to avoid false positives? I guess I should interpret more of the header to rule that out(?).
I hope that ensuring all zeros until tag start is enough.
*/
size_t lame_offset = (fr->stereo == 2) ? (fr->lsf ? 17 : 32 ) : (fr->lsf ? 9 : 17);
if(fr->framesize >= 120+lame_offset) /* traditional Xing header is 120 bytes */
{
size_t i;
int lame_type = 0;
/* only search for tag when all zero before it (apart from checksum) */
for(i=2; i < lame_offset; ++i) if(bsbuf[i] != 0) break;
if(i == lame_offset)
{
if
(
(bsbuf[lame_offset] == 'I')
&& (bsbuf[lame_offset+1] == 'n')
&& (bsbuf[lame_offset+2] == 'f')
&& (bsbuf[lame_offset+3] == 'o')
)
{
lame_type = 1; /* We still have to see what there is */
}
else if
(
(bsbuf[lame_offset] == 'X')
&& (bsbuf[lame_offset+1] == 'i')
&& (bsbuf[lame_offset+2] == 'n')
&& (bsbuf[lame_offset+3] == 'g')
)
{
lame_type = 2;
vbr = VBR; /* Xing header means always VBR */
}
if(lame_type)
{
unsigned long xing_flags;
/* we have one of these headers... */
if(param.verbose > 1) fprintf(stderr, "Note: Xing/Lame/Info header detected\n");
/* now interpret the Xing part, I have 120 bytes total for sure */
/* there are 4 bytes for flags, but only the last byte contains known ones */
lame_offset += 4; /* now first byte after Xing/Name */
/* 4 bytes dword for flags */
#define make_long(a, o) ((((unsigned long) a[o]) << 24) | (((unsigned long) a[o+1]) << 16) | (((unsigned long) a[o+2]) << 8) | ((unsigned long) a[o+3]))
/* 16 bit */
#define make_short(a,o) ((((unsigned short) a[o]) << 8) | ((unsigned short) a[o+1]))
xing_flags = make_long(bsbuf, lame_offset);
lame_offset += 4;
debug1("Xing: flags 0x%08lx", xing_flags);
if(xing_flags & 1) /* frames */
{
/*
In theory, one should use that value for skipping...
When I know the exact number of samples I could simply count in audio_flush,
but that's problematic with seeking and such.
I still miss the real solution for detecting the end.
*/
track_frames = make_long(bsbuf, lame_offset);
if(track_frames > TRACK_MAX_FRAMES) track_frames = 0; /* endless stream? */
#ifdef GAPLESS
/* if no further info there, remove/add at least the decoder delay */
if(param.gapless)
{
unsigned long length = track_frames * spf(fr);
if(length > 1)
layer3_gapless_init(DECODER_DELAY+GAP_SHIFT, length+DECODER_DELAY+GAP_SHIFT);
}
#endif
debug1("Xing: %lu frames", track_frames);
lame_offset += 4;
}
if(xing_flags & 0x2) /* bytes */
{
#ifdef DEBUG
unsigned long xing_bytes = make_long(bsbuf, lame_offset);
debug1("Xing: %lu bytes", xing_bytes);
#endif
lame_offset += 4;
}
if(xing_flags & 0x4) /* TOC */
{
lame_offset += 100; /* just skip */
}
if(xing_flags & 0x8) /* VBR quality */
{
#ifdef DEBUG
unsigned long xing_quality = make_long(bsbuf, lame_offset);
debug1("Xing: quality = %lu", xing_quality);
#endif
lame_offset += 4;
}
/* I guess that either 0 or LAME extra data follows */
/* there may this crc16 be floating around... (?) */
if(bsbuf[lame_offset] != 0)
{
unsigned char lame_vbr;
float replay_gain[2] = {0,0};
float peak = 0;
float gain_offset = 0; /* going to be +6 for old lame that used 83dB */
char nb[10];
memcpy(nb, bsbuf+lame_offset, 9);
nb[9] = 0;
debug1("Info: Encoder: %s", nb);
if(!strncmp("LAME", nb, 4))
{
gain_offset = 6;
debug("TODO: finish lame detetcion...");
}
lame_offset += 9;
/* the 4 big bits are tag revision, the small bits vbr method */
lame_vbr = bsbuf[lame_offset] & 15;
debug1("Info: rev %u", bsbuf[lame_offset] >> 4);
debug1("Info: vbr mode %u", lame_vbr);
lame_offset += 1;
switch(lame_vbr)
{
/* from rev1 proposal... not sure if all good in practice */
case 1:
case 8: vbr = CBR; break;
case 2:
case 9: vbr = ABR; break;
default: vbr = VBR; /* 00==unknown is taken as VBR */
}
/* skipping: lowpass filter value */
lame_offset += 1;
/* replaygain */
/* 32bit float: peak amplitude -- why did I parse it as int before??*/
/* Ah, yes, lame seems to store it as int since some day in 2003; I've only seen zeros anyway until now, bah! */
if
(
(bsbuf[lame_offset] != 0)
|| (bsbuf[lame_offset+1] != 0)
|| (bsbuf[lame_offset+2] != 0)
|| (bsbuf[lame_offset+3] != 0)
)
{
debug("Wow! Is there _really_ a non-zero peak value? Now is it stored as float or int - how should I know?");
peak = *(float*) (bsbuf+lame_offset);
}
debug1("Info: peak = %f (I won't use this)", peak);
peak = 0; /* until better times arrived */
lame_offset += 4;
/*
ReplayGain values - lame only writes radio mode gain...
16bit gain, 3 bits name, 3 bits originator, sign (1=-, 0=+), dB value*10 in 9 bits (fixed point)
ignore the setting if name or originator == 000!
radio 0 0 1 0 1 1 1 0 0 1 1 1 1 1 0 1
audiophile 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0
*/
for(i =0; i < 2; ++i)
{
unsigned char origin = (bsbuf[lame_offset] >> 2) & 0x7; /* the 3 bits after that... */
if(origin != 0)
{
unsigned char gt = bsbuf[lame_offset] >> 5; /* only first 3 bits */
if(gt == 1) gt = 0; /* radio */
else if(gt == 2) gt = 1; /* audiophile */
else continue;
/* get the 9 bits into a number, divide by 10, multiply sign... happy bit banging */
replay_gain[0] = ((bsbuf[lame_offset] & 0x2) ? -0.1 : 0.1) * (make_short(bsbuf, lame_offset) & 0x1f);
}
lame_offset += 2;
}
debug1("Info: Radio Gain = %03.1fdB", replay_gain[0]);
debug1("Info: Audiophile Gain = %03.1fdB", replay_gain[1]);
for(i=0; i < 2; ++i)
{
if(rva_level[i] <= 0)
{
rva_peak[i] = 0; /* at some time the parsed peak should be used */
rva_gain[i] = replay_gain[i];
rva_level[i] = 0;
}
}
lame_offset += 1; /* skipping encoding flags byte */
if(vbr == ABR)
{
abr_rate = bsbuf[lame_offset];
debug1("Info: ABR rate = %u", abr_rate);
}
lame_offset += 1;
/* encoder delay and padding, two 12 bit values... lame does write them from int ...*/
#ifdef GAPLESS
if(param.gapless)
{
/*
Temporary hack that doesn't work with seeking and also is not waterproof but works most of the time;
in future the lame delay/padding and frame number info should be passed to layer3.c and the junk samples avoided at the source.
*/
unsigned long length = track_frames * spf(fr);
unsigned long skipbegin = DECODER_DELAY + ((((int) bsbuf[lame_offset]) << 4) | (((int) bsbuf[lame_offset+1]) >> 4));
unsigned long skipend = -DECODER_DELAY + (((((int) bsbuf[lame_offset+1]) << 8) | (((int) bsbuf[lame_offset+2]))) & 0xfff);
debug3("preparing gapless mode for layer3: length %lu, skipbegin %lu, skipend %lu", length, skipbegin, skipend);
if(length > 1)
layer3_gapless_init(skipbegin+GAP_SHIFT, (skipend < length) ? length-skipend+GAP_SHIFT : length+GAP_SHIFT);
}
#endif
}
/* switch buffer back ... */
bsbuf = bsspace[bsnum]+512;
bsnum = (bsnum + 1) & 1;
goto read_again;
}
}
}
} /* end block for Xing/Lame/Info tag */
firsthead = newhead; /* _now_ it's time to store it... the first real header */
debug1("firsthead: %08lx", firsthead);
/* now adjust volume */
do_rva();
/* and print id3 info */
if(!param.quiet) print_id3_tag(rd->flags & READER_ID3TAG ? rd->id3buf : NULL);
}
#endif
bsi.bitindex = 0;
bsi.wordpointer = (unsigned char *) bsbuf;
set_synth_functions(fr);
if (fr->error_protection)
getbits(16);
return 1;
}
 
 
#if 0
 
static int stream_back_bytes(struct reader *rds, off_t bytes)
{
if(stream_lseek(rds,-bytes,SEEK_CUR) < 0)
return -1;
/* you sure you want the buffer to resync here? */
if(param.usebuffer)
buffer_resync();
return 0;
}
 
 
/* this function strangely is define to seek num frames _back_ (and is called with -offset - duh!) */
/* also... let that int be a long in future! */
static int stream_back_frame(struct reader *rds,struct frame *fr,long num)
{
if(rds->flags & READER_SEEKABLE)
{
unsigned long newframe, preframe;
if(num > 0) /* back! */
{
if(num > fr->num) newframe = 0;
else newframe = fr->num-num;
}
else newframe = fr->num-num;
/* two leading frames? hm, doesn't seem to be really needed... */
/*if(newframe > 1) newframe -= 2;
else newframe = 0;*/
/* now seek to nearest leading index position and read from there until newframe is reached */
if(stream_lseek(rds,frame_index_find(newframe, &preframe),SEEK_SET) < 0)
return -1;
debug2("going to %lu; just got %lu", newframe, preframe);
fr->num = preframe;
while(fr->num < newframe)
{
/* try to be non-fatal now... frameNum only gets advanced on success anyway */
if(!read_frame(fr)) break;
}
 
/* this is not needed at last? */
/*read_frame(fr);
read_frame(fr);*/
 
if(fr->lay == 3) {
set_pointer(512);
}
 
debug1("arrived at %lu", fr->num);
 
if(param.usebuffer)
buffer_resync();
 
return 0;
 
}
else return -1; /* invalid, no seek happened */
}
 
static int stream_head_read(struct reader *rds,unsigned long *newhead)
{
unsigned char hbuf[4];
 
if(fullread(rds,hbuf,4) != 4)
return FALSE;
*newhead = ((unsigned long) hbuf[0] << 24) |
((unsigned long) hbuf[1] << 16) |
((unsigned long) hbuf[2] << 8) |
(unsigned long) hbuf[3];
return TRUE;
}
 
static int stream_head_shift(struct reader *rds,unsigned long *head)
{
unsigned char hbuf;
 
if(fullread(rds,&hbuf,1) != 1)
return 0;
*head <<= 8;
*head |= hbuf;
*head &= 0xffffffff;
return 1;
}
 
static off_t stream_skip_bytes(struct reader *rds,off_t len)
{
if (rds->filelen >= 0) {
off_t ret = stream_lseek(rds, len, SEEK_CUR);
if (param.usebuffer)
buffer_resync();
return ret;
} else if (len >= 0) {
unsigned char buf[1024]; /* ThOr: Compaq cxx complained and it makes sense to me... or should one do a cast? What for? */
off_t ret;
while (len > 0) {
off_t num = len < sizeof(buf) ? len : sizeof(buf);
ret = fullread(rds, buf, num);
if (ret < 0)
return ret;
len -= ret;
}
return rds->filepos;
} else
return -1;
}
 
static int stream_read_frame_body(struct reader *rds,unsigned char *buf,
int size)
{
long l;
 
if( (l=fullread(rds,buf,size)) != size)
{
if(l <= 0)
return 0;
memset(buf+l,0,size-l);
}
 
return 1;
}
 
static off_t stream_tell(struct reader *rds)
{
return rds->filepos;
}
 
static void stream_rewind(struct reader *rds)
{
stream_lseek(rds,0,SEEK_SET);
if(param.usebuffer)
buffer_resync();
}
 
static off_t get_fileinfo(struct reader *rds,char *buf)
{
off_t len;
 
if((len=lseek(rds->filept,0,SEEK_END)) < 0) {
return -1;
}
if(lseek(rds->filept,-128,SEEK_END) < 0)
return -1;
if(fullread(rds,(unsigned char *)buf,128) != 128) {
return -1;
}
if(!strncmp(buf,"TAG",3)) {
len -= 128;
}
if(lseek(rds->filept,0,SEEK_SET) < 0)
return -1;
if(len <= 0)
return -1;
return len;
}
 
#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;
};
/programs/media/ac97snd/mpg/tabinit.c
0,0 → 1,159
/*
tabinit.c: initialize tables...
 
copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
see COPYING and AUTHORS files in distribution or http://mpg123.de
initially written by Michael Hipp
*/
 
//#include <stdlib.h>
 
//#include "config.h"
#include "mpg123.h"
//#include "debug.h"
 
static unsigned char *conv16to8_buf = NULL;
unsigned char *conv16to8;
 
#ifndef USE_MMX
real decwin[512+32];
#ifdef USE_ALTIVEC
static real __attribute__ ((aligned (16))) cos64[16];
static real __attribute__ ((aligned (16))) cos32[8];
static real __attribute__ ((aligned (16))) cos16[4];
static real __attribute__ ((aligned (16))) cos8[2];
static real __attribute__ ((aligned (16))) cos4[1];
#else
static real cos64[16],cos32[8],cos16[4],cos8[2],cos4[1];
#endif
 
real *pnts[] = { cos64,cos32,cos16,cos8,cos4 };
 
 
static long intwinbase[] = {
0, -1, -1, -1, -1, -1, -1, -2, -2, -2,
-2, -3, -3, -4, -4, -5, -5, -6, -7, -7,
-8, -9, -10, -11, -13, -14, -16, -17, -19, -21,
-24, -26, -29, -31, -35, -38, -41, -45, -49, -53,
-58, -63, -68, -73, -79, -85, -91, -97, -104, -111,
-117, -125, -132, -139, -147, -154, -161, -169, -176, -183,
-190, -196, -202, -208, -213, -218, -222, -225, -227, -228,
-228, -227, -224, -221, -215, -208, -200, -189, -177, -163,
-146, -127, -106, -83, -57, -29, 2, 36, 72, 111,
153, 197, 244, 294, 347, 401, 459, 519, 581, 645,
711, 779, 848, 919, 991, 1064, 1137, 1210, 1283, 1356,
1428, 1498, 1567, 1634, 1698, 1759, 1817, 1870, 1919, 1962,
2001, 2032, 2057, 2075, 2085, 2087, 2080, 2063, 2037, 2000,
1952, 1893, 1822, 1739, 1644, 1535, 1414, 1280, 1131, 970,
794, 605, 402, 185, -45, -288, -545, -814, -1095, -1388,
-1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
-5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209,
-8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959,
-9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092,
-7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082,
-70, 998, 2122, 3300, 4533, 5818, 7154, 8540, 9975, 11455,
12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289,
30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617,
48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684,
64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835,
73415, 73908, 74313, 74630, 74856, 74992, 75038 };
 
#pragma warning(disable:4244)
void make_decode_tables(long scaleval)
{
int i,j,k,kr,divv;
real *costab;
int idx;
 
for(i=0;i<5;i++)
{
kr=0x10>>i; divv=0x40>>i;
costab = pnts[i];
for(k=0;k<kr;k++)
costab[k] = DOUBLE_TO_REAL(1.0 / (2.0 * cos(M_PI * ((double) k * 2.0 + 1.0) / (double) divv)));
 
}
 
idx = 0;
scaleval = -scaleval;
for(i=0,j=0;i<256;i++,j++,idx+=32)
{
if(idx < 512+16)
decwin[idx+16] = decwin[idx] = DOUBLE_TO_REAL((double) intwinbase[j] / 65536.0 * (double) scaleval);
 
if(i % 32 == 31)
idx -= 1023;
if(i % 64 == 63)
scaleval = - scaleval;
}
 
for( /* i=256 */ ;i<512;i++,j--,idx+=32)
{
if(idx < 512+16)
decwin[idx+16] = decwin[idx] = DOUBLE_TO_REAL((double) intwinbase[j] / 65536.0 * (double) scaleval);
 
if(i % 32 == 31)
idx -= 1023;
if(i % 64 == 63)
scaleval = - scaleval;
}
}
#endif
 
#if 0
int make_conv16to8_table(int mode)
{
int i;
 
/*
* ????: 8.0 is right but on SB cards '2.0' is a better value ???
*/
const double mul = 8.0;
 
if(!conv16to8_buf) {
conv16to8_buf = (unsigned char *) malloc(8192);
if(!conv16to8_buf) {
error("Can't allocate 16 to 8 converter table!");
return -1;
}
conv16to8 = conv16to8_buf + 4096;
}
 
if(mode == AUDIO_FORMAT_ULAW_8) {
double m=127.0 / log(256.0);
int c1;
 
for(i=-4096;i<4096;i++) {
/* dunno whether this is a valid transformation rule ?!?!? */
if(i < 0)
c1 = 127 - (int) (log( 1.0 - 255.0 * (double) i*mul / 32768.0 ) * m);
else
c1 = 255 - (int) (log( 1.0 + 255.0 * (double) i*mul / 32768.0 ) * m);
if(c1 < 0 || c1 > 255)
fprintf(stderr,"Converror %d %d\n",i,c1);
if(c1 == 0)
c1 = 2;
conv16to8[i] = (unsigned char) c1;
}
}
else if(mode == AUDIO_FORMAT_SIGNED_8) {
for(i=-4096;i<4096;i++) {
conv16to8[i] = i>>5;
}
}
else if(mode == AUDIO_FORMAT_UNSIGNED_8) {
for(i=-4096;i<4096;i++) {
conv16to8[i] = (i>>5)+128;
}
}
else {
for(i=-4096;i<4096;i++) {
conv16to8[i] = 0;
}
}
return 0;
}
 
 
#endif
/programs/media/ac97snd/sound.h
0,0 → 1,136
 
#ifndef _SOUND_H_
#define _SOUND_H_
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define SOUND_VERSION 0x0100
#define PCM_ALL 0
 
#define PCM_OUT 0x08000000
#define PCM_RING 0x10000000
#define PCM_STATIC 0x20000000
#define PCM_FLOAT 0x40000000
#define PCM_FILTER 0x80000000
 
#define PCM_2_16_48 1
#define PCM_1_16_48 2
#define PCM_2_16_44 3
#define PCM_1_16_44 4
#define PCM_2_16_32 5
#define PCM_1_16_32 6
#define PCM_2_16_24 7
#define PCM_1_16_24 8
#define PCM_2_16_22 9
#define PCM_1_16_22 10
#define PCM_2_16_16 11
#define PCM_1_16_16 12
#define PCM_2_16_12 13
#define PCM_1_16_12 14
#define PCM_2_16_11 15
#define PCM_1_16_11 16
#define PCM_2_16_8 17
#define PCM_1_16_8 18
#define PCM_2_8_48 19
#define PCM_1_8_48 20
#define PCM_2_8_44 21
#define PCM_1_8_44 22
#define PCM_2_8_32 23
#define PCM_1_8_32 24
#define PCM_2_8_24 25
#define PCM_1_8_24 26
#define PCM_2_8_22 27
#define PCM_1_8_22 28
#define PCM_2_8_16 29
#define PCM_1_8_16 30
#define PCM_2_8_12 31
#define PCM_1_8_12 32
#define PCM_2_8_11 33
#define PCM_1_8_11 34
#define PCM_2_8_8 35
#define PCM_1_8_8 36
 
#define SRV_GETVERSION 0
#define SND_CREATE_BUFF 1
#define SND_DESTROY_BUFF 2
#define SND_SETFORMAT 3
#define SND_GETFORMAT 4
#define SND_RESET 5
#define SND_SETPOS 6
#define SND_GETPOS 7
#define SND_SETBUFF 8
#define SND_OUT 9
#define SND_PLAY 10
#define SND_STOP 11
#define SND_SETVOLUME 12
#define SND_GETVOLUME 13
#define SND_SETPAN 14
#define SND_GETPAN 15
#define SND_GETBUFFSIZE 16
#define SND_GETFREESPACE 17
 
 
#define PLAY_SYNC 0x80000000
 
typedef unsigned int SNDBUF;
 
int _stdcall InitSound(int *version);
 
int _stdcall CreateBuffer(unsigned int format,int size,SNDBUF *buf);
int _stdcall DestroyBuffer(SNDBUF hBuff);
 
int _stdcall SetFormat(SNDBUF hBuff, unsigned int format);
int _stdcall GetFormat(SNDBUF hBuff, unsigned int *format);
 
int _stdcall ResetBuffer(SNDBUF hBuff, unsigned int flags);
int _stdcall SetBufferPos(SNDBUF hBuff, int offset);
int _stdcall GetBufferPos(SNDBUF hBuff, int *offset);
int _stdcall GetBufferSize(SNDBUF hBuff, int *size);
int _stdcall GetBufferFree(SNDBUF hBuff, int *free);
 
int _stdcall SetBuffer(SNDBUF hBuff,void* buff,
int offs, int size);
int _stdcall WaveOut(SNDBUF hBuff,void *buff, int size);
int _stdcall PlayBuffer(SNDBUF hBuff,unsigned int flags);
int _stdcall StopBuffer(SNDBUF hBuff);
 
int _stdcall SetVolume(SNDBUF hBuff, int left, int right);
int _stdcall GetVolume(SNDBUF hBuff, int *left, int *right);
int _stdcall SetPan(SNDBUF hBuff, int pan);
int _stdcall GetPan(SNDBUF hBuff, int *pan);
 
int _stdcall GetMasterVol(int* vol);
int _stdcall SetMasterVol(int vol);
 
 
typedef struct
{
unsigned int riff_id;
unsigned int riff_size;
unsigned int riff_format;
 
unsigned int fmt_id;
unsigned int fmt_size;
 
unsigned short int wFormatTag;
unsigned short int nChannels;
unsigned int nSamplesPerSec;
unsigned int nAvgBytesPerSec;
unsigned short int nBlockAlign;
unsigned short int wBitsPerSample;
unsigned int data_id;
unsigned int data_size;
} WAVEHEADER;
 
 
unsigned int _stdcall test_wav(WAVEHEADER *hdr);
 
#ifdef __cplusplus
extern "C"
}
#endif
 
#endif //_SOUND_H_