arnavbhatt288/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

ac97_mp3 source code

Browse Source 
git-svn-id: svn://kolibrios.org@165 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge) 2006-10-06 06:20:41 +00:00
parent b6950333ac
commit 1634ac97c2
38 changed files with 10606 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

268
programs/media/ac97 mp3/trunk/PROC32.INC Normal file
View File

@ -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 }

38
programs/media/ac97 mp3/trunk/ac97.sln Normal file
View File

@ -0,0 +1,38 @@

Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pe2kos", "pe2kos\pe2kos.vcproj", "{50E3FB09-4E3A-4998-A824-6830405193AE}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mp3dec", "mp3dec\mp3dec.vcproj", "{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pow_test", "pow_test\pow_test.vcproj", "{9FE40739-2ADC-4241-8182-20E1B3C661A7}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ac97", "ac97\ac97.vcproj", "{1C94A897-DA4F-45B2-B8A6-B97AD837828E}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{50E3FB09-4E3A-4998-A824-6830405193AE}.Debug|Win32.ActiveCfg = Debug|Win32
{50E3FB09-4E3A-4998-A824-6830405193AE}.Debug|Win32.Build.0 = Debug|Win32
{50E3FB09-4E3A-4998-A824-6830405193AE}.Release|Win32.ActiveCfg = Release|Win32
{50E3FB09-4E3A-4998-A824-6830405193AE}.Release|Win32.Build.0 = Release|Win32
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Debug|Win32.ActiveCfg = Debug|Win32
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Debug|Win32.Build.0 = Debug|Win32
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Release|Win32.ActiveCfg = Release|Win32
{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}.Release|Win32.Build.0 = Release|Win32
{9FE40739-2ADC-4241-8182-20E1B3C661A7}.Debug|Win32.ActiveCfg = Debug|Win32
{9FE40739-2ADC-4241-8182-20E1B3C661A7}.Debug|Win32.Build.0 = Debug|Win32
{9FE40739-2ADC-4241-8182-20E1B3C661A7}.Release|Win32.ActiveCfg = Release|Win32
{9FE40739-2ADC-4241-8182-20E1B3C661A7}.Release|Win32.Build.0 = Release|Win32
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Debug|Win32.ActiveCfg = Debug|Win32
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Debug|Win32.Build.0 = Debug|Win32
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Release|Win32.ActiveCfg = Release|Win32
{1C94A897-DA4F-45B2-B8A6-B97AD837828E}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

718
programs/media/ac97 mp3/trunk/ac97wav.c Normal file
View File

@ -0,0 +1,718 @@
//
// 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 "stdio.h"
#include "string.h"
#include "ac97wav.h"
#include "mp3dec/mp3dec.h"
void thread_proc();
void touch(char *buf, int size);
extern char *__argv;
//extern char __path;
/***** for debug output only
char formats[37][12] =
{ "PCM_ALL",
"PCM_2_16_48","PCM_1_16_48","PCM_2_16_44","PCM_1_16_44",
"PCM_2_16_32","PCM_1_16_32","PCM_2_16_24","PCM_1_16_24",
"PCM_2_16_22","PCM_1_16_22","PCM_2_16_16","PCM_1_16_16",
"PCM_2_16_12","PCM_1_16_12","PCM_2_16_11","PCM_1_16_11",
"PCM_2_16_8","PCM_1_16_8","PCM_2_8_48","PCM_1_8_48",
"PCM_2_8_44","PCM_1_8_44","PCM_2_8_32","PCM_1_8_32",
"PCM_2_8_24","PCM_1_8_24","PCM_2_8_22","PCM_1_8_22",
"PCM_2_8_16","PCM_1_8_16","PCM_2_8_12","PCM_1_8_12",
"PCM_2_8_11","PCM_1_8_11","PCM_2_8_8","PCM_1_8_8"
};
*******/
DWORD hDrv;
DWORD hSound;
DWORD hBuff;
DWORD event[2];
CTRL_INFO info;
FILEINFO fileinfo;
int m_vol;
DWORD status;
DWORD offset;
DWORD first_sync;
char *testbuff;
char *outbuf;
char *inpbuf;
int inpsize;
int outsize;
char srv_name[] = "INFINITY";
char srv_intel[] = "SOUND";
char header[] = "AC97 MP3 player";
char buttons_text[]=" Play Stop << >> Vol- Vol+";
MPEG_DECODE_INFO mpginfo;
MPEG_DECODE_PARAM param;
void (*snd_play)();
void draw_window()
{
BeginDraw();
DrawWindow(100,100,299,72,0x404040,3,0,0,0);
make_button(7,24,45,13, 0x10|BT_NORMAL,0x808080);
make_button(56,24,45,13, 0x11|BT_NORMAL,0x808080);
make_button(104,24,45,13, 0x12|BT_NORMAL,0x808080);
make_button(152,24,45,13, 0x13|BT_NORMAL,0x808080);
make_button(200,24,45,13, 0x14|BT_NORMAL,0x808080);
make_button(248,24,45,13, 0x15|BT_NORMAL,0x808080);
make_button(7,41,286,11, 0x30|BT_HIDE|BT_NOFRAME,0x404040);
draw_bar(7,41,286,11,0x404040);
draw_bar(7,55,286,11,0x404040);
write_text(12,58,0x004000|FONT0, __argv, strlen(__argv));
write_text(11,57,0x00FF20|FONT0, __argv, strlen(__argv));
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 = 286.0f * (float)offset/(float)fileinfo.size;
if(x==0) return;
draw_bar(7,41,x,11,0xA0A0A0);
draw_bar(x+7,41,286-x,11,0x404040);
};
void debug_out_str(char* str)
{
while (*str != 0)
{
debug_out(*str);
str++;
}
}
int main() //int argc, char *argv[])
{ DWORD fmt;
char *thread_stack;
DWORD r_bytes;
int retval;
InitHeap(1024*1024);
if(get_fileinfo(__argv, &fileinfo)==FILE_NOT_FOUND)
return 0;
if((hDrv=GetService(srv_intel))==0)
return 0;
if ((hSound=GetService(srv_name))==0)
return 0;
GetDevInfo(hDrv, &info);
m_vol = GetMasterVol(hDrv,&m_vol);
if (m_vol > 85)
{ m_vol = 85;
SetMasterVol(hDrv,m_vol);
};
_asm {fninit};
mp3DecodeInit();
testbuff = UserAlloc(4096);
get_fileinfo(__argv, &fileinfo);
offset = 0;
retval=read_file (__argv,testbuff,0,2048,&r_bytes);
if (retval) return 0;
fmt = test_wav((WAVEHEADER*)testbuff);
if (fmt != 0)
{
snd_play = &play_wave;
outbuf = UserAlloc(32*1024);
touch(outbuf, 32768);
offset = 44;
}
else
{ fmt = test_mp3(testbuff);
if(fmt ==0) return 0;
snd_play = &play_mp3;
inpsize = mpginfo.maxInputSize*30;
inpbuf = UserAlloc(inpsize);
touch(inpbuf, inpsize);
outsize = mpginfo.outputSize*30+0x10000;
outbuf = UserAlloc(outsize);
touch(outbuf, outsize);
first_sync = offset;
};
status = ST_PLAY;
hBuff = CreateBuffer(hSound,fmt);
if (hBuff == 0) return 0;
thread_stack = UserAlloc(4096);
thread_stack+=4092;
CreateThread(thread_proc, thread_stack);
while(1)
{ delay(10);
switch(status)
{ case ST_PLAY:
snd_play();
continue;
case ST_STOP:
StopBuffer(hSound, hBuff);
status = ST_DONE;
continue;
case ST_EXIT:
StopBuffer(hSound, hBuff);
DestroyBuffer(hSound, hBuff);
return 0;
};
};
return 0;
};
void touch(char *buf, int size)
{ int i;
for ( i = 0;i < size; i+=4096)
buf[i] = 0;
};
DWORD test_mp3(char *buf)
{ int retval;
int sync;
WAVEHEADER whdr;
DWORD r_bytes=2048;
for (;;)
{
if (!mp3FindSync(buf, 2048, &sync))
offset+= 2048;
else break;
if (offset >= fileinfo.size || offset >= 102400)
return 0;
retval = read_file (__argv,buf,offset,2048,&r_bytes);
if(retval != 0) return 0;
};
offset+=sync;
retval = read_file (__argv,buf,offset,2048,&r_bytes);
if(retval != 0) return 0;
mp3GetDecodeInfo(buf, r_bytes, &mpginfo, 1);
whdr.riff_id = 0x46464952;
whdr.riff_format = 0x45564157;
whdr.wFormatTag = 0x01;
whdr.nSamplesPerSec = mpginfo.frequency;
whdr.nChannels = mpginfo.channels;
whdr.wBitsPerSample = mpginfo.bitsPerSample;
return test_wav(&whdr);
};
void wave_out(char* buff)
{ DWORD ev[2];
GetNotify(&ev[0]);
SetBuffer(hSound,hBuff,buff,ev[1],0x8000);
}
void play_mp3()
{ int retval;
DWORD r_bytes;
char *inpPtr;
char *outPtr;
int inpBytes;
int totalout;
offset = first_sync;
retval = read_file (__argv,inpbuf,offset,inpsize,&r_bytes);
if(retval != 0)
{ status = ST_STOP;
return ;
};
offset+=inpsize;
mp3DecodeStart(inpbuf, inpsize);
inpPtr = inpbuf+mpginfo.skipSize;
inpBytes = inpsize-mpginfo.skipSize;
outPtr = outbuf;
totalout=0;
memset(outbuf,0,0x10000);
SetBuffer(hSound,hBuff,outbuf,0,0x10000);
PlayBuffer(hSound, hBuff);
_asm { fninit }
while(1)
{ if(status!=ST_PLAY)
break;
for(;;)
{ param.inputBuf = inpPtr;
param.inputSize = inpBytes;
param.outputBuf = outPtr;
if(!mp3DecodeFrame(&param))
if( mp3GetLastError()== MP3_ERROR_OUT_OF_BUFFER)
break;
inpPtr += param.inputSize;
inpBytes -= param.inputSize;
outPtr+=param.outputSize;
totalout+=param.outputSize;
};
memmove(inpbuf, inpPtr, inpBytes);
retval = read_file(__argv, &inpbuf[inpBytes],offset, inpsize-inpBytes, &r_bytes);
offset+=r_bytes;
if (r_bytes== 0) break;
inpPtr = inpbuf;
inpBytes += r_bytes;
if(totalout < 32768) continue;
outPtr = outbuf;
while (totalout > 32768)
{ wave_out(outPtr);
totalout-=0x8000;
outPtr+=0x8000;
};
memmove(outbuf,outPtr, totalout);
outPtr = outbuf+totalout;
};
if(status != ST_EXIT)
status = ST_STOP;
};
void play_wave()
{
int retval;
int remain;
int i;
offset = 44;
read_file (__argv,outbuf,offset,32*1024,0);
offset+=32*1024;
SetBuffer(hSound,hBuff,outbuf,0,0x8000);
read_file (__argv,outbuf,offset,32*1024,0);
offset+=32*1024;
SetBuffer(hSound,hBuff,outbuf,0x8000,0x8000);
PlayBuffer(hSound, hBuff);
retval = 0;
while(1)
{
if(status!=ST_PLAY)
break;
GetNotify(&event[0]);
if(retval == FILE_EOF)
break;
remain = fileinfo.size-offset;
if(remain >=32768)
{ retval = read_file (__argv,outbuf,offset,32*1024,0);
offset+=32*1024;
SetBuffer(hSound,hBuff,outbuf,event[1],0x8000);
continue;
};
if(remain == 0)
{ retval = FILE_EOF;
continue;
};
read_file (__argv,outbuf,offset,remain,0);
for(i=remain;i<32768;i++)
outbuf[i] = 0;
SetBuffer(hSound,hBuff,outbuf,event[1],0x8000);
retval= FILE_EOF;
};
if(status != ST_EXIT)
status = ST_STOP;
};
void snd_stop()
{
StopBuffer(hSound, hBuff);
};
void thread_proc()
{ int evnt;
int pos;
int key;
_asm { fninit };
draw_window();
while(1)
{ if(status==ST_PLAY)
{ draw_progress_bar();
evnt = wait_for_event(80);
// debug_out_str("BIG ERROR...\x0D\x0A\x00");
}
else
evnt = wait_for_event_infinite();
switch(evnt)
{
case EV_REDRAW:
draw_window();
break;
case EV_KEY:
key = get_key();
if(key==27)
{ status = ST_EXIT;
exit();
};
if((key==45)||key==54)
{ if(m_vol > 0)
{ m_vol--;
SetMasterVol(hDrv,m_vol);
};
break;
};
if((key==61)||key==56)
{ if(m_vol < 90)
{ m_vol++;
SetMasterVol(hDrv,m_vol);
};
};
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(m_vol > 0)
{ m_vol--;
SetMasterVol(hDrv,m_vol);
};
break;
case 0x15:
if(m_vol < 90)
{ m_vol++;
SetMasterVol(hDrv,m_vol);
};
break;
case 0x30:
if(status==ST_DONE)
break;
if(snd_play == play_mp3)
continue;
pos = (GetMousePos(REL_WINDOW)>>16)-7;
offset = ((fileinfo.size-44)/286*pos+44)&0xFFFFFFFC;
draw_progress_bar();
break;
};
};
};
};
DWORD test_wav(WAVEHEADER *hdr)
{
if(hdr->riff_id != 0x46464952)
return 0;
if(hdr->riff_format != 0x45564157)
return 0;
if (hdr->wFormatTag != 0x01)
return 0;
switch(hdr->nSamplesPerSec)
{ case 48000:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_48;
else
return PCM_1_8_48;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_48;
else
return PCM_2_8_48;
};
case 44100:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_44;
else
return PCM_1_8_44;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_44;
else
return PCM_2_8_44;
};
case 32000:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_32;
else
return PCM_1_8_32;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_32;
else
return PCM_2_8_32;
};
case 24000:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_24;
else
return PCM_1_8_24;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_24;
else
return PCM_2_8_24;
};
case 22050:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_22;
else
return PCM_1_8_22;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_22;
else
return PCM_2_8_22;
};
case 16000:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_16;
else
return PCM_1_8_16;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_16;
else
return PCM_2_8_16;
};
case 12000:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_12;
else
return PCM_1_8_12;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_12;
else
return PCM_2_8_12;
};
case 11025:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_11;
else
return PCM_1_8_11;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_11;
else
return PCM_2_8_11;
};
case 8000:
switch (hdr->nChannels)
{ case 1:
if(hdr->wBitsPerSample == 16)
return PCM_1_16_8;
else
return PCM_1_8_8;
case 2:
if(hdr->wBitsPerSample == 16)
return PCM_2_16_8;
else
return PCM_2_8_8;
};
default:
return 0;
};
};
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 * __cdecl memmove ( void * dst, const void * src, size_t count)
{ void * 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);
};
// 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");

86
programs/media/ac97 mp3/trunk/ac97wav.h Normal file
View File

@ -0,0 +1,86 @@
//
// 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 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 ST_DONE 0x0
#define ST_PLAY 0x1
#define ST_EXIT 0x2
#define ST_STOP 0x4
typedef struct
{ DWORD riff_id;
DWORD riff_size;
DWORD riff_format;
DWORD fmt_id;
DWORD fmt_size;
WORD wFormatTag;
WORD nChannels;
DWORD nSamplesPerSec;
DWORD nAvgBytesPerSec;
WORD nBlockAlign;
WORD wBitsPerSample;
DWORD data_id;
DWORD data_size;
} WAVEHEADER;
DWORD test_wav(WAVEHEADER *hdr);
DWORD test_mp3(char *buf);
//void (*snd_play)();
void wave_out(char* buff);
void play_wave();
void play_mp3();
void snd_stop();

70
programs/media/ac97 mp3/trunk/crt.c Normal file
View File

@ -0,0 +1,70 @@
#include "crt.h"
#define atexitBufferSize 32
char pureCallMessage[] = "PURE function call!";
char *__argv = 0;
void (__cdecl *atExitList[atexitBufferSize])();
int atExitFnNum = 0;
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)();
}
__argv = *((char **)0x1C);
main();
exit();
}

13
programs/media/ac97 mp3/trunk/crt.h Normal file
View File

@ -0,0 +1,13 @@
typedef unsigned __int32 Dword;
typedef unsigned __int16 Word;
typedef unsigned __int8 Byte;
typedef unsigned __int32 size_t;
extern char *__argv;
void crtStartUp();
int __cdecl _purecall();
int __cdecl atexit( void (__cdecl *func )( void ));
void exit();
int main();

714
programs/media/ac97 mp3/trunk/k_lib.asm Normal file
View File

@ -0,0 +1,714 @@
;
; 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.
format MS COFF
include "proc32.inc"
section '.text' code readable executable
public _GetService@4
public _GetDevInfo@8
public _GetMasterVol@8
public _SetMasterVol@8
public _CreateBuffer@8
public _DestroyBuffer@8
public _SetBuffer@20
public _PlayBuffer@8
public _StopBuffer@8
public _InitHeap@4
public _UserAlloc@4
public _GetNotify@4
public _CreateThread@8
public _GetMousePos@4
public _get_fileinfo@8
public _read_file@20
public _get_key
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 _memset
struc FILEIO
{ .cmd dd ?
.offset dd ?
dd ?
.count dd ?
.buff dd ?
db ?
.name dd ?
};
struc CTRL_INFO
{ .pci_cmd dd ?
.irq dd ?
.glob_cntrl dd ?
.glob_sta dd ?
.codec_io_base dd ?
.ctrl_io_base dd ?
.codec_mem_base dd ?
.ctrl_mem_base dd ?
.codec_id dd ?
}
CTRL_INFO_SIZE equ 9*4
SND_CREATE_DEV equ 1
SND_CREATE_BUFF equ 2
SND_PLAY equ 3
SND_STOP equ 4
SND_SETBUFF equ 5
SND_DESTROY_BUFF equ 6
DEV_SET_BUFF equ 4
DEV_NOTIFY equ 5
DEV_SET_MASTERVOL equ 6
DEV_GET_MASTERVOL equ 7
DEV_GET_INFO equ 8
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
mov eax, 2
int 0x40
shr eax, 8
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 _GetNotify@4 stdcall, p_ev:dword
push ebx
mov eax, 68
mov ebx, 14
mov ecx, [p_ev]
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 CallServiceEx stdcall, ioctl:dword
push ebx
mov eax, 68
mov ebx, 17
mov ecx, [ioctl]
int 0x40
pop ebx
ret
endp
align 4
proc _GetService@4 stdcall, name:dword
push ebx
mov eax, 68
mov ebx, 16
mov ecx, [name]
int 0x40
pop ebx
ret
endp
align 4
proc _GetDevInfo@8 stdcall, hSrv:dword, p_info:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSrv]
xor ebx, ebx
mov ecx, [p_info]
mov [handle], eax
mov [io_code], DEV_GET_INFO
mov [input], ebx
mov [inp_size], ebx
mov [output], ecx
mov [out_size], CTRL_INFO_SIZE
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _GetMasterVol@8 stdcall, hSrv:dword,pvol:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSrv]
mov ecx, [pvol]
xor ebx, ebx
mov [handle], eax
mov [io_code], DEV_GET_MASTERVOL
mov [input], ebx
mov [inp_size], ebx
mov [output], ecx
mov [out_size], 4
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _SetMasterVol@8 stdcall,hSrv:dword,vol:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSrv]
lea ecx, [vol]
xor ebx, ebx
mov [handle], eax
mov [io_code], DEV_SET_MASTERVOL
mov [input], ecx
mov [inp_size], 4
mov [output], ebx
mov [out_size], 0
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _CreateBuffer@8 stdcall, hSound:dword,format:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSound]
lea ecx, [format]
xor ebx, ebx
mov [handle], eax
mov [io_code], SND_CREATE_BUFF
mov [input], ecx
mov [inp_size], 4
mov [output], ebx
mov [out_size], 0
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _DestroyBuffer@8 stdcall, hSound:dword, str:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSound]
lea ecx, [str]
xor ebx, ebx
mov [handle], eax
mov [io_code], SND_DESTROY_BUFF
mov [input], ecx
mov [inp_size], 4
mov [output], ebx
mov [out_size], 0
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _SetBuffer@20 stdcall,hSound:dword, str:dword, src:dword, offs:dword, size:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSound]
lea ecx, [str]
xor ebx, ebx
mov [handle], eax
mov [io_code], SND_SETBUFF
mov [input], ecx
mov [inp_size], 16
mov [output], ebx
mov [out_size], 0
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _PlayBuffer@8 stdcall, hSound:dword, str:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSound]
lea ecx, [str]
xor ebx, ebx
mov [handle], eax
mov [io_code], SND_PLAY
mov [input], ecx
mov [inp_size], 4
mov [output], ebx
mov [out_size], 0
lea eax, [handle]
stdcall CallServiceEx, eax
pop ebx
ret
endp
align 4
proc _StopBuffer@8 stdcall, hSound:dword, str:dword
locals
handle dd ?
io_code dd ?
input dd ?
inp_size dd ?
output dd ?
out_size dd ?
endl
push ebx
mov eax, [hSound]
lea ecx, [str]
xor ebx, ebx
mov [handle], eax
mov [io_code], SND_STOP
mov [input], ecx
mov [inp_size], 4
mov [output], ebx
mov [out_size], 0
lea eax, [handle]
stdcall CallServiceEx, eax
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 __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

109
programs/media/ac97 mp3/trunk/kolibri.h Normal file
View File

@ -0,0 +1,109 @@
//
// 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 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 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;
} FILEINFO;
void _stdcall InitHeap(int heap_size);
void* _stdcall UserAlloc(int size);
void _stdcall GetNotify(DWORD *event);
void _stdcall CreateThread(void *fn, char *p_stack);
DWORD _stdcall GetMousePos(DWORD rel_type);
int _stdcall GetService(char *srv_name);
void _stdcall GetDevInfo(DWORD hSrv,CTRL_INFO *pInfo);
int _stdcall GetMasterVol(DWORD hSrv,int* vol);
int _stdcall SetMasterVol(DWORD hSrv, int vol);
DWORD _stdcall CreateBuffer(DWORD hSrv, DWORD format);
int _stdcall DestroyBuffer(DWORD hSrv, DWORD hBuff);
int _stdcall SetBuffer(DWORD hSrv, DWORD hBuff,char* buff,
DWORD offs, int size);
int _stdcall PlayBuffer(DWORD hSrv, DWORD hBuff);
int _stdcall StopBuffer(DWORD hSrv, DWORD hBuff);
void _stdcall debug_out_hex(DWORD val);
void debug_out_str(char* str);
int _stdcall get_fileinfo(char *name,FILEINFO* pinfo);
int _stdcall read_file (char *name,char*buff,int offset,int count,int *reads);
void exit();
int get_key(void);
int 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 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);

268
programs/media/ac97 mp3/trunk/mp3dec/PROC32.INC Normal file
View File

@ -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 }

212
programs/media/ac97 mp3/trunk/mp3dec/bstream.c Normal file
View File

@ -0,0 +1,212 @@
/* max bits required for any lookup - change if htable changes */
/* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */
#define MAXBITS 9
static unsigned int bitbuf;
static int bits;
static unsigned char *bs_ptr;
static unsigned char *bs_ptr0;
static unsigned char *bs_ptr_end; // optional for overrun test
void bitget_init(unsigned char *buf)
{
bs_ptr0 = bs_ptr = buf;
bits = 0;
bitbuf = 0;
}
int bitget(int n)
{
unsigned int x;
if (bits < n)
{ /* refill bit buf if necessary */
while (bits <= 24)
{
bitbuf = (bitbuf << 8) | *bs_ptr++;
bits += 8;
}
}
bits -= n;
x = bitbuf >> bits;
bitbuf -= x << bits;
return x;
}
void bitget_skip(int n)
{
unsigned int k;
if (bits < n)
{
n -= bits;
k = n >> 3;
/*--- bytes = n/8 --*/
bs_ptr += k;
n -= k << 3;
bitbuf = *bs_ptr++;
bits = 8;
}
bits -= n;
bitbuf -= (bitbuf >> bits) << bits;
}
void bitget_init_end(unsigned char *buf_end)
{
bs_ptr_end = buf_end;
}
/*------------- check overrun -------------*/
int bitget_overrun()
{
return bs_ptr > bs_ptr_end;
}
/*------------- get n bits from bitstream -------------*/
int bitget_bits_used()
{
unsigned int n; /* compute bits used from last init call */
n = ((bs_ptr - bs_ptr0) << 3) - bits;
return n;
}
/*------------- check for n bits in bitbuf -------------*/
void bitget_check(int n)
{
if (bits < n)
{
while (bits <= 24)
{
bitbuf = (bitbuf << 8) | *bs_ptr++;
bits += 8;
}
}
}
#if 0
/*------------- get 1 bit from bitstream -------------*/
int bitget_1bit()
{
unsigned int x;
if (bits <= 0)
{ /* refill bit buf if necessary */
while (bits <= 24)
{
bitbuf = (bitbuf << 8) | *bs_ptr++;
bits += 8;
}
}
bits--;
x = bitbuf >> bits;
bitbuf -= x << bits;
return x;
}
/*------------- get 1 bit from bitstream NO CHECK -------------*/
int bitget_1bit()
{
unsigned int x;
bits--;
x = bitbuf >> bits;
bitbuf -= x << bits;
return x;
}
#endif
/* only huffman */
/*----- get n bits - checks for n+2 avail bits (linbits+sign) -----*/
int bitget_lb(int n)
{
unsigned int x;
if (bits < (n + 2))
{ /* refill bit buf if necessary */
while (bits <= 24)
{
bitbuf = (bitbuf << 8) | *bs_ptr++;
bits += 8;
}
}
bits -= n;
x = bitbuf >> bits;
bitbuf -= x << bits;
return x;
}
/*------------- get n bits but DO NOT remove from bitstream --*/
int bitget2(int n)
{
unsigned int x;
if (bits < (MAXBITS + 2))
{ /* refill bit buf if necessary */
while (bits <= 24)
{
bitbuf = (bitbuf << 8) | *bs_ptr++;
bits += 8;
}
}
x = bitbuf >> (bits - n);
return x;
}
/*------------- remove n bits from bitstream ---------*/
void bitget_purge(int n)
{
bits -= n;
bitbuf -= (bitbuf >> bits) << bits;
}
void mac_bitget_check(int n)
{
if( bits < n ) {
while( bits <= 24 ) {
bitbuf = (bitbuf << 8) | *bs_ptr++;
bits += 8;
}
}
}
int mac_bitget(int n)
{
unsigned int code;
bits -= n;
code = bitbuf >> bits;
bitbuf -= code << bits;
return code;
}
int mac_bitget2(int n)
{
return (bitbuf >> (bits-n));
}
int mac_bitget_1bit()
{
unsigned int code;
bits--;
code = bitbuf >> bits;
bitbuf -= code << bits;
return code;
}
void mac_bitget_purge(int n)
{
bits -= n;
bitbuf -= (bitbuf >> bits) << bits;
}
/*
#define mac_bitget(n) ( bits -= n, \
code = bitbuf >> bits, \
bitbuf -= code << bits, \
code )
#define mac_bitget_1bit() ( bits--, \
code = bitbuf >> bits, \
bitbuf -= code << bits, \
code )
*/

23
programs/media/ac97 mp3/trunk/mp3dec/bstream.h Normal file
View File

@ -0,0 +1,23 @@
typedef unsigned char byte;
typedef unsigned int uint;
typedef void (*SBT_PROC) (float *sample, void *pcm, int n);
typedef void (*XFORM_PROC) (void *pcm, int igr);
void bitget_init(unsigned char *buf);
void bitget_init_end(unsigned char *buf_end);
int bitget_overrun();
int bitget_bits_used();
void bitget_check(int n);
int bitget(int n);
void bitget_skip(int n);
//int bitget_1bit();
int bitget_lb(int n);
int bitget2(int n);
void bitget_purge(int n);
void mac_bitget_check(int n);
int mac_bitget(int n);
int mac_bitget_1bit();
int mac_bitget2(int n);
void mac_bitget_purge(int n);

358
programs/media/ac97 mp3/trunk/mp3dec/e_pow.c Normal file
View File

@ -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 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;
}

290
programs/media/ac97 mp3/trunk/mp3dec/fdct.c Normal file
View File

@ -0,0 +1,290 @@
#include <math.h>
static float coef32[31]; /* 32 pt dct coefs */
void fdct_init() /* gen coef for N=32 (31 coefs) */
{
int p, n, i, k;
double t, pi;
pi = 4.0 * atan(1.0);
n = 16;
k = 0;
for (i = 0; i < 5; i++, n = n / 2) {
for (p = 0; p < n; p++, k++) {
t = (pi / (4 * n)) * (2 * p + 1);
coef32[k] = (float) (0.50 / cos(t));
}
}
}
static void forward_bf(int m, int n, float x[], float f[], float coef[])
{
int i, j, n2;
int p, q, p0, k;
p0 = 0;
n2 = n >> 1;
for (i = 0; i < m; i++, p0 += n) {
k = 0;
p = p0;
q = p + n - 1;
for (j = 0; j < n2; j++, p++, q--, k++) {
f[p] = x[p] + x[q];
f[n2 + p] = coef[k] * (x[p] - x[q]);
}
}
}
/*------------------------------------------------------------*/
static void back_bf(int m, int n, float x[], float f[])
{
int i, j, n2, n21;
int p, q, p0;
p0 = 0;
n2 = n >> 1;
n21 = n2 - 1;
for (i = 0; i < m; i++, p0 += n) {
p = p0;
q = p0;
for (j = 0; j < n2; j++, p += 2, q++)
f[p] = x[q];
p = p0 + 1;
for (j = 0; j < n21; j++, p += 2, q++)
f[p] = x[q] + x[q + 1];
f[p] = x[q];
}
}
/*------------------------------------------------------------*/
extern int m_enableEQ;
extern float m_equalizer[32];
void fdct32(float x[], float c[])
{
float a[32]; /* ping pong buffers */
float b[32];
int p, q;
if (m_enableEQ) {
for (p = 0; p < 32; p++) x[p] *= m_equalizer[p];
}
/* special first stage */
for (p = 0, q = 31; p < 16; p++, q--) {
a[p] = x[p] + x[q];
a[16 + p] = coef32[p] * (x[p] - x[q]);
}
forward_bf(2, 16, a, b, coef32 + 16);
forward_bf(4, 8, b, a, coef32 + 16 + 8);
forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
back_bf(8, 4, a, b);
back_bf(4, 8, b, a);
back_bf(2, 16, a, b);
back_bf(1, 32, b, c);
}
/*------------------------------------------------------------*/
void fdct32_dual(float x[], float c[])
{
float a[32]; /* ping pong buffers */
float b[32];
int p, pp, qq;
if (m_enableEQ) {
for (p = 0; p < 32; p++) x[p] *= m_equalizer[p];
}
/* special first stage for dual chan (interleaved x) */
pp = 0;
qq = 2 * 31;
for (p = 0; p < 16; p++, pp += 2, qq -= 2)
{
a[p] = x[pp] + x[qq];
a[16 + p] = coef32[p] * (x[pp] - x[qq]);
}
forward_bf(2, 16, a, b, coef32 + 16);
forward_bf(4, 8, b, a, coef32 + 16 + 8);
forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
back_bf(8, 4, a, b);
back_bf(4, 8, b, a);
back_bf(2, 16, a, b);
back_bf(1, 32, b, c);
}
/*---------------convert dual to mono------------------------------*/
void fdct32_dual_mono(float x[], float c[])
{
float a[32]; /* ping pong buffers */
float b[32];
float t1, t2;
int p, pp, qq;
/* special first stage */
pp = 0;
qq = 2 * 31;
for (p = 0; p < 16; p++, pp += 2, qq -= 2)
{
t1 = 0.5F * (x[pp] + x[pp + 1]);
t2 = 0.5F * (x[qq] + x[qq + 1]);
a[p] = t1 + t2;
a[16 + p] = coef32[p] * (t1 - t2);
}
forward_bf(2, 16, a, b, coef32 + 16);
forward_bf(4, 8, b, a, coef32 + 16 + 8);
forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
back_bf(8, 4, a, b);
back_bf(4, 8, b, a);
back_bf(2, 16, a, b);
back_bf(1, 32, b, c);
}
/*------------------------------------------------------------*/
/*---------------- 16 pt fdct -------------------------------*/
void fdct16(float x[], float c[])
{
float a[16]; /* ping pong buffers */
float b[16];
int p, q;
/* special first stage (drop highest sb) */
a[0] = x[0];
a[8] = coef32[16] * x[0];
for (p = 1, q = 14; p < 8; p++, q--)
{
a[p] = x[p] + x[q];
a[8 + p] = coef32[16 + p] * (x[p] - x[q]);
}
forward_bf(2, 8, a, b, coef32 + 16 + 8);
forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
back_bf(4, 4, b, a);
back_bf(2, 8, a, b);
back_bf(1, 16, b, c);
}
/*------------------------------------------------------------*/
/*---------------- 16 pt fdct dual chan---------------------*/
void fdct16_dual(float x[], float c[])
{
float a[16]; /* ping pong buffers */
float b[16];
int p, pp, qq;
/* special first stage for interleaved input */
a[0] = x[0];
a[8] = coef32[16] * x[0];
pp = 2;
qq = 2 * 14;
for (p = 1; p < 8; p++, pp += 2, qq -= 2)
{
a[p] = x[pp] + x[qq];
a[8 + p] = coef32[16 + p] * (x[pp] - x[qq]);
}
forward_bf(2, 8, a, b, coef32 + 16 + 8);
forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
back_bf(4, 4, b, a);
back_bf(2, 8, a, b);
back_bf(1, 16, b, c);
}
/*------------------------------------------------------------*/
/*---------------- 16 pt fdct dual to mono-------------------*/
void fdct16_dual_mono(float x[], float c[])
{
float a[16]; /* ping pong buffers */
float b[16];
float t1, t2;
int p, pp, qq;
/* special first stage */
a[0] = 0.5F * (x[0] + x[1]);
a[8] = coef32[16] * a[0];
pp = 2;
qq = 2 * 14;
for (p = 1; p < 8; p++, pp += 2, qq -= 2)
{
t1 = 0.5F * (x[pp] + x[pp + 1]);
t2 = 0.5F * (x[qq] + x[qq + 1]);
a[p] = t1 + t2;
a[8 + p] = coef32[16 + p] * (t1 - t2);
}
forward_bf(2, 8, a, b, coef32 + 16 + 8);
forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
back_bf(4, 4, b, a);
back_bf(2, 8, a, b);
back_bf(1, 16, b, c);
}
/*------------------------------------------------------------*/
/*---------------- 8 pt fdct -------------------------------*/
void fdct8(float x[], float c[])
{
float a[8]; /* ping pong buffers */
float b[8];
int p, q;
/* special first stage */
b[0] = x[0] + x[7];
b[4] = coef32[16 + 8] * (x[0] - x[7]);
for (p = 1, q = 6; p < 4; p++, q--)
{
b[p] = x[p] + x[q];
b[4 + p] = coef32[16 + 8 + p] * (x[p] - x[q]);
}
forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
back_bf(2, 4, b, a);
back_bf(1, 8, a, c);
}
/*---------------- 8 pt fdct dual chan---------------------*/
void fdct8_dual(float x[], float c[])
{
float a[8]; /* ping pong buffers */
float b[8];
int p, pp, qq;
/* special first stage for interleaved input */
b[0] = x[0] + x[14];
b[4] = coef32[16 + 8] * (x[0] - x[14]);
pp = 2;
qq = 2 * 6;
for (p = 1; p < 4; p++, pp += 2, qq -= 2)
{
b[p] = x[pp] + x[qq];
b[4 + p] = coef32[16 + 8 + p] * (x[pp] - x[qq]);
}
forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
back_bf(2, 4, b, a);
back_bf(1, 8, a, c);
}
/*---------------- 8 pt fdct dual to mono---------------------*/
void fdct8_dual_mono(float x[], float c[])
{
float a[8]; /* ping pong buffers */
float b[8];
float t1, t2;
int p, pp, qq;
/* special first stage */
t1 = 0.5F * (x[0] + x[1]);
t2 = 0.5F * (x[14] + x[15]);
b[0] = t1 + t2;
b[4] = coef32[16 + 8] * (t1 - t2);
pp = 2;
qq = 2 * 6;
for (p = 1; p < 4; p++, pp += 2, qq -= 2)
{
t1 = 0.5F * (x[pp] + x[pp + 1]);
t2 = 0.5F * (x[qq] + x[qq + 1]);
b[p] = t1 + t2;
b[4 + p] = coef32[16 + 8 + p] * (t1 - t2);
}
forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
back_bf(2, 4, b, a);
back_bf(1, 8, a, c);
}

222
programs/media/ac97 mp3/trunk/mp3dec/imdct.c Normal file
View File

@ -0,0 +1,222 @@
#include <math.h>
/*------ 18 point xform -------*/
static float w[18];
static float w2[9];
static float coef[9][4];
static float v[6];
static float v2[3];
static float coef87;
/*
typedef struct
{
float *w;
float *w2;
void *coef;
}
IMDCT_INIT_BLOCK;
static IMDCT_INIT_BLOCK imdct_info_18 =
{w, w2, coef};
static IMDCT_INIT_BLOCK imdct_info_6 =
{v, v2, &coef87};
*/
/*=============================================================*/
void imdct_init()
{
int k, p, n;
double t, pi;
// IMDCT_INIT_BLOCK *addr;
// float *w, *w2;
// float *v, *v2, *coef87;
/*--- 18 point --*/
// addr = imdct_init_addr_18();
// w = addr->w;
// w2 = addr->w2;
// coef = addr->coef;
/*----*/
n = 18;
pi = 4.0 * atan(1.0);
t = pi / (4 * n);
for (p = 0; p < n; p++)
w[p] = (float) (2.0 * cos(t * (2 * p + 1)));
for (p = 0; p < 9; p++)
w2[p] = (float) (2.0 *cos(2 * t * (2 * p + 1)));
t = pi / (2 * n);
for (k = 0; k < 9; k++)
{
for (p = 0; p < 4; p++)
coef[k][p] = (float) (cos(t * (2 * k) * (2 * p + 1)));
}
/*--- 6 point */
// addr = imdct_init_addr_6();
// v = addr->w;
// v2 = addr->w2;
// coef87 = addr->coef;
/*----*/
n = 6;
pi = 4.0 * atan(1.0);
t = pi / (4 * n);
for (p = 0; p < n; p++)
v[p] = (float) (2.0 *cos(t * (2 * p + 1)));
for (p = 0; p < 3; p++)
v2[p] = (float) (2.0 *cos(2 * t * (2 * p + 1)));
t = pi / (2 * n);
k = 1;
p = 0;
coef87 = (float) (cos(t * (2 * k) * (2 * p + 1)));
/* adjust scaling to save a few mults */
for (p = 0; p < 6; p++)
v[p] = v[p] / 2.0f;
coef87 = (float) (2.0 * coef87);
}
/*--------------------------------------------------------------------*/
void imdct18(float f[18]) /* 18 point */
{
int p;
float a[9], b[9];
float ap, bp, a8p, b8p;
float g1, g2;
for (p = 0; p < 4; p++)
{
g1 = w[p] * f[p];
g2 = w[17 - p] * f[17 - p];
ap = g1 + g2; // a[p]
bp = w2[p] * (g1 - g2); // b[p]
g1 = w[8 - p] * f[8 - p];
g2 = w[9 + p] * f[9 + p];
a8p = g1 + g2; // a[8-p]
b8p = w2[8 - p] * (g1 - g2); // b[8-p]
a[p] = ap + a8p;
a[5 + p] = ap - a8p;
b[p] = bp + b8p;
b[5 + p] = bp - b8p;
}
g1 = w[p] * f[p];
g2 = w[17 - p] * f[17 - p];
a[p] = g1 + g2;
b[p] = w2[p] * (g1 - g2);
f[0] = 0.5f * (a[0] + a[1] + a[2] + a[3] + a[4]);
f[1] = 0.5f * (b[0] + b[1] + b[2] + b[3] + b[4]);
f[2] = coef[1][0] * a[5] + coef[1][1] * a[6] + coef[1][2] * a[7]
+ coef[1][3] * a[8];
f[3] = coef[1][0] * b[5] + coef[1][1] * b[6] + coef[1][2] * b[7]
+ coef[1][3] * b[8] - f[1];
f[1] = f[1] - f[0];
f[2] = f[2] - f[1];
f[4] = coef[2][0] * a[0] + coef[2][1] * a[1] + coef[2][2] * a[2]
+ coef[2][3] * a[3] - a[4];
f[5] = coef[2][0] * b[0] + coef[2][1] * b[1] + coef[2][2] * b[2]
+ coef[2][3] * b[3] - b[4] - f[3];
f[3] = f[3] - f[2];
f[4] = f[4] - f[3];
f[6] = coef[3][0] * (a[5] - a[7] - a[8]);
f[7] = coef[3][0] * (b[5] - b[7] - b[8]) - f[5];
f[5] = f[5] - f[4];
f[6] = f[6] - f[5];
f[8] = coef[4][0] * a[0] + coef[4][1] * a[1] + coef[4][2] * a[2]
+ coef[4][3] * a[3] + a[4];
f[9] = coef[4][0] * b[0] + coef[4][1] * b[1] + coef[4][2] * b[2]
+ coef[4][3] * b[3] + b[4] - f[7];
f[7] = f[7] - f[6];
f[8] = f[8] - f[7];
f[10] = coef[5][0] * a[5] + coef[5][1] * a[6] + coef[5][2] * a[7]
+ coef[5][3] * a[8];
f[11] = coef[5][0] * b[5] + coef[5][1] * b[6] + coef[5][2] * b[7]
+ coef[5][3] * b[8] - f[9];
f[9] = f[9] - f[8];
f[10] = f[10] - f[9];
f[12] = 0.5f * (a[0] + a[2] + a[3]) - a[1] - a[4];
f[13] = 0.5f * (b[0] + b[2] + b[3]) - b[1] - b[4] - f[11];
f[11] = f[11] - f[10];
f[12] = f[12] - f[11];
f[14] = coef[7][0] * a[5] + coef[7][1] * a[6] + coef[7][2] * a[7]
+ coef[7][3] * a[8];
f[15] = coef[7][0] * b[5] + coef[7][1] * b[6] + coef[7][2] * b[7]
+ coef[7][3] * b[8] - f[13];
f[13] = f[13] - f[12];
f[14] = f[14] - f[13];
f[16] = coef[8][0] * a[0] + coef[8][1] * a[1] + coef[8][2] * a[2]
+ coef[8][3] * a[3] + a[4];
f[17] = coef[8][0] * b[0] + coef[8][1] * b[1] + coef[8][2] * b[2]
+ coef[8][3] * b[3] + b[4] - f[15];
f[15] = f[15] - f[14];
f[16] = f[16] - f[15];
f[17] = f[17] - f[16];
}
/*--------------------------------------------------------------------*/
/* does 3, 6 pt dct. changes order from f[i][window] c[window][i] */
void imdct6_3(float f[]) /* 6 point */
{
int w;
float buf[18];
float *a, *c; // b[i] = a[3+i]
float g1, g2;
float a02, b02;
c = f;
a = buf;
for (w = 0; w < 3; w++)
{
g1 = v[0] * f[3 * 0];
g2 = v[5] * f[3 * 5];
a[0] = g1 + g2;
a[3 + 0] = v2[0] * (g1 - g2);
g1 = v[1] * f[3 * 1];
g2 = v[4] * f[3 * 4];
a[1] = g1 + g2;
a[3 + 1] = v2[1] * (g1 - g2);
g1 = v[2] * f[3 * 2];
g2 = v[3] * f[3 * 3];
a[2] = g1 + g2;
a[3 + 2] = v2[2] * (g1 - g2);
a += 6;
f++;
}
a = buf;
for (w = 0; w < 3; w++)
{
a02 = (a[0] + a[2]);
b02 = (a[3 + 0] + a[3 + 2]);
c[0] = a02 + a[1];
c[1] = b02 + a[3 + 1];
c[2] = coef87 * (a[0] - a[2]);
c[3] = coef87 * (a[3 + 0] - a[3 + 2]) - c[1];
c[1] = c[1] - c[0];
c[2] = c[2] - c[1];
c[4] = a02 - a[1] - a[1];
c[5] = b02 - a[3 + 1] - a[3 + 1] - c[3];
c[3] = c[3] - c[2];
c[4] = c[4] - c[3];
c[5] = c[5] - c[4];
a += 6;
c += 6;
}
}

202
programs/media/ac97 mp3/trunk/mp3dec/l1dec.c Normal file
View File

@ -0,0 +1,202 @@
#include "bstream.h"
#include "mp3dec.h"
extern MPEG_DECODE_OPTION m_option;
extern float m_sample[2304];
extern int m_nsb_limit;
extern SBT_PROC m_sbt_proc;
extern int m_max_sb;
extern int m_stereo_sb;
extern int m_bat[4][16];
extern int m_ballo[64];
extern unsigned int m_samp_dispatch[66];
extern float m_c_value[64];
extern unsigned int m_sf_dispatch[66];
extern float m_sf_table[64];
extern float m_cs_factor[3][64];
float m_look_c_valueL1[18];
float *m_cs_factorL1 = m_cs_factor[0];
int m_nbatL1;
int m_bit_skip;
static const int look_joint[16] =
{ /* lookup stereo sb's by mode+ext */
64, 64, 64, 64, /* stereo */
2 * 4, 2 * 8, 2 * 12, 2 * 16, /* joint */
64, 64, 64, 64, /* dual */
32, 32, 32, 32, /* mono */
};
static const int bat_bit_masterL1[] =
{
0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
};
void unpack_baL1();
void unpack_sfL1();
void unpack_sampL1();
void L1decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
{
int crc_size;
crc_size = (h->error_prot) ? 2 : 0;
bitget_init(mpeg + 4 + crc_size);
m_stereo_sb = look_joint[(h->mode << 2) + h->mode_ext];
unpack_baL1(); /* unpack bit allocation */
unpack_sfL1(); /* unpack scale factor */
unpack_sampL1(); /* unpack samples */
m_sbt_proc(m_sample, pcm, 12);
}
void unpack_baL1()
{
int j;
int nstereo;
m_bit_skip = 0;
nstereo = m_stereo_sb;
for (j = 0; j < m_nbatL1; j++)
{
bitget_check(4);
m_ballo[j] = m_samp_dispatch[j] = mac_bitget(4);
if (j >= m_nsb_limit)
m_bit_skip += bat_bit_masterL1[m_samp_dispatch[j]];
m_c_value[j] = m_look_c_valueL1[m_samp_dispatch[j]];
if (--nstereo < 0)
{
m_ballo[j + 1] = m_ballo[j];
// flag as joint
m_samp_dispatch[j] += 15;
// flag for sf
m_samp_dispatch[j + 1] = m_samp_dispatch[j];
m_c_value[j + 1] = m_c_value[j];
j++;
}
}
// terminate with bit skip and end
m_samp_dispatch[m_nsb_limit] = 31;
m_samp_dispatch[j] = 30;
}
// unpack scale factor
// combine dequant and scale factors
void unpack_sfL1()
{
int i;
for (i = 0; i < m_nbatL1; i++)
{
if (m_ballo[i])
{
bitget_check(6);
m_cs_factorL1[i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
}
}
}
// unpack samples
#define UNPACKL1_N(n) \
s[k] = m_cs_factorL1[k]*(bitget(n)-((1 << n-1) -1)); \
goto dispatch;
#define UNPACKL1J_N(n) \
tmp = (bitget(n)-((1 << n-1) -1)); \
s[k] = m_cs_factorL1[k]*tmp; \
s[k+1] = m_cs_factorL1[k+1]*tmp; \
k++; \
goto dispatch;
void unpack_sampL1()
{
int j, k;
float *s;
long tmp;
s = m_sample;
for (j = 0; j < 12; j++)
{
k = -1;
dispatch:
switch (m_samp_dispatch[++k])
{
case 0:
s[k] = 0.0F;
goto dispatch;
case 1:
UNPACKL1_N(2) /* 3 levels */
case 2:
UNPACKL1_N(3) /* 7 levels */
case 3:
UNPACKL1_N(4) /* 15 levels */
case 4:
UNPACKL1_N(5) /* 31 levels */
case 5:
UNPACKL1_N(6) /* 63 levels */
case 6:
UNPACKL1_N(7) /* 127 levels */
case 7:
UNPACKL1_N(8) /* 255 levels */
case 8:
UNPACKL1_N(9) /* 511 levels */
case 9:
UNPACKL1_N(10) /* 1023 levels */
case 10:
UNPACKL1_N(11) /* 2047 levels */
case 11:
UNPACKL1_N(12) /* 4095 levels */
case 12:
UNPACKL1_N(13) /* 8191 levels */
case 13:
UNPACKL1_N(14) /* 16383 levels */
case 14:
UNPACKL1_N(15) /* 32767 levels */
/* -- joint ---- */
case 15 + 0:
s[k + 1] = s[k] = 0.0F;
k++; /* skip right chan dispatch */
goto dispatch;
/* -- joint ---- */
case 15 + 1:
UNPACKL1J_N(2) /* 3 levels */
case 15 + 2:
UNPACKL1J_N(3) /* 7 levels */
case 15 + 3:
UNPACKL1J_N(4) /* 15 levels */
case 15 + 4:
UNPACKL1J_N(5) /* 31 levels */
case 15 + 5:
UNPACKL1J_N(6) /* 63 levels */
case 15 + 6:
UNPACKL1J_N(7) /* 127 levels */
case 15 + 7:
UNPACKL1J_N(8) /* 255 levels */
case 15 + 8:
UNPACKL1J_N(9) /* 511 levels */
case 15 + 9:
UNPACKL1J_N(10) /* 1023 levels */
case 15 + 10:
UNPACKL1J_N(11) /* 2047 levels */
case 15 + 11:
UNPACKL1J_N(12) /* 4095 levels */
case 15 + 12:
UNPACKL1J_N(13) /* 8191 levels */
case 15 + 13:
UNPACKL1J_N(14) /* 16383 levels */
case 15 + 14:
UNPACKL1J_N(15) /* 32767 levels */
/* -- end of dispatch -- */
case 31:
bitget_skip(m_bit_skip);
case 30:
s += 64;
} /* end switch */
} /* end j loop */
}

87
programs/media/ac97 mp3/trunk/mp3dec/l1init.c Normal file
View File

@ -0,0 +1,87 @@
#include "bstream.h"
#include "mp3dec.h"
#include <math.h>
extern MPEG_DECODE_OPTION m_option;
extern int m_frequency;
extern float m_sample[2304];
extern int m_nsb_limit;
extern int m_max_sb;
extern int m_stereo_sb;
extern SBT_PROC m_sbt_proc;
extern float m_look_c_valueL1[18];
extern int m_nbatL1;
//extern "sbt.c"
void sbt_mono(float *sample, signed short *pcm, int ch);
void sbt_dual(float *sample, signed short *pcm, int ch);
void sbt16_mono(float *sample, signed short *pcm, int ch);
void sbt16_dual(float *sample, signed short *pcm, int ch);
void sbt8_mono(float *sample, signed short *pcm, int ch);
void sbt8_dual(float *sample, signed short *pcm, int ch);
void sbtB_mono(float *sample, unsigned char *pcm, int ch);
void sbtB_dual(float *sample, unsigned char *pcm, int ch);
void sbtB16_mono(float *sample, unsigned char *pcm, int ch);
void sbtB16_dual(float *sample, unsigned char *pcm, int ch);
void sbtB8_mono(float *sample, unsigned char *pcm, int ch);
void sbtB8_dual(float *sample, unsigned char *pcm, int ch);
static const SBT_PROC sbt_table[2][3][2] =
{
sbt_mono,
sbt_dual,
sbt16_mono,
sbt16_dual,
sbt8_mono,
sbt8_dual,
sbtB_mono,
sbtB_dual,
sbtB16_mono,
sbtB16_dual,
sbtB8_mono,
sbtB8_dual,
};
void L1table_init()
{
int i, stepL1;
for (stepL1 = 4, i = 1; i < 16; i++, stepL1 <<= 1) {
m_look_c_valueL1[i] = (float) (2.0 / (stepL1 - 1));
}
}
int L1decode_start(MPEG_HEADER* h)
{
int i, k, bit_code, limit;
/*- caller limit -*/
m_nbatL1 = 32;
m_max_sb = m_nbatL1;
m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
/*---- limit = 0.94*(32>>reduction_code); ----*/
limit = (32 >> m_option.reduction);
if (limit > 8)
limit--;
if (m_nsb_limit > limit)
m_nsb_limit = limit;
if (m_nsb_limit > m_max_sb)
m_nsb_limit = m_max_sb;
if (h->mode != 3) { /* adjust for 2 channel modes */
m_nbatL1 *= 2;
m_max_sb *= 2;
m_nsb_limit *= 2;
}
/* set sbt function */
bit_code = (m_option.convert & 8) ? 1 : 0;
k = (h->mode == 3) ? 0 : (1 + m_option.convert);
m_sbt_proc = sbt_table[bit_code][m_option.reduction][k];//[2][3][2]
for (i = 0; i < 768; i++)
m_sample[i] = 0.0F;
return 1;
}

306
programs/media/ac97 mp3/trunk/mp3dec/l2dec.c Normal file
View File

@ -0,0 +1,306 @@
#include "bstream.h"
#include "mp3dec.h"
extern float m_sample[2304];
extern int m_nsb_limit;
int m_stereo_sb;
int m_max_sb;
SBT_PROC m_sbt_proc;
float m_sf_table[64];
float m_look_c_valueL2[18];
char m_group3_table[32][3];
char m_group5_table[128][3];
short m_group9_table[1024][3];
int m_nbat[4];// = {3, 8, 12, 7};
int m_bat[4][16];
int m_ballo[64];
uint m_samp_dispatch[66];
float m_c_value[64];
uint m_sf_dispatch[66];
float m_cs_factor[3][64];
int m_bit_skip;
static const int look_joint[16] =
{ /* lookup stereo sb's by mode+ext */
64, 64, 64, 64, /* stereo */
2 * 4, 2 * 8, 2 * 12, 2 * 16, /* joint */
64, 64, 64, 64, /* dual */
32, 32, 32, 32, /* mono */
};
static const int bat_bit_masterL2[] =
{
0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48
};
void unpack_ba();
void unpack_sfs();
void unpack_sf();
void unpack_samp();
void L2decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
{
int crc_size;
crc_size = (h->error_prot) ? 2 : 0;
bitget_init(mpeg + 4 + crc_size);
m_stereo_sb = look_joint[(h->mode << 2) + h->mode_ext];
unpack_ba(); // unpack bit allocation
unpack_sfs(); // unpack scale factor selectors
unpack_sf(); // unpack scale factor
unpack_samp(); // unpack samples
m_sbt_proc(m_sample, pcm, 36);
}
void unpack_ba()
{
int i, j, k;
int nstereo;
int nbit[4] = {4, 4, 3, 2};
m_bit_skip = 0;
nstereo = m_stereo_sb;
k = 0;
for (i = 0; i < 4; i++) {
for (j = 0; j < m_nbat[i]; j++, k++) {
bitget_check(4);
m_ballo[k] = m_samp_dispatch[k] = m_bat[i][mac_bitget(nbit[i])];
if (k >= m_nsb_limit)
m_bit_skip += bat_bit_masterL2[m_samp_dispatch[k]];
m_c_value[k] = m_look_c_valueL2[m_samp_dispatch[k]];
if (--nstereo < 0) {
m_ballo[k + 1] = m_ballo[k];
m_samp_dispatch[k] += 18; /* flag as joint */
m_samp_dispatch[k + 1] = m_samp_dispatch[k]; /* flag for sf */
m_c_value[k + 1] = m_c_value[k];
k++;
j++;
}
}
}
m_samp_dispatch[m_nsb_limit] = 37; /* terminate the dispatcher with skip */
m_samp_dispatch[k] = 36; /* terminate the dispatcher */
}
void unpack_sfs() /* unpack scale factor selectors */
{
int i;
for (i = 0; i < m_max_sb; i++) {
bitget_check(2);
if (m_ballo[i])
m_sf_dispatch[i] = mac_bitget(2);
else
m_sf_dispatch[i] = 4; /* no allo */
}
m_sf_dispatch[i] = 5; /* terminate dispatcher */
}
void unpack_sf() /* unpack scale factor */
{ /* combine dequant and scale factors */
int i;
i = -1;
dispatch:switch (m_sf_dispatch[++i])
{
case 0: /* 3 factors 012 */
bitget_check(18);
m_cs_factor[0][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
m_cs_factor[1][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
m_cs_factor[2][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
goto dispatch;
case 1: /* 2 factors 002 */
bitget_check(12);
m_cs_factor[1][i] = m_cs_factor[0][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
m_cs_factor[2][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
goto dispatch;
case 2: /* 1 factor 000 */
bitget_check(6);
m_cs_factor[2][i] = m_cs_factor[1][i] = m_cs_factor[0][i] =
m_c_value[i] * m_sf_table[mac_bitget(6)];
goto dispatch;
case 3: /* 2 factors 022 */
bitget_check(12);
m_cs_factor[0][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
m_cs_factor[2][i] = m_cs_factor[1][i] = m_c_value[i] * m_sf_table[mac_bitget(6)];
goto dispatch;
case 4: /* no allo */
/*-- m_cs_factor[2][i] = m_cs_factor[1][i] = m_cs_factor[0][i] = 0.0; --*/
goto dispatch;
case 5: /* all done */
;
} /* end switch */
}
/*-------------------------------------------------------------------------*/
#define UNPACK_N(n) s[k] = m_cs_factor[i][k]*(bitget(n)-((1 << n-1) -1)); \
s[k+64] = m_cs_factor[i][k]*(bitget(n)-((1 << n-1) -1)); \
s[k+128] = m_cs_factor[i][k]*(bitget(n)-((1 << n-1) -1)); \
goto dispatch;
#define UNPACK_N2(n) bitget_check(3*n); \
s[k] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
s[k+64] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
s[k+128] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
goto dispatch;
#define UNPACK_N3(n) bitget_check(2*n); \
s[k] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
s[k+64] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
bitget_check(n); \
s[k+128] = m_cs_factor[i][k]*(mac_bitget(n)-((1 << n-1) -1)); \
goto dispatch;
#define UNPACKJ_N(n) tmp = (bitget(n)-((1 << n-1) -1)); \
s[k] = m_cs_factor[i][k]*tmp; \
s[k+1] = m_cs_factor[i][k+1]*tmp; \
tmp = (bitget(n)-((1 << n-1) -1)); \
s[k+64] = m_cs_factor[i][k]*tmp; \
s[k+64+1] = m_cs_factor[i][k+1]*tmp; \
tmp = (bitget(n)-((1 << n-1) -1)); \
s[k+128] = m_cs_factor[i][k]*tmp; \
s[k+128+1] = m_cs_factor[i][k+1]*tmp; \
k++; /* skip right chan dispatch */ \
goto dispatch;
/*-------------------------------------------------------------------------*/
void unpack_samp() /* unpack samples */
{
int i, j, k;
float *s;
int n;
long tmp;
s = m_sample;
for (i = 0; i < 3; i++)
{ /* 3 groups of scale factors */
for (j = 0; j < 4; j++)
{
k = -1;
dispatch:switch (m_samp_dispatch[++k])
{
case 0:
s[k + 128] = s[k + 64] = s[k] = 0.0F;
goto dispatch;
case 1: /* 3 levels grouped 5 bits */
bitget_check(5);
n = mac_bitget(5);
s[k] = m_cs_factor[i][k] * m_group3_table[n][0];
s[k + 64] = m_cs_factor[i][k] * m_group3_table[n][1];
s[k + 128] = m_cs_factor[i][k] * m_group3_table[n][2];
goto dispatch;
case 2: /* 5 levels grouped 7 bits */
bitget_check(7);
n = mac_bitget(7);
s[k] = m_cs_factor[i][k] * m_group5_table[n][0];
s[k + 64] = m_cs_factor[i][k] * m_group5_table[n][1];
s[k + 128] = m_cs_factor[i][k] * m_group5_table[n][2];
goto dispatch;
case 3:
UNPACK_N2(3) /* 7 levels */
case 4: /* 9 levels grouped 10 bits */
bitget_check(10);
n = mac_bitget(10);
s[k] = m_cs_factor[i][k] * m_group9_table[n][0];
s[k + 64] = m_cs_factor[i][k] * m_group9_table[n][1];
s[k + 128] = m_cs_factor[i][k] * m_group9_table[n][2];
goto dispatch;
case 5:
UNPACK_N2(4) /* 15 levels */
case 6:
UNPACK_N2(5) /* 31 levels */
case 7:
UNPACK_N2(6) /* 63 levels */
case 8:
UNPACK_N2(7) /* 127 levels */
case 9:
UNPACK_N2(8) /* 255 levels */
case 10:
UNPACK_N3(9) /* 511 levels */
case 11:
UNPACK_N3(10) /* 1023 levels */
case 12:
UNPACK_N3(11) /* 2047 levels */
case 13:
UNPACK_N3(12) /* 4095 levels */
case 14:
UNPACK_N(13) /* 8191 levels */
case 15:
UNPACK_N(14) /* 16383 levels */
case 16:
UNPACK_N(15) /* 32767 levels */
case 17:
UNPACK_N(16) /* 65535 levels */
/* -- joint ---- */
case 18 + 0:
s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0.0F;
k++; /* skip right chan dispatch */
goto dispatch;
case 18 + 1: /* 3 levels grouped 5 bits */
n = bitget(5);
s[k] = m_cs_factor[i][k] * m_group3_table[n][0];
s[k + 1] = m_cs_factor[i][k + 1] * m_group3_table[n][0];
s[k + 64] = m_cs_factor[i][k] * m_group3_table[n][1];
s[k + 64 + 1] = m_cs_factor[i][k + 1] * m_group3_table[n][1];
s[k + 128] = m_cs_factor[i][k] * m_group3_table[n][2];
s[k + 128 + 1] = m_cs_factor[i][k + 1] * m_group3_table[n][2];
k++; /* skip right chan dispatch */
goto dispatch;
case 18 + 2: /* 5 levels grouped 7 bits */
n = bitget(7);
s[k] = m_cs_factor[i][k] * m_group5_table[n][0];
s[k + 1] = m_cs_factor[i][k + 1] * m_group5_table[n][0];
s[k + 64] = m_cs_factor[i][k] * m_group5_table[n][1];
s[k + 64 + 1] = m_cs_factor[i][k + 1] * m_group5_table[n][1];
s[k + 128] = m_cs_factor[i][k] * m_group5_table[n][2];
s[k + 128 + 1] = m_cs_factor[i][k + 1] * m_group5_table[n][2];
k++; /* skip right chan dispatch */
goto dispatch;
case 18 + 3:
UNPACKJ_N(3) /* 7 levels */
case 18 + 4: /* 9 levels grouped 10 bits */
n = bitget(10);
s[k] = m_cs_factor[i][k] * m_group9_table[n][0];
s[k + 1] = m_cs_factor[i][k + 1] * m_group9_table[n][0];
s[k + 64] = m_cs_factor[i][k] * m_group9_table[n][1];
s[k + 64 + 1] = m_cs_factor[i][k + 1] * m_group9_table[n][1];
s[k + 128] = m_cs_factor[i][k] * m_group9_table[n][2];
s[k + 128 + 1] = m_cs_factor[i][k + 1] * m_group9_table[n][2];
k++; /* skip right chan dispatch */
goto dispatch;
case 18 + 5:
UNPACKJ_N(4) /* 15 levels */
case 18 + 6:
UNPACKJ_N(5) /* 31 levels */
case 18 + 7:
UNPACKJ_N(6) /* 63 levels */
case 18 + 8:
UNPACKJ_N(7) /* 127 levels */
case 18 + 9:
UNPACKJ_N(8) /* 255 levels */
case 18 + 10:
UNPACKJ_N(9) /* 511 levels */
case 18 + 11:
UNPACKJ_N(10) /* 1023 levels */
case 18 + 12:
UNPACKJ_N(11) /* 2047 levels */
case 18 + 13:
UNPACKJ_N(12) /* 4095 levels */
case 18 + 14:
UNPACKJ_N(13) /* 8191 levels */
case 18 + 15:
UNPACKJ_N(14) /* 16383 levels */
case 18 + 16:
UNPACKJ_N(15) /* 32767 levels */
case 18 + 17:
UNPACKJ_N(16) /* 65535 levels */
/* -- end of dispatch -- */
case 37:
bitget_skip(m_bit_skip);
case 36:
s += 3 * 64;
} /* end switch */
} /* end j loop */
} /* end i loop */
}

205
programs/media/ac97 mp3/trunk/mp3dec/l2init.c Normal file
View File

@ -0,0 +1,205 @@
#include "bstream.h"
#include "mp3dec.h"
#include <math.h>
extern MPEG_DECODE_OPTION m_option;
extern int m_frequency;
extern float m_sample[2304];
extern int m_nsb_limit;
extern int m_max_sb;
extern SBT_PROC m_sbt_proc;
extern float m_sf_table[64];
extern float m_look_c_valueL2[18];
extern char m_group3_table[32][3];
extern char m_group5_table[128][3];
extern short m_group9_table[1024][3];
extern int m_nbat[4];// = {3, 8, 12, 7};
extern int m_bat[4][16];
/* ABCD_INDEX = lookqt[mode][sr_index][br_index] */
/* -1 = invalid */
static const char lookqt[4][3][16] =
{
1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 44ks stereo */
0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, /* 48ks */
1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 32ks */
1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 44ks joint stereo */
0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, /* 48ks */
1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 32ks */
1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 44ks dual chan */
0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, /* 48ks */
1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, /* 32ks */
// mono extended beyond legal br index
// 1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1, /* 44ks single chan */
// 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1, /* 48ks */
// 1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1, /* 32ks */
// legal mono
1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* 44ks single chan */
0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, /* 48ks */
1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, /* 32ks */
};
/* bit allocation table look up */
/* table per mpeg spec tables 3b2a/b/c/d /e is mpeg2 */
/* look_bat[abcd_index][4][16] */
static const unsigned char look_bat[5][4][16] =
{
/* LOOK_BATA */
0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17,
0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* LOOK_BATB */
0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17,
0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* LOOK_BATC */
0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* LOOK_BATD */
0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* LOOK_BATE */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
/* look_nbat[abcd_index]][4] */
static const unsigned char look_nbat[5][4] =
{
3, 8, 12, 4,
3, 8, 12, 7,
2, 0, 6, 0,
2, 0, 10, 0,
4, 0, 7, 19,
};
//extern "sbt.c"
void sbt_mono(float *sample, signed short *pcm, int ch);
void sbt_dual(float *sample, signed short *pcm, int ch);
void sbt16_mono(float *sample, signed short *pcm, int ch);
void sbt16_dual(float *sample, signed short *pcm, int ch);
void sbt8_mono(float *sample, signed short *pcm, int ch);
void sbt8_dual(float *sample, signed short *pcm, int ch);
void sbtB_mono(float *sample, unsigned char *pcm, int ch);
void sbtB_dual(float *sample, unsigned char *pcm, int ch);
void sbtB16_mono(float *sample, unsigned char *pcm, int ch);
void sbtB16_dual(float *sample, unsigned char *pcm, int ch);
void sbtB8_mono(float *sample, unsigned char *pcm, int ch);
void sbtB8_dual(float *sample, unsigned char *pcm, int ch);
static const SBT_PROC sbt_table[2][3][2] =
{
sbt_mono,
sbt_dual,
sbt16_mono,
sbt16_dual,
sbt8_mono,
sbt8_dual,
sbtB_mono,
sbtB_dual,
sbtB16_mono,
sbtB16_dual,
sbtB8_mono,
sbtB8_dual,
};
void L2table_init()
{
int i, j, code;
long stepL2[18] = {
0, 3, 5, 7, 9, 15, 31, 63, 127,
255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535
};
//c_values (dequant)
for (i = 1; i < 18; i++) {
m_look_c_valueL2[i] = 2.0F / stepL2[i];
}
//scale factor table, scale by 32768 for 16 pcm output
for (i = 0; i < 64; i++) {
m_sf_table[i] = (float) (32768.0 * 2.0 * pow_test(2.0, -i / 3.0));
}
//grouped 3 level lookup table 5 bit token
for (i = 0; i < 32; i++) {
code = i;
for (j = 0; j < 3; j++) {
m_group3_table[i][j] = (char) ((code % 3) - 1);
code /= 3;
}
}
//grouped 5 level lookup table 7 bit token
for (i = 0; i < 128; i++) {
code = i;
for (j = 0; j < 3; j++) {
m_group5_table[i][j] = (char) ((code % 5) - 2);
code /= 5;
}
}
//grouped 9 level lookup table 10 bit token
for (i = 0; i < 1024; i++) {
code = i;
for (j = 0; j < 3; j++) {
m_group9_table[i][j] = (short) ((code % 9) - 4);
code /= 9;
}
}
}
int L2decode_start(MPEG_HEADER* h)
{
int i, j, k, bit_code, limit;
int abcd_index;
// compute abcd index for bit allo table selection
if (h->version == 1) // MPEG-1
abcd_index = lookqt[h->mode][h->fr_index][h->br_index];
else
abcd_index = 4; // MPEG-2, MPEG-2.5
if (abcd_index < 0)
return 0; // fail invalid Layer II bit rate index
for (i = 0; i < 4; i++) {
m_nbat[i] = look_nbat[abcd_index][i];
for (j = 0; j < 16; j++) {
m_bat[i][j] = look_bat[abcd_index][i][j];
}
}
m_max_sb = m_nbat[0] + m_nbat[1] + m_nbat[2] + m_nbat[3];
// compute nsb_limit
m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
// caller limit
// limit = 0.94*(32>>reduction_code);
limit = (32 >> m_option.reduction);
if (limit > 8)
limit--;
if (m_nsb_limit > limit)
m_nsb_limit = limit;
if (m_nsb_limit > m_max_sb)
m_nsb_limit = m_max_sb;
if (h->mode != 3) {
// adjust for 2 channel modes
for (i = 0; i < 4; i++)
m_nbat[i] *= 2;
m_max_sb *= 2;
m_nsb_limit *= 2;
}
// set sbt function
bit_code = (m_option.convert & 8) ? 1 : 0;
k = (h->mode == 3) ? 0 : (1 + m_option.convert);
m_sbt_proc = sbt_table[bit_code][m_option.reduction][k];//[2][3][2]
// clear sample buffer, unused sub bands must be 0
for (i = 0; i < 2304; i++)
m_sample[i] = 0.0F;
return 1;
}

38
programs/media/ac97 mp3/trunk/mp3dec/l3alias.c Normal file
View File

@ -0,0 +1,38 @@
#include <math.h> //sqrt
static float csa[8][2]; /* antialias */
void alias_init()
{
float Ci[8] =
{
-0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f
};
int i;
for (i = 0; i < 8; i++)
{
csa[i][0] = (float) (1.0 / sqrt(1.0 + Ci[i] * Ci[i]));
csa[i][1] = (float) (Ci[i] / sqrt(1.0 + Ci[i] * Ci[i]));
}
}
void antialias(float x[], int n)
{
int i, k;
float a, b;
for (k = 0; k < n; k++)
{
for (i = 0; i < 8; i++)
{
a = x[17 - i];
b = x[18 + i];
x[17 - i] = a * csa[i][0] - b * csa[i][1];
x[18 + i] = b * csa[i][0] + a * csa[i][1];
}
x += 18;
}
}

350
programs/media/ac97 mp3/trunk/mp3dec/l3dec.c Normal file
View File

@ -0,0 +1,350 @@
#include "layer3.h"
#include <string.h>
#include <math.h>
#ifndef min
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
extern int m_frame_size, m_pcm_size;
// shared
SAMPLE m_sample[2][2][576];//- sample union of int/float sample[ch][gr][576]
int m_nsb_limit;
SBT_PROC m_sbt_proc;
XFORM_PROC m_xform_proc;
int m_channels; //(mode == 3) ? 1 : 2
int m_ms_mode, m_is_mode;
int m_sfBandIndex[2][22];// [long/short][cb]
int m_nBand[2][22];
int m_band_limit;
int m_band_limit21; // limit for sf band 21
int m_band_limit12; // limit for sf band 12 short
int m_band_limit_nsb;
int m_ncbl_mixed;
SIDE_INFO m_side_info;
SCALE_FACTOR m_scale_fac[2][2]; // [gr][ch]
CB_INFO m_cb_info[2][2]; // [gr][ch]
IS_SF_INFO m_is_sf_info;
#define NBUF (8*1024)
#define BUF_TRIGGER (NBUF-1500)
int m_gr;
int m_main_pos_bit;
byte m_buf[NBUF];
int m_buf_ptr0, m_buf_ptr1;
int m_nsamp[2][2]; // must start = 0, for m_nsamp[igr_prev]
float m_yout[576]; // hybrid out, sbt in
//extern "l3side.c"
int L3get_side_info1();
int L3get_side_info2(int gr);
//extern "l3sf.c"
void L3get_scale_factor1(int gr, int ch);
void L3get_scale_factor2(int gr, int ch);
void huffman(void *xy, int n, int ntable);
int huffman_quad(void *vwxy, int n, int nbits, int ntable);
void dequant(SAMPLE sample[], int gr, int ch);
void antialias(void *x, int n);
void ms_process(void *x, int n);
void is_process1(void *x, SCALE_FACTOR* sf,
CB_INFO cb_info[2], int nsamp);
void is_process2(void *x, SCALE_FACTOR * sf,
CB_INFO cb_info[2], int nsamp);
//extern "l3hybrid.c"
int hybrid(void *xin, void *xprev, float *y,
int btype, int nlong, int ntot, int nprev);
int hybrid_sum(void *xin, void *xin_left, float *y,
int btype, int nlong, int ntot);
void sum_f_bands(void *a, void *b, int n);
void freq_invert(float *y, int n); /* xform, */
void L3decode_main(MPEG_HEADER* h, byte *pcm, int gr);
void L3decode_reset()
{
m_buf_ptr0 = m_buf_ptr1 = 0;
}
void L3decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
{
int crc_size, side_size;
int copy_size;
if (h->mode == 1) {
m_ms_mode = h->mode_ext >> 1;
m_is_mode = h->mode_ext & 1;
}
else {
m_ms_mode = 0;
m_is_mode = 0;
}
crc_size = (h->error_prot) ? 2 : 0;
bitget_init(mpeg + 4 + crc_size);
if (h->version == 1)
side_size = L3get_side_info1();
else
side_size = L3get_side_info2(m_gr);
m_buf_ptr0 = m_buf_ptr1 - m_side_info.main_data_begin;/* decode start point */
if (m_buf_ptr1 > BUF_TRIGGER) { /* shift buffer */
memmove(m_buf, m_buf + m_buf_ptr0, m_side_info.main_data_begin);
m_buf_ptr0 = 0;
m_buf_ptr1 = m_side_info.main_data_begin;
}
copy_size = m_frame_size - (4 + crc_size + side_size);
//24/02/02 X-MaD
if (copy_size < 0) { copy_size = copy_size * -1; }
//if (copy_size < 0) { copy_size = 0; }
//__try {
memmove(m_buf + m_buf_ptr1, mpeg + (4 + crc_size + side_size), copy_size);
//} __except(0){
// m_buf_ptr1 = 0;
//}
m_buf_ptr1 += copy_size;
//24/02/02 X-MaD
if (m_buf_ptr0 >= 0) {
m_main_pos_bit = m_buf_ptr0 << 3;
if (h->version == 1) {
L3decode_main(h, pcm, 0);
L3decode_main(h, pcm + (m_pcm_size / 2), 1);
}
else {
L3decode_main(h, pcm, m_gr);
m_gr = m_gr ^ 1;
}
}
}
void L3decode_main(MPEG_HEADER* h, byte *pcm, int gr)
{
int ch;
int n1, n2, n3, n4, nn2, nn3, nn4;
int bit0, qbits, m0;
for (ch = 0; ch < m_channels; ch ++) {
bitget_init(m_buf + (m_main_pos_bit >> 3));
bit0 = (m_main_pos_bit & 7);
if (bit0) bitget(bit0);
m_main_pos_bit += m_side_info.gr[gr][ch].part2_3_length;
bitget_init_end(m_buf + ((m_main_pos_bit + 39) >> 3));
// scale factors
if (h->version == 1)
L3get_scale_factor1(gr, ch);
else
L3get_scale_factor2(gr, ch);
// huff data
n1 = m_sfBandIndex[0][m_side_info.gr[gr][ch].region0_count];
n2 = m_sfBandIndex[0][m_side_info.gr[gr][ch].region0_count
+ m_side_info.gr[gr][ch].region1_count + 1];
n3 = m_side_info.gr[gr][ch].big_values;
n3 = n3 + n3;
if (n3 > m_band_limit) n3 = m_band_limit;
if (n2 > n3) n2 = n3;
if (n1 > n3) n1 = n3;
nn3 = n3 - n2;
nn2 = n2 - n1;
huffman(m_sample[ch][gr], n1, m_side_info.gr[gr][ch].table_select[0]);
huffman(m_sample[ch][gr] + n1, nn2, m_side_info.gr[gr][ch].table_select[1]);
huffman(m_sample[ch][gr] + n2, nn3, m_side_info.gr[gr][ch].table_select[2]);
qbits = m_side_info.gr[gr][ch].part2_3_length - (bitget_bits_used() - bit0);
nn4 = huffman_quad(m_sample[ch][gr] + n3, m_band_limit - n3, qbits,
m_side_info.gr[gr][ch].count1table_select);
n4 = n3 + nn4;
m_nsamp[gr][ch] = n4;
// limit n4 or allow deqaunt to sf band 22
if (m_side_info.gr[gr][ch].block_type == 2)
n4 = min(n4, m_band_limit12);
else
n4 = min(n4, m_band_limit21);
if (n4 < 576)
memset(m_sample[ch][gr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
if (bitget_overrun())
memset(m_sample[ch][gr], 0, sizeof(SAMPLE) * (576));
}
// dequant
for (ch = 0; ch < m_channels; ch++) {
dequant(m_sample[ch][gr], gr, ch);
}
// ms stereo processing
if (m_ms_mode) {
if (m_is_mode == 0) {
m0 = m_nsamp[gr][0]; // process to longer of left/right
if (m0 < m_nsamp[gr][1])
m0 = m_nsamp[gr][1];
}
else {// process to last cb in right
m0 = m_sfBandIndex[m_cb_info[gr][1].cbtype][m_cb_info[gr][1].cbmax];
}
ms_process(m_sample[0][gr], m0);
}
// is stereo processing
if (m_is_mode) {
if (h->version == 1)
is_process1(m_sample[0][gr], &m_scale_fac[gr][1],
m_cb_info[gr], m_nsamp[gr][0]);
else
is_process2(m_sample[0][gr], &m_scale_fac[gr][1],
m_cb_info[gr], m_nsamp[gr][0]);
}
// adjust ms and is modes to max of left/right
if (m_ms_mode || m_is_mode) {
if (m_nsamp[gr][0] < m_nsamp[gr][1])
m_nsamp[gr][0] = m_nsamp[gr][1];
else
m_nsamp[gr][1] = m_nsamp[gr][0];
}
// antialias
for (ch = 0; ch < m_channels; ch ++) {
if (m_cb_info[gr][ch].ncbl == 0)
continue; // have no long blocks
if (m_side_info.gr[gr][ch].mixed_block_flag)
n1 = 1; // 1 -> 36 samples
else
n1 = (m_nsamp[gr][ch] + 7) / 18;
if (n1 > 31)
n1 = 31;
antialias(m_sample[ch][gr], n1);
n1 = 18 * n1 + 8; // update number of samples
if (n1 > m_nsamp[gr][ch])
m_nsamp[gr][ch] = n1;
}
// hybrid + sbt
m_xform_proc(pcm, gr);
}
void xform_mono(void *pcm, int igr)
{
int igr_prev, n1, n2;
// hybrid + sbt
n1 = n2 = m_nsamp[igr][0]; // total number bands
if (m_side_info.gr[igr][0].block_type == 2) { // long bands
if (m_side_info.gr[igr][0].mixed_block_flag)
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
else
n1 = 0;
}
if (n1 > m_band_limit)
n1 = m_band_limit;
if (n2 > m_band_limit)
n2 = m_band_limit;
igr_prev = igr ^ 1;
m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
freq_invert(m_yout, m_nsamp[igr][0]);
m_sbt_proc(m_yout, pcm, 0);
}
void xform_dual_right(void *pcm, int igr)
{
int igr_prev, n1, n2;
// hybrid + sbt
n1 = n2 = m_nsamp[igr][1]; // total number bands
if (m_side_info.gr[igr][1].block_type == 2) { // long bands
if (m_side_info.gr[igr][1].mixed_block_flag)
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
else
n1 = 0;
}
if (n1 > m_band_limit)
n1 = m_band_limit;
if (n2 > m_band_limit)
n2 = m_band_limit;
igr_prev = igr ^ 1;
m_nsamp[igr][1] = hybrid(m_sample[1][igr], m_sample[1][igr_prev],
m_yout, m_side_info.gr[igr][1].block_type, n1, n2, m_nsamp[igr_prev][1]);
freq_invert(m_yout, m_nsamp[igr][1]);
m_sbt_proc(m_yout, pcm, 0);
}
void xform_dual(void *pcm, int igr)
{
int ch;
int igr_prev, n1, n2;
// hybrid + sbt
igr_prev = igr ^ 1;
for (ch = 0; ch < m_channels; ch++) {
n1 = n2 = m_nsamp[igr][ch]; // total number bands
if (m_side_info.gr[igr][ch].block_type == 2) { // long bands
if (m_side_info.gr[igr][ch].mixed_block_flag)
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
else
n1 = 0;
}
if (n1 > m_band_limit)
n1 = m_band_limit;
if (n2 > m_band_limit)
n2 = m_band_limit;
m_nsamp[igr][ch] = hybrid(m_sample[ch][igr], m_sample[ch][igr_prev],
m_yout, m_side_info.gr[igr][ch].block_type, n1, n2, m_nsamp[igr_prev][ch]);
freq_invert(m_yout, m_nsamp[igr][ch]);
m_sbt_proc(m_yout, pcm, ch);
}
}
void xform_dual_mono(void *pcm, int igr)
{
int igr_prev, n1, n2, n3;
// hybrid + sbt
igr_prev = igr ^ 1;
if ((m_side_info.gr[igr][0].block_type == m_side_info.gr[igr][1].block_type)
&& (m_side_info.gr[igr][0].mixed_block_flag == 0)
&& (m_side_info.gr[igr][1].mixed_block_flag == 0)) {
n2 = m_nsamp[igr][0]; // total number bands max of L R
if (n2 < m_nsamp[igr][1])
n2 = m_nsamp[igr][1];
if (n2 > m_band_limit)
n2 = m_band_limit;
if (m_side_info.gr[igr][0].block_type == 2)
n1 = 0;
else
n1 = n2; // n1 = number long bands
sum_f_bands(m_sample[0][igr], m_sample[1][igr], n2);
n3 = m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
}
else { // transform and then sum (not tested - never happens in test)
// left chan
n1 = n2 = m_nsamp[igr][0]; // total number bands
if (m_side_info.gr[igr][0].block_type == 2) { // long bands
if (m_side_info.gr[igr][0].mixed_block_flag)
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
else
n1 = 0;
}
n3 = m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
// right chan
n1 = n2 = m_nsamp[igr][1]; // total number bands
if (m_side_info.gr[igr][1].block_type == 2) { // long bands
if (m_side_info.gr[igr][1].mixed_block_flag)
n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
else
n1 = 0;
}
m_nsamp[igr][1] = hybrid_sum(m_sample[1][igr], m_sample[0][igr],
m_yout, m_side_info.gr[igr][1].block_type, n1, n2);
if (n3 < m_nsamp[igr][1])
n1 = m_nsamp[igr][1];
}
freq_invert(m_yout, n3);
m_sbt_proc(m_yout, pcm, 0);
}

359
programs/media/ac97 mp3/trunk/mp3dec/l3huff.c Normal file
View File

@ -0,0 +1,359 @@
#include "layer3.h"
#include "l3huff.h"
//#ifdef _MSC_VER
//#pragma warning(disable: 4505)
//#endif
/*===============================================================*/
/* max bits required for any lookup - change if htable changes */
/* quad required 10 bit w/signs must have (MAXBITS+2) >= 10 */
#define MAXBITS 9
static HUFF_ELEMENT huff_table_0[] =
{0, 0, 0, 64}; /* dummy must not use */
/*-- 6 bit lookup (purgebits, value) --*/
static unsigned char quad_table_a[][2] =
{
6, 11, 6, 15, 6, 13, 6, 14, 6, 7, 6, 5, 5, 9,
5, 9, 5, 6, 5, 6, 5, 3, 5, 3, 5, 10, 5, 10,
5, 12, 5, 12, 4, 2, 4, 2, 4, 2, 4, 2, 4, 1,
4, 1, 4, 1, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4,
4, 8, 4, 8, 4, 8, 4, 8, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0,
};
typedef struct
{
HUFF_ELEMENT *table;
int linbits;
int ncase;
}
HUFF_SETUP;
#define no_bits 0
#define one_shot 1
#define no_linbits 2
#define have_linbits 3
#define quad_a 4
#define quad_b 5
static HUFF_SETUP table_look[] =
{
huff_table_0, 0, no_bits,
huff_table_1, 0, one_shot,
huff_table_2, 0, one_shot,
huff_table_3, 0, one_shot,
huff_table_0, 0, no_bits,
huff_table_5, 0, one_shot,
huff_table_6, 0, one_shot,
huff_table_7, 0, no_linbits,
huff_table_8, 0, no_linbits,
huff_table_9, 0, no_linbits,
huff_table_10, 0, no_linbits,
huff_table_11, 0, no_linbits,
huff_table_12, 0, no_linbits,
huff_table_13, 0, no_linbits,
huff_table_0, 0, no_bits,
huff_table_15, 0, no_linbits,
huff_table_16, 1, have_linbits,
huff_table_16, 2, have_linbits,
huff_table_16, 3, have_linbits,
huff_table_16, 4, have_linbits,
huff_table_16, 6, have_linbits,
huff_table_16, 8, have_linbits,
huff_table_16, 10, have_linbits,
huff_table_16, 13, have_linbits,
huff_table_24, 4, have_linbits,
huff_table_24, 5, have_linbits,
huff_table_24, 6, have_linbits,
huff_table_24, 7, have_linbits,
huff_table_24, 8, have_linbits,
huff_table_24, 9, have_linbits,
huff_table_24, 11, have_linbits,
huff_table_24, 13, have_linbits,
huff_table_0, 0, quad_a,
huff_table_0, 0, quad_b,
};
/*========================================================*/
void huffman(int xy[][2], int n, int ntable)
{
int i;
HUFF_ELEMENT *t;
HUFF_ELEMENT *t0;
int linbits;
int bits;
int code;
int x, y;
if (n <= 0)
return;
n = n >> 1; /* huff in pairs */
/*-------------*/
t0 = table_look[ntable].table;
linbits = table_look[ntable].linbits;
switch (table_look[ntable].ncase)
{
default:
/*------------------------------------------*/
case no_bits:
/*- table 0, no data, x=y=0--*/
for (i = 0; i < n; i++)
{
xy[i][0] = 0;
xy[i][1] = 0;
}
return;
/*------------------------------------------*/
case one_shot:
/*- single lookup, no escapes -*/
for (i = 0; i < n; i++)
{
mac_bitget_check((MAXBITS + 2));
bits = t0[0].b.signbits;
code = mac_bitget2(bits);
mac_bitget_purge(t0[1 + code].b.purgebits);
x = t0[1 + code].b.x;
y = t0[1 + code].b.y;
if (x)
if (mac_bitget_1bit())
x = -x;
if (y)
if (mac_bitget_1bit())
y = -y;
xy[i][0] = x;
xy[i][1] = y;
if (bitget_overrun())
break; // bad data protect
}
return;
/*------------------------------------------*/
case no_linbits:
for (i = 0; i < n; i++)
{
t = t0;
for (;;)
{
mac_bitget_check((MAXBITS + 2));
bits = t[0].b.signbits;
code = mac_bitget2(bits);
if (t[1 + code].b.purgebits)
break;
t += t[1 + code].ptr; /* ptr include 1+code */
mac_bitget_purge(bits);
}
mac_bitget_purge(t[1 + code].b.purgebits);
x = t[1 + code].b.x;
y = t[1 + code].b.y;
if (x)
if (mac_bitget_1bit())
x = -x;
if (y)
if (mac_bitget_1bit())
y = -y;
xy[i][0] = x;
xy[i][1] = y;
if (bitget_overrun())
break; // bad data protect
}
return;
/*------------------------------------------*/
case have_linbits:
for (i = 0; i < n; i++)
{
t = t0;
for (;;)
{
bits = t[0].b.signbits;
code = bitget2(bits);
if (t[1 + code].b.purgebits)
break;
t += t[1 + code].ptr; /* ptr includes 1+code */
mac_bitget_purge(bits);
}
mac_bitget_purge(t[1 + code].b.purgebits);
x = t[1 + code].b.x;
y = t[1 + code].b.y;
if (x == 15)
x += bitget_lb(linbits);
if (x)
if (mac_bitget_1bit())
x = -x;
if (y == 15)
y += bitget_lb(linbits);
if (y)
if (mac_bitget_1bit())
y = -y;
xy[i][0] = x;
xy[i][1] = y;
if (bitget_overrun())
break; // bad data protect
}
return;
}
/*--- end switch ---*/
}
int huffman_quad(int vwxy[][4], int n, int nbits, int ntable)
{
int i;
int code;
int x, y, v, w;
int tmp;
int i_non_zero, tmp_nz;
tmp_nz = 15;
i_non_zero = -1;
n = n >> 2; /* huff in quads */
if (ntable)
goto case_quad_b;
/* case_quad_a: */
for (i = 0; i < n; i++)
{
if (nbits <= 0)
break;
mac_bitget_check(10);
code = mac_bitget2(6);
nbits -= quad_table_a[code][0];
mac_bitget_purge(quad_table_a[code][0]);
tmp = quad_table_a[code][1];
if (tmp)
{
i_non_zero = i;
tmp_nz = tmp;
}
v = (tmp >> 3) & 1;
w = (tmp >> 2) & 1;
x = (tmp >> 1) & 1;
y = tmp & 1;
if (v)
{
if (mac_bitget_1bit())
v = -v;
nbits--;
}
if (w)
{
if (mac_bitget_1bit())
w = -w;
nbits--;
}
if (x)
{
if (mac_bitget_1bit())
x = -x;
nbits--;
}
if (y)
{
if (mac_bitget_1bit())
y = -y;
nbits--;
}
vwxy[i][0] = v;
vwxy[i][1] = w;
vwxy[i][2] = x;
vwxy[i][3] = y;
if (bitget_overrun())
break; // bad data protect
}
if (nbits < 0)
{
i--;
vwxy[i][0] = 0;
vwxy[i][1] = 0;
vwxy[i][2] = 0;
vwxy[i][3] = 0;
}
i_non_zero = (i_non_zero + 1) << 2;
if ((tmp_nz & 3) == 0)
i_non_zero -= 2;
return i_non_zero;
/*--------------------*/
case_quad_b:
for (i = 0; i < n; i++)
{
if (nbits < 4)
break;
nbits -= 4;
mac_bitget_check(8);
tmp = mac_bitget(4) ^ 15; /* one's complement of bitstream */
if (tmp)
{
i_non_zero = i;
tmp_nz = tmp;
}
v = (tmp >> 3) & 1;
w = (tmp >> 2) & 1;
x = (tmp >> 1) & 1;
y = tmp & 1;
if (v)
{
if (mac_bitget_1bit())
v = -v;
nbits--;
}
if (w)
{
if (mac_bitget_1bit())
w = -w;
nbits--;
}
if (x)
{
if (mac_bitget_1bit())
x = -x;
nbits--;
}
if (y)
{
if (mac_bitget_1bit())
y = -y;
nbits--;
}
vwxy[i][0] = v;
vwxy[i][1] = w;
vwxy[i][2] = x;
vwxy[i][3] = y;
if (bitget_overrun())
break; // bad data protect
}
if (nbits < 0)
{
i--;
vwxy[i][0] = 0;
vwxy[i][1] = 0;
vwxy[i][2] = 0;
vwxy[i][3] = 0;
}
i_non_zero = (i_non_zero + 1) << 2;
if ((tmp_nz & 3) == 0)
i_non_zero -= 2;
return i_non_zero; /* return non-zero sample (to nearest pair) */
}

973
programs/media/ac97 mp3/trunk/mp3dec/l3huff.h Normal file
View File

@ -0,0 +1,973 @@
typedef union
{
int ptr;
struct
{
unsigned char signbits;
unsigned char x;
unsigned char y;
unsigned char purgebits; // 0 = esc
}
b;
}
HUFF_ELEMENT;
/* TABLE 1 4 entries maxbits 3 linbits 0 */
static HUFF_ELEMENT huff_table_1[] =
{
0xFF000003, 0x03010102, 0x03010001, 0x02000101, 0x02000101, /* 4 */
0x01000000, 0x01000000, 0x01000000, 0x01000000,};
/* max table bits 3 */
/* TABLE 2 9 entries maxbits 6 linbits 0 */
static HUFF_ELEMENT huff_table_2[] =
{
0xFF000006, 0x06020202, 0x06020001, 0x05020102, 0x05020102, /* 4 */
0x05010202, 0x05010202, 0x05000201, 0x05000201, 0x03010102, /* 9 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 14 */
0x03010102, 0x03010102, 0x03010001, 0x03010001, 0x03010001, /* 19 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 24 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 29 */
0x03000101, 0x03000101, 0x03000101, 0x01000000, 0x01000000, /* 34 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 39 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 44 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 49 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 54 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 59 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 64 */ };
/* max table bits 6 */
/* TABLE 3 9 entries maxbits 6 linbits 0 */
static HUFF_ELEMENT huff_table_3[] =
{
0xFF000006, 0x06020202, 0x06020001, 0x05020102, 0x05020102, /* 4 */
0x05010202, 0x05010202, 0x05000201, 0x05000201, 0x03000101, /* 9 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 14 */
0x03000101, 0x03000101, 0x02010102, 0x02010102, 0x02010102, /* 19 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 24 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 29 */
0x02010102, 0x02010102, 0x02010102, 0x02010001, 0x02010001, /* 34 */
0x02010001, 0x02010001, 0x02010001, 0x02010001, 0x02010001, /* 39 */
0x02010001, 0x02010001, 0x02010001, 0x02010001, 0x02010001, /* 44 */
0x02010001, 0x02010001, 0x02010001, 0x02010001, 0x02000000, /* 49 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 54 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 59 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 64 */ };
/* max table bits 6 */
/* NO XING TABLE 4 */
/* TABLE 5 16 entries maxbits 8 linbits 0 */
static HUFF_ELEMENT huff_table_5[] =
{
0xFF000008, 0x08030302, 0x08030202, 0x07020302, 0x07020302, /* 4 */
0x06010302, 0x06010302, 0x06010302, 0x06010302, 0x07030102, /* 9 */
0x07030102, 0x07030001, 0x07030001, 0x07000301, 0x07000301, /* 14 */
0x07020202, 0x07020202, 0x06020102, 0x06020102, 0x06020102, /* 19 */
0x06020102, 0x06010202, 0x06010202, 0x06010202, 0x06010202, /* 24 */
0x06020001, 0x06020001, 0x06020001, 0x06020001, 0x06000201, /* 29 */
0x06000201, 0x06000201, 0x06000201, 0x03010102, 0x03010102, /* 34 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 39 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 44 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 49 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 54 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 59 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 64 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 69 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 74 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 79 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 84 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 89 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 94 */
0x03010001, 0x03010001, 0x03000101, 0x03000101, 0x03000101, /* 99 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 114 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x01000000, /* 129 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 134 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 139 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 144 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 149 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 154 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 159 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 164 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 169 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 174 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 179 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 184 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 189 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 194 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 199 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 204 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 209 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 214 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 219 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 224 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 229 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 234 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 239 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 244 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 249 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 254 */
0x01000000, 0x01000000,};
/* max table bits 8 */
/* TABLE 6 16 entries maxbits 7 linbits 0 */
static HUFF_ELEMENT huff_table_6[] =
{
0xFF000007, 0x07030302, 0x07030001, 0x06030202, 0x06030202, /* 4 */
0x06020302, 0x06020302, 0x06000301, 0x06000301, 0x05030102, /* 9 */
0x05030102, 0x05030102, 0x05030102, 0x05010302, 0x05010302, /* 14 */
0x05010302, 0x05010302, 0x05020202, 0x05020202, 0x05020202, /* 19 */
0x05020202, 0x05020001, 0x05020001, 0x05020001, 0x05020001, /* 24 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 29 */
0x04020102, 0x04020102, 0x04020102, 0x04010202, 0x04010202, /* 34 */
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 39 */
0x04010202, 0x04000201, 0x04000201, 0x04000201, 0x04000201, /* 44 */
0x04000201, 0x04000201, 0x04000201, 0x04000201, 0x03010001, /* 49 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 54 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 59 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 64 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 69 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 74 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 79 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 84 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 89 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 94 */
0x02010102, 0x02010102, 0x03000101, 0x03000101, 0x03000101, /* 99 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
0x03000101, 0x03000101, 0x03000101, 0x03000000, 0x03000000, /* 114 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 119 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 124 */
0x03000000, 0x03000000, 0x03000000, 0x03000000,};
/* max table bits 7 */
/* TABLE 7 36 entries maxbits 10 linbits 0 */
static HUFF_ELEMENT huff_table_7[] =
{
0xFF000006, 0x00000041, 0x00000052, 0x0000005B, 0x00000060, /* 4 */
0x00000063, 0x00000068, 0x0000006B, 0x06020102, 0x05010202, /* 9 */
0x05010202, 0x06020001, 0x06000201, 0x04010102, 0x04010102, /* 14 */
0x04010102, 0x04010102, 0x03010001, 0x03010001, 0x03010001, /* 19 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 24 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 29 */
0x03000101, 0x03000101, 0x03000101, 0x01000000, 0x01000000, /* 34 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 39 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 44 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 49 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 54 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 59 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 64 */
0xFF000004, 0x04050502, 0x04050402, 0x04040502, 0x04030502, /* 69 */
0x03050302, 0x03050302, 0x03040402, 0x03040402, 0x03050202, /* 74 */
0x03050202, 0x03020502, 0x03020502, 0x02050102, 0x02050102, /* 79 */
0x02050102, 0x02050102, 0xFF000003, 0x02010502, 0x02010502, /* 84 */
0x03050001, 0x03040302, 0x02000501, 0x02000501, 0x03030402, /* 89 */
0x03030302, 0xFF000002, 0x02040202, 0x02020402, 0x01040102, /* 94 */
0x01040102, 0xFF000001, 0x01010402, 0x01000401, 0xFF000002, /* 99 */
0x02040001, 0x02030202, 0x02020302, 0x02030001, 0xFF000001, /* 104 */
0x01030102, 0x01010302, 0xFF000001, 0x01000301, 0x01020202, /* 109 */ };
/* max table bits 6 */
/* TABLE 8 36 entries maxbits 11 linbits 0 */
static HUFF_ELEMENT huff_table_8[] =
{
0xFF000008, 0x00000101, 0x0000010A, 0x0000010F, 0x08050102, /* 4 */
0x08010502, 0x00000112, 0x00000115, 0x08040202, 0x08020402, /* 9 */
0x08040102, 0x07010402, 0x07010402, 0x08040001, 0x08000401, /* 14 */
0x08030202, 0x08020302, 0x08030102, 0x08010302, 0x08030001, /* 19 */
0x08000301, 0x06020202, 0x06020202, 0x06020202, 0x06020202, /* 24 */
0x06020001, 0x06020001, 0x06020001, 0x06020001, 0x06000201, /* 29 */
0x06000201, 0x06000201, 0x06000201, 0x04020102, 0x04020102, /* 34 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 39 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 44 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04010202, /* 49 */
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 54 */
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 59 */
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 64 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 69 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 74 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 79 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 84 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 89 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 94 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 99 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 104 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 109 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 114 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 119 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x02010102, /* 124 */
0x02010102, 0x02010102, 0x02010102, 0x02010102, 0x03010001, /* 129 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 134 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 139 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 144 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 149 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 154 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 159 */
0x03010001, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 164 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 169 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 174 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 179 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 184 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 189 */
0x03000101, 0x03000101, 0x03000101, 0x02000000, 0x02000000, /* 194 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 199 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 204 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 209 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 214 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 219 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 224 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 229 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 234 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 239 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 244 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 249 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 254 */
0x02000000, 0x02000000, 0xFF000003, 0x03050502, 0x03040502, /* 259 */
0x02050402, 0x02050402, 0x01030502, 0x01030502, 0x01030502, /* 264 */
0x01030502, 0xFF000002, 0x02050302, 0x02040402, 0x01050202, /* 269 */
0x01050202, 0xFF000001, 0x01020502, 0x01050001, 0xFF000001, /* 274 */
0x01040302, 0x01030402, 0xFF000001, 0x01000501, 0x01030302, /* 279 */ };
/* max table bits 8 */
/* TABLE 9 36 entries maxbits 9 linbits 0 */
static HUFF_ELEMENT huff_table_9[] =
{
0xFF000006, 0x00000041, 0x0000004A, 0x0000004F, 0x00000052, /* 4 */
0x00000057, 0x0000005A, 0x06040102, 0x06010402, 0x06030202, /* 9 */
0x06020302, 0x05030102, 0x05030102, 0x05010302, 0x05010302, /* 14 */
0x06030001, 0x06000301, 0x05020202, 0x05020202, 0x05020001, /* 19 */
0x05020001, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 24 */
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04000201, /* 29 */
0x04000201, 0x04000201, 0x04000201, 0x03010102, 0x03010102, /* 34 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 39 */
0x03010102, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 44 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03000101, /* 49 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 54 */
0x03000101, 0x03000101, 0x03000000, 0x03000000, 0x03000000, /* 59 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 64 */
0xFF000003, 0x03050502, 0x03050402, 0x02050302, 0x02050302, /* 69 */
0x02030502, 0x02030502, 0x03040502, 0x03050001, 0xFF000002, /* 74 */
0x02040402, 0x02050202, 0x02020502, 0x02050102, 0xFF000001, /* 79 */
0x01010502, 0x01040302, 0xFF000002, 0x01030402, 0x01030402, /* 84 */
0x02000501, 0x02040001, 0xFF000001, 0x01040202, 0x01020402, /* 89 */
0xFF000001, 0x01030302, 0x01000401,};
/* max table bits 6 */
/* TABLE 10 64 entries maxbits 11 linbits 0 */
static HUFF_ELEMENT huff_table_10[] =
{
0xFF000008, 0x00000101, 0x0000010A, 0x0000010F, 0x00000118, /* 4 */
0x0000011B, 0x00000120, 0x00000125, 0x08070102, 0x08010702, /* 9 */
0x0000012A, 0x0000012D, 0x00000132, 0x08060102, 0x08010602, /* 14 */
0x08000601, 0x00000137, 0x0000013A, 0x0000013D, 0x08040102, /* 19 */
0x08010402, 0x08000401, 0x08030202, 0x08020302, 0x08030001, /* 24 */
0x07030102, 0x07030102, 0x07010302, 0x07010302, 0x07000301, /* 29 */
0x07000301, 0x07020202, 0x07020202, 0x06020102, 0x06020102, /* 34 */
0x06020102, 0x06020102, 0x06010202, 0x06010202, 0x06010202, /* 39 */
0x06010202, 0x06020001, 0x06020001, 0x06020001, 0x06020001, /* 44 */
0x06000201, 0x06000201, 0x06000201, 0x06000201, 0x04010102, /* 49 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 54 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 59 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 64 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 69 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 74 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 79 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 84 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 89 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 94 */
0x03010001, 0x03010001, 0x03000101, 0x03000101, 0x03000101, /* 99 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 114 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x01000000, /* 129 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 134 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 139 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 144 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 149 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 154 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 159 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 164 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 169 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 174 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 179 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 184 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 189 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 194 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 199 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 204 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 209 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 214 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 219 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 224 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 229 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 234 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 239 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 244 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 249 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 254 */
0x01000000, 0x01000000, 0xFF000003, 0x03070702, 0x03070602, /* 259 */
0x03060702, 0x03070502, 0x03050702, 0x03060602, 0x02070402, /* 264 */
0x02070402, 0xFF000002, 0x02040702, 0x02060502, 0x02050602, /* 269 */
0x02070302, 0xFF000003, 0x02030702, 0x02030702, 0x02060402, /* 274 */
0x02060402, 0x03050502, 0x03040502, 0x02030602, 0x02030602, /* 279 */
0xFF000001, 0x01070202, 0x01020702, 0xFF000002, 0x02040602, /* 284 */
0x02070001, 0x01000701, 0x01000701, 0xFF000002, 0x01020602, /* 289 */
0x01020602, 0x02050402, 0x02050302, 0xFF000002, 0x01060001, /* 294 */
0x01060001, 0x02030502, 0x02040402, 0xFF000001, 0x01060302, /* 299 */
0x01060202, 0xFF000002, 0x02050202, 0x02020502, 0x01050102, /* 304 */
0x01050102, 0xFF000002, 0x01010502, 0x01010502, 0x02040302, /* 309 */
0x02030402, 0xFF000001, 0x01050001, 0x01000501, 0xFF000001, /* 314 */
0x01040202, 0x01020402, 0xFF000001, 0x01030302, 0x01040001, /* 319 */ };
/* max table bits 8 */
/* TABLE 11 64 entries maxbits 11 linbits 0 */
static HUFF_ELEMENT huff_table_11[] =
{
0xFF000008, 0x00000101, 0x00000106, 0x0000010F, 0x00000114, /* 4 */
0x00000117, 0x08070202, 0x08020702, 0x0000011C, 0x07010702, /* 9 */
0x07010702, 0x08070102, 0x08000701, 0x08060302, 0x08030602, /* 14 */
0x08000601, 0x0000011F, 0x00000122, 0x08050102, 0x07020602, /* 19 */
0x07020602, 0x08060202, 0x08060001, 0x07060102, 0x07060102, /* 24 */
0x07010602, 0x07010602, 0x08010502, 0x08040302, 0x08000501, /* 29 */
0x00000125, 0x08040202, 0x08020402, 0x08040102, 0x08010402, /* 34 */
0x08040001, 0x08000401, 0x07030202, 0x07030202, 0x07020302, /* 39 */
0x07020302, 0x06030102, 0x06030102, 0x06030102, 0x06030102, /* 44 */
0x06010302, 0x06010302, 0x06010302, 0x06010302, 0x07030001, /* 49 */
0x07030001, 0x07000301, 0x07000301, 0x06020202, 0x06020202, /* 54 */
0x06020202, 0x06020202, 0x05010202, 0x05010202, 0x05010202, /* 59 */
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 64 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 69 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 74 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 79 */
0x04020102, 0x05020001, 0x05020001, 0x05020001, 0x05020001, /* 84 */
0x05020001, 0x05020001, 0x05020001, 0x05020001, 0x05000201, /* 89 */
0x05000201, 0x05000201, 0x05000201, 0x05000201, 0x05000201, /* 94 */
0x05000201, 0x05000201, 0x03010102, 0x03010102, 0x03010102, /* 99 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 104 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 109 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 114 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 119 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 124 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010001, /* 129 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 134 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 139 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 144 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 149 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 154 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 159 */
0x03010001, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 164 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 169 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 174 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 179 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 184 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 189 */
0x03000101, 0x03000101, 0x03000101, 0x02000000, 0x02000000, /* 194 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 199 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 204 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 209 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 214 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 219 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 224 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 229 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 234 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 239 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 244 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 249 */
0x02000000, 0x02000000, 0x02000000, 0x02000000, 0x02000000, /* 254 */
0x02000000, 0x02000000, 0xFF000002, 0x02070702, 0x02070602, /* 259 */
0x02060702, 0x02050702, 0xFF000003, 0x02060602, 0x02060602, /* 264 */
0x02070402, 0x02070402, 0x02040702, 0x02040702, 0x03070502, /* 269 */
0x03050502, 0xFF000002, 0x02060502, 0x02050602, 0x01070302, /* 274 */
0x01070302, 0xFF000001, 0x01030702, 0x01060402, 0xFF000002, /* 279 */
0x02050402, 0x02040502, 0x02050302, 0x02030502, 0xFF000001, /* 284 */
0x01040602, 0x01070001, 0xFF000001, 0x01040402, 0x01050202, /* 289 */
0xFF000001, 0x01020502, 0x01050001, 0xFF000001, 0x01030402, /* 294 */
0x01030302,};
/* max table bits 8 */
/* TABLE 12 64 entries maxbits 10 linbits 0 */
static HUFF_ELEMENT huff_table_12[] =
{
0xFF000007, 0x00000081, 0x0000008A, 0x0000008F, 0x00000092, /* 4 */
0x00000097, 0x0000009A, 0x0000009D, 0x000000A2, 0x000000A5, /* 9 */
0x000000A8, 0x07060202, 0x07020602, 0x07010602, 0x000000AD, /* 14 */
0x000000B0, 0x000000B3, 0x07050102, 0x07010502, 0x07040302, /* 19 */
0x07030402, 0x000000B6, 0x07040202, 0x07020402, 0x07040102, /* 24 */
0x06030302, 0x06030302, 0x06010402, 0x06010402, 0x06030202, /* 29 */
0x06030202, 0x06020302, 0x06020302, 0x07000401, 0x07030001, /* 34 */
0x06000301, 0x06000301, 0x05030102, 0x05030102, 0x05030102, /* 39 */
0x05030102, 0x05010302, 0x05010302, 0x05010302, 0x05010302, /* 44 */
0x05020202, 0x05020202, 0x05020202, 0x05020202, 0x04020102, /* 49 */
0x04020102, 0x04020102, 0x04020102, 0x04020102, 0x04020102, /* 54 */
0x04020102, 0x04020102, 0x04010202, 0x04010202, 0x04010202, /* 59 */
0x04010202, 0x04010202, 0x04010202, 0x04010202, 0x04010202, /* 64 */
0x05020001, 0x05020001, 0x05020001, 0x05020001, 0x05000201, /* 69 */
0x05000201, 0x05000201, 0x05000201, 0x04000000, 0x04000000, /* 74 */
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 79 */
0x04000000, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 84 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 89 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 94 */
0x03010102, 0x03010102, 0x03010001, 0x03010001, 0x03010001, /* 99 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 104 */
0x03010001, 0x03010001, 0x03010001, 0x03010001, 0x03010001, /* 109 */
0x03010001, 0x03010001, 0x03010001, 0x03000101, 0x03000101, /* 114 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0xFF000003, /* 129 */
0x03070702, 0x03070602, 0x02060702, 0x02060702, 0x02070502, /* 134 */
0x02070502, 0x02050702, 0x02050702, 0xFF000002, 0x02060602, /* 139 */
0x02070402, 0x02040702, 0x02050602, 0xFF000001, 0x01060502, /* 144 */
0x01070302, 0xFF000002, 0x02030702, 0x02050502, 0x01070202, /* 149 */
0x01070202, 0xFF000001, 0x01020702, 0x01060402, 0xFF000001, /* 154 */
0x01040602, 0x01070102, 0xFF000002, 0x01010702, 0x01010702, /* 159 */
0x02070001, 0x02000701, 0xFF000001, 0x01060302, 0x01030602, /* 164 */
0xFF000001, 0x01050402, 0x01040502, 0xFF000002, 0x01040402, /* 169 */
0x01040402, 0x02060001, 0x02050001, 0xFF000001, 0x01060102, /* 174 */
0x01000601, 0xFF000001, 0x01050302, 0x01030502, 0xFF000001, /* 179 */
0x01050202, 0x01020502, 0xFF000001, 0x01000501, 0x01040001, /* 184 */ };
/* max table bits 7 */
/* TABLE 13 256 entries maxbits 19 linbits 0 */
static HUFF_ELEMENT huff_table_13[] =
{
0xFF000006, 0x00000041, 0x00000082, 0x000000C3, 0x000000E4, /* 4 */
0x00000105, 0x00000116, 0x0000011F, 0x00000130, 0x00000139, /* 9 */
0x0000013E, 0x00000143, 0x00000146, 0x06020102, 0x06010202, /* 14 */
0x06020001, 0x06000201, 0x04010102, 0x04010102, 0x04010102, /* 19 */
0x04010102, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 24 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 29 */
0x03000101, 0x03000101, 0x03000101, 0x01000000, 0x01000000, /* 34 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 39 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 44 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 49 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 54 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 59 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 64 */
0xFF000006, 0x00000108, 0x00000111, 0x0000011A, 0x00000123, /* 69 */
0x0000012C, 0x00000131, 0x00000136, 0x0000013F, 0x00000144, /* 74 */
0x00000147, 0x0000014C, 0x00000151, 0x00000156, 0x0000015B, /* 79 */
0x060F0102, 0x06010F02, 0x06000F01, 0x00000160, 0x00000163, /* 84 */
0x00000166, 0x06020E02, 0x00000169, 0x060E0102, 0x06010E02, /* 89 */
0x0000016C, 0x0000016F, 0x00000172, 0x00000175, 0x00000178, /* 94 */
0x0000017B, 0x06060C02, 0x060D0302, 0x0000017E, 0x060D0202, /* 99 */
0x06020D02, 0x060D0102, 0x06070B02, 0x00000181, 0x00000184, /* 104 */
0x06030C02, 0x00000187, 0x060B0402, 0x05010D02, 0x05010D02, /* 109 */
0x060D0001, 0x06000D01, 0x060A0802, 0x06080A02, 0x060C0402, /* 114 */
0x06040C02, 0x060B0602, 0x06060B02, 0x050C0302, 0x050C0302, /* 119 */
0x050C0202, 0x050C0202, 0x05020C02, 0x05020C02, 0x050B0502, /* 124 */
0x050B0502, 0x06050B02, 0x06090802, 0x050C0102, 0x050C0102, /* 129 */
0xFF000006, 0x05010C02, 0x05010C02, 0x06080902, 0x060C0001, /* 134 */
0x05000C01, 0x05000C01, 0x06040B02, 0x060A0602, 0x06060A02, /* 139 */
0x06090702, 0x050B0302, 0x050B0302, 0x05030B02, 0x05030B02, /* 144 */
0x06080802, 0x060A0502, 0x050B0202, 0x050B0202, 0x06050A02, /* 149 */
0x06090602, 0x05040A02, 0x05040A02, 0x06080702, 0x06070802, /* 154 */
0x05040902, 0x05040902, 0x06070702, 0x06060702, 0x04020B02, /* 159 */
0x04020B02, 0x04020B02, 0x04020B02, 0x040B0102, 0x040B0102, /* 164 */
0x040B0102, 0x040B0102, 0x04010B02, 0x04010B02, 0x04010B02, /* 169 */
0x04010B02, 0x050B0001, 0x050B0001, 0x05000B01, 0x05000B01, /* 174 */
0x05060902, 0x05060902, 0x050A0402, 0x050A0402, 0x050A0302, /* 179 */
0x050A0302, 0x05030A02, 0x05030A02, 0x05090502, 0x05090502, /* 184 */
0x05050902, 0x05050902, 0x040A0202, 0x040A0202, 0x040A0202, /* 189 */
0x040A0202, 0x04020A02, 0x04020A02, 0x04020A02, 0x04020A02, /* 194 */
0xFF000005, 0x040A0102, 0x040A0102, 0x04010A02, 0x04010A02, /* 199 */
0x050A0001, 0x05080602, 0x04000A01, 0x04000A01, 0x05060802, /* 204 */
0x05090402, 0x04030902, 0x04030902, 0x05090302, 0x05080502, /* 209 */
0x05050802, 0x05070602, 0x04090202, 0x04090202, 0x04020902, /* 214 */
0x04020902, 0x05070502, 0x05050702, 0x04080302, 0x04080302, /* 219 */
0x04030802, 0x04030802, 0x05060602, 0x05070402, 0x05040702, /* 224 */
0x05060502, 0x05050602, 0x05030702, 0xFF000005, 0x03090102, /* 229 */
0x03090102, 0x03090102, 0x03090102, 0x03010902, 0x03010902, /* 234 */
0x03010902, 0x03010902, 0x04090001, 0x04090001, 0x04000901, /* 239 */
0x04000901, 0x04080402, 0x04080402, 0x04040802, 0x04040802, /* 244 */
0x04020702, 0x04020702, 0x05060402, 0x05040602, 0x03080202, /* 249 */
0x03080202, 0x03080202, 0x03080202, 0x03020802, 0x03020802, /* 254 */
0x03020802, 0x03020802, 0x03080102, 0x03080102, 0x03080102, /* 259 */
0x03080102, 0xFF000004, 0x04070302, 0x04070202, 0x03070102, /* 264 */
0x03070102, 0x03010702, 0x03010702, 0x04050502, 0x04070001, /* 269 */
0x04000701, 0x04060302, 0x04030602, 0x04050402, 0x04040502, /* 274 */
0x04060202, 0x04020602, 0x04050302, 0xFF000003, 0x02010802, /* 279 */
0x02010802, 0x03080001, 0x03000801, 0x03060102, 0x03010602, /* 284 */
0x03060001, 0x03000601, 0xFF000004, 0x04030502, 0x04040402, /* 289 */
0x03050202, 0x03050202, 0x03020502, 0x03020502, 0x03050001, /* 294 */
0x03050001, 0x02050102, 0x02050102, 0x02050102, 0x02050102, /* 299 */
0x02010502, 0x02010502, 0x02010502, 0x02010502, 0xFF000003, /* 304 */
0x03040302, 0x03030402, 0x03000501, 0x03040202, 0x03020402, /* 309 */
0x03030302, 0x02040102, 0x02040102, 0xFF000002, 0x01010402, /* 314 */
0x01010402, 0x02040001, 0x02000401, 0xFF000002, 0x02030202, /* 319 */
0x02020302, 0x01030102, 0x01030102, 0xFF000001, 0x01010302, /* 324 */
0x01030001, 0xFF000001, 0x01000301, 0x01020202, 0xFF000003, /* 329 */
0x00000082, 0x0000008B, 0x0000008E, 0x00000091, 0x00000094, /* 334 */
0x00000097, 0x030C0E02, 0x030D0D02, 0xFF000003, 0x00000093, /* 339 */
0x030E0B02, 0x030B0E02, 0x030F0902, 0x03090F02, 0x030A0E02, /* 344 */
0x030D0B02, 0x030B0D02, 0xFF000003, 0x030F0802, 0x03080F02, /* 349 */
0x030C0C02, 0x0000008D, 0x030E0802, 0x00000090, 0x02070F02, /* 354 */
0x02070F02, 0xFF000003, 0x020A0D02, 0x020A0D02, 0x030D0A02, /* 359 */
0x030C0B02, 0x030B0C02, 0x03060F02, 0x020F0602, 0x020F0602, /* 364 */
0xFF000002, 0x02080E02, 0x020F0502, 0x020D0902, 0x02090D02, /* 369 */
0xFF000002, 0x02050F02, 0x02070E02, 0x020C0A02, 0x020B0B02, /* 374 */
0xFF000003, 0x020F0402, 0x020F0402, 0x02040F02, 0x02040F02, /* 379 */
0x030A0C02, 0x03060E02, 0x02030F02, 0x02030F02, 0xFF000002, /* 384 */
0x010F0302, 0x010F0302, 0x020D0802, 0x02080D02, 0xFF000001, /* 389 */
0x010F0202, 0x01020F02, 0xFF000002, 0x020E0602, 0x020C0902, /* 394 */
0x010F0001, 0x010F0001, 0xFF000002, 0x02090C02, 0x020E0502, /* 399 */
0x010B0A02, 0x010B0A02, 0xFF000002, 0x020D0702, 0x02070D02, /* 404 */
0x010E0402, 0x010E0402, 0xFF000002, 0x02080C02, 0x02060D02, /* 409 */
0x010E0302, 0x010E0302, 0xFF000002, 0x01090B02, 0x01090B02, /* 414 */
0x020B0902, 0x020A0A02, 0xFF000001, 0x010A0B02, 0x01050E02, /* 419 */
0xFF000001, 0x01040E02, 0x010C0802, 0xFF000001, 0x010D0602, /* 424 */
0x01030E02, 0xFF000001, 0x010E0202, 0x010E0001, 0xFF000001, /* 429 */
0x01000E01, 0x010D0502, 0xFF000001, 0x01050D02, 0x010C0702, /* 434 */
0xFF000001, 0x01070C02, 0x010D0402, 0xFF000001, 0x010B0802, /* 439 */
0x01080B02, 0xFF000001, 0x01040D02, 0x010A0902, 0xFF000001, /* 444 */
0x01090A02, 0x010C0602, 0xFF000001, 0x01030D02, 0x010B0702, /* 449 */
0xFF000001, 0x010C0502, 0x01050C02, 0xFF000001, 0x01090902, /* 454 */
0x010A0702, 0xFF000001, 0x01070A02, 0x01070902, 0xFF000003, /* 459 */
0x00000023, 0x030D0F02, 0x020D0E02, 0x020D0E02, 0x010F0F02, /* 464 */
0x010F0F02, 0x010F0F02, 0x010F0F02, 0xFF000001, 0x010F0E02, /* 469 */
0x010F0D02, 0xFF000001, 0x010E0E02, 0x010F0C02, 0xFF000001, /* 474 */
0x010E0D02, 0x010F0B02, 0xFF000001, 0x010B0F02, 0x010E0C02, /* 479 */
0xFF000002, 0x010C0D02, 0x010C0D02, 0x020F0A02, 0x02090E02, /* 484 */
0xFF000001, 0x010A0F02, 0x010D0C02, 0xFF000001, 0x010E0A02, /* 489 */
0x010E0902, 0xFF000001, 0x010F0702, 0x010E0702, 0xFF000001, /* 494 */
0x010E0F02, 0x010C0F02,};
/* max table bits 6 */
/* NO XING TABLE 14 */
/* TABLE 15 256 entries maxbits 13 linbits 0 */
static HUFF_ELEMENT huff_table_15[] =
{
0xFF000008, 0x00000101, 0x00000122, 0x00000143, 0x00000154, /* 4 */
0x00000165, 0x00000176, 0x0000017F, 0x00000188, 0x00000199, /* 9 */
0x000001A2, 0x000001AB, 0x000001B4, 0x000001BD, 0x000001C2, /* 14 */
0x000001CB, 0x000001D4, 0x000001D9, 0x000001DE, 0x000001E3, /* 19 */
0x000001E8, 0x000001ED, 0x000001F2, 0x000001F7, 0x000001FC, /* 24 */
0x00000201, 0x00000204, 0x00000207, 0x0000020A, 0x0000020F, /* 29 */
0x00000212, 0x00000215, 0x0000021A, 0x0000021D, 0x00000220, /* 34 */
0x08010902, 0x00000223, 0x00000226, 0x00000229, 0x0000022C, /* 39 */
0x0000022F, 0x08080202, 0x08020802, 0x08080102, 0x08010802, /* 44 */
0x00000232, 0x00000235, 0x00000238, 0x0000023B, 0x08070202, /* 49 */
0x08020702, 0x08040602, 0x08070102, 0x08050502, 0x08010702, /* 54 */
0x0000023E, 0x08060302, 0x08030602, 0x08050402, 0x08040502, /* 59 */
0x08060202, 0x08020602, 0x08060102, 0x00000241, 0x08050302, /* 64 */
0x07010602, 0x07010602, 0x08030502, 0x08040402, 0x07050202, /* 69 */
0x07050202, 0x07020502, 0x07020502, 0x07050102, 0x07050102, /* 74 */
0x07010502, 0x07010502, 0x08050001, 0x08000501, 0x07040302, /* 79 */
0x07040302, 0x07030402, 0x07030402, 0x07040202, 0x07040202, /* 84 */
0x07020402, 0x07020402, 0x07030302, 0x07030302, 0x06010402, /* 89 */
0x06010402, 0x06010402, 0x06010402, 0x07040102, 0x07040102, /* 94 */
0x07040001, 0x07040001, 0x06030202, 0x06030202, 0x06030202, /* 99 */
0x06030202, 0x06020302, 0x06020302, 0x06020302, 0x06020302, /* 104 */
0x07000401, 0x07000401, 0x07030001, 0x07030001, 0x06030102, /* 109 */
0x06030102, 0x06030102, 0x06030102, 0x06010302, 0x06010302, /* 114 */
0x06010302, 0x06010302, 0x06000301, 0x06000301, 0x06000301, /* 119 */
0x06000301, 0x05020202, 0x05020202, 0x05020202, 0x05020202, /* 124 */
0x05020202, 0x05020202, 0x05020202, 0x05020202, 0x05020102, /* 129 */
0x05020102, 0x05020102, 0x05020102, 0x05020102, 0x05020102, /* 134 */
0x05020102, 0x05020102, 0x05010202, 0x05010202, 0x05010202, /* 139 */
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 144 */
0x05020001, 0x05020001, 0x05020001, 0x05020001, 0x05020001, /* 149 */
0x05020001, 0x05020001, 0x05020001, 0x05000201, 0x05000201, /* 154 */
0x05000201, 0x05000201, 0x05000201, 0x05000201, 0x05000201, /* 159 */
0x05000201, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 164 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 169 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 174 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 179 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 184 */
0x03010102, 0x03010102, 0x03010102, 0x03010102, 0x03010102, /* 189 */
0x03010102, 0x03010102, 0x03010102, 0x04010001, 0x04010001, /* 194 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 199 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 204 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04000101, /* 209 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 214 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 219 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 224 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 229 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 234 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 239 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 244 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 249 */
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, /* 254 */
0x03000000, 0x03000000, 0xFF000005, 0x050F0F02, 0x050F0E02, /* 259 */
0x050E0F02, 0x050F0D02, 0x040E0E02, 0x040E0E02, 0x050D0F02, /* 264 */
0x050F0C02, 0x050C0F02, 0x050E0D02, 0x050D0E02, 0x050F0B02, /* 269 */
0x040B0F02, 0x040B0F02, 0x050E0C02, 0x050C0E02, 0x040D0D02, /* 274 */
0x040D0D02, 0x040F0A02, 0x040F0A02, 0x040A0F02, 0x040A0F02, /* 279 */
0x040E0B02, 0x040E0B02, 0x040B0E02, 0x040B0E02, 0x040D0C02, /* 284 */
0x040D0C02, 0x040C0D02, 0x040C0D02, 0x040F0902, 0x040F0902, /* 289 */
0xFF000005, 0x04090F02, 0x04090F02, 0x040A0E02, 0x040A0E02, /* 294 */
0x040D0B02, 0x040D0B02, 0x040B0D02, 0x040B0D02, 0x040F0802, /* 299 */
0x040F0802, 0x04080F02, 0x04080F02, 0x040C0C02, 0x040C0C02, /* 304 */
0x040E0902, 0x040E0902, 0x04090E02, 0x04090E02, 0x040F0702, /* 309 */
0x040F0702, 0x04070F02, 0x04070F02, 0x040D0A02, 0x040D0A02, /* 314 */
0x040A0D02, 0x040A0D02, 0x040C0B02, 0x040C0B02, 0x040F0602, /* 319 */
0x040F0602, 0x050E0A02, 0x050F0001, 0xFF000004, 0x030B0C02, /* 324 */
0x030B0C02, 0x03060F02, 0x03060F02, 0x040E0802, 0x04080E02, /* 329 */
0x040F0502, 0x040D0902, 0x03050F02, 0x03050F02, 0x030E0702, /* 334 */
0x030E0702, 0x03070E02, 0x03070E02, 0x030C0A02, 0x030C0A02, /* 339 */
0xFF000004, 0x030A0C02, 0x030A0C02, 0x030B0B02, 0x030B0B02, /* 344 */
0x04090D02, 0x040D0802, 0x030F0402, 0x030F0402, 0x03040F02, /* 349 */
0x03040F02, 0x030F0302, 0x030F0302, 0x03030F02, 0x03030F02, /* 354 */
0x03080D02, 0x03080D02, 0xFF000004, 0x03060E02, 0x03060E02, /* 359 */
0x030F0202, 0x030F0202, 0x03020F02, 0x03020F02, 0x040E0602, /* 364 */
0x04000F01, 0x030F0102, 0x030F0102, 0x03010F02, 0x03010F02, /* 369 */
0x030C0902, 0x030C0902, 0x03090C02, 0x03090C02, 0xFF000003, /* 374 */
0x030E0502, 0x030B0A02, 0x030A0B02, 0x03050E02, 0x030D0702, /* 379 */
0x03070D02, 0x030E0402, 0x03040E02, 0xFF000003, 0x030C0802, /* 384 */
0x03080C02, 0x030E0302, 0x030D0602, 0x03060D02, 0x03030E02, /* 389 */
0x030B0902, 0x03090B02, 0xFF000004, 0x030E0202, 0x030E0202, /* 394 */
0x030A0A02, 0x030A0A02, 0x03020E02, 0x03020E02, 0x030E0102, /* 399 */
0x030E0102, 0x03010E02, 0x03010E02, 0x040E0001, 0x04000E01, /* 404 */
0x030D0502, 0x030D0502, 0x03050D02, 0x03050D02, 0xFF000003, /* 409 */
0x030C0702, 0x03070C02, 0x030D0402, 0x030B0802, 0x02040D02, /* 414 */
0x02040D02, 0x03080B02, 0x030A0902, 0xFF000003, 0x03090A02, /* 419 */
0x030C0602, 0x03060C02, 0x030D0302, 0x02030D02, 0x02030D02, /* 424 */
0x02020D02, 0x02020D02, 0xFF000003, 0x030D0202, 0x030D0001, /* 429 */
0x020D0102, 0x020D0102, 0x020B0702, 0x020B0702, 0x02070B02, /* 434 */
0x02070B02, 0xFF000003, 0x02010D02, 0x02010D02, 0x030C0502, /* 439 */
0x03000D01, 0x02050C02, 0x02050C02, 0x020A0802, 0x020A0802, /* 444 */
0xFF000002, 0x02080A02, 0x020C0402, 0x02040C02, 0x020B0602, /* 449 */
0xFF000003, 0x02060B02, 0x02060B02, 0x03090902, 0x030C0001, /* 454 */
0x020C0302, 0x020C0302, 0x02030C02, 0x02030C02, 0xFF000003, /* 459 */
0x020A0702, 0x020A0702, 0x02070A02, 0x02070A02, 0x02060A02, /* 464 */
0x02060A02, 0x03000C01, 0x030B0001, 0xFF000002, 0x01020C02, /* 469 */
0x01020C02, 0x020C0202, 0x020B0502, 0xFF000002, 0x02050B02, /* 474 */
0x020C0102, 0x02090802, 0x02080902, 0xFF000002, 0x02010C02, /* 479 */
0x020B0402, 0x02040B02, 0x020A0602, 0xFF000002, 0x020B0302, /* 484 */
0x02090702, 0x01030B02, 0x01030B02, 0xFF000002, 0x02070902, /* 489 */
0x02080802, 0x020B0202, 0x020A0502, 0xFF000002, 0x01020B02, /* 494 */
0x01020B02, 0x02050A02, 0x020B0102, 0xFF000002, 0x01010B02, /* 499 */
0x01010B02, 0x02000B01, 0x02090602, 0xFF000002, 0x02060902, /* 504 */
0x020A0402, 0x02040A02, 0x02080702, 0xFF000002, 0x02070802, /* 509 */
0x020A0302, 0x01030A02, 0x01030A02, 0xFF000001, 0x01090502, /* 514 */
0x01050902, 0xFF000001, 0x010A0202, 0x01020A02, 0xFF000001, /* 519 */
0x010A0102, 0x01010A02, 0xFF000002, 0x020A0001, 0x02000A01, /* 524 */
0x01080602, 0x01080602, 0xFF000001, 0x01060802, 0x01090402, /* 529 */
0xFF000001, 0x01040902, 0x01090302, 0xFF000002, 0x01030902, /* 534 */
0x01030902, 0x02070702, 0x02090001, 0xFF000001, 0x01080502, /* 539 */
0x01050802, 0xFF000001, 0x01090202, 0x01070602, 0xFF000001, /* 544 */
0x01060702, 0x01020902, 0xFF000001, 0x01090102, 0x01000901, /* 549 */
0xFF000001, 0x01080402, 0x01040802, 0xFF000001, 0x01070502, /* 554 */
0x01050702, 0xFF000001, 0x01080302, 0x01030802, 0xFF000001, /* 559 */
0x01060602, 0x01070402, 0xFF000001, 0x01040702, 0x01080001, /* 564 */
0xFF000001, 0x01000801, 0x01060502, 0xFF000001, 0x01050602, /* 569 */
0x01070302, 0xFF000001, 0x01030702, 0x01060402, 0xFF000001, /* 574 */
0x01070001, 0x01000701, 0xFF000001, 0x01060001, 0x01000601, /* 579 */ };
/* max table bits 8 */
/* TABLE 16 256 entries maxbits 17 linbits 0 */
static HUFF_ELEMENT huff_table_16[] =
{
0xFF000008, 0x00000101, 0x0000010A, 0x00000113, 0x080F0F02, /* 4 */
0x00000118, 0x0000011D, 0x00000120, 0x08020F02, 0x00000131, /* 9 */
0x080F0102, 0x08010F02, 0x00000134, 0x00000145, 0x00000156, /* 14 */
0x00000167, 0x00000178, 0x00000189, 0x0000019A, 0x000001A3, /* 19 */
0x000001AC, 0x000001B5, 0x000001BE, 0x000001C7, 0x000001D0, /* 24 */
0x000001D9, 0x000001DE, 0x000001E3, 0x000001E6, 0x000001EB, /* 29 */
0x000001F0, 0x08010502, 0x000001F3, 0x000001F6, 0x000001F9, /* 34 */
0x000001FC, 0x08040102, 0x08010402, 0x000001FF, 0x08030202, /* 39 */
0x08020302, 0x07030102, 0x07030102, 0x07010302, 0x07010302, /* 44 */
0x08030001, 0x08000301, 0x07020202, 0x07020202, 0x06020102, /* 49 */
0x06020102, 0x06020102, 0x06020102, 0x06010202, 0x06010202, /* 54 */
0x06010202, 0x06010202, 0x06020001, 0x06020001, 0x06020001, /* 59 */
0x06020001, 0x06000201, 0x06000201, 0x06000201, 0x06000201, /* 64 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 69 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 74 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 79 */
0x04010102, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 84 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 89 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 94 */
0x04010001, 0x04010001, 0x03000101, 0x03000101, 0x03000101, /* 99 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 104 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 109 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 114 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 119 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x03000101, /* 124 */
0x03000101, 0x03000101, 0x03000101, 0x03000101, 0x01000000, /* 129 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 134 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 139 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 144 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 149 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 154 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 159 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 164 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 169 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 174 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 179 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 184 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 189 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 194 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 199 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 204 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 209 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 214 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 219 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 224 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 229 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 234 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 239 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 244 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 249 */
0x01000000, 0x01000000, 0x01000000, 0x01000000, 0x01000000, /* 254 */
0x01000000, 0x01000000, 0xFF000003, 0x030F0E02, 0x030E0F02, /* 259 */
0x030F0D02, 0x030D0F02, 0x030F0C02, 0x030C0F02, 0x030F0B02, /* 264 */
0x030B0F02, 0xFF000003, 0x020F0A02, 0x020F0A02, 0x030A0F02, /* 269 */
0x030F0902, 0x03090F02, 0x03080F02, 0x020F0802, 0x020F0802, /* 274 */
0xFF000002, 0x020F0702, 0x02070F02, 0x020F0602, 0x02060F02, /* 279 */
0xFF000002, 0x020F0502, 0x02050F02, 0x010F0402, 0x010F0402, /* 284 */
0xFF000001, 0x01040F02, 0x01030F02, 0xFF000004, 0x01000F01, /* 289 */
0x01000F01, 0x01000F01, 0x01000F01, 0x01000F01, 0x01000F01, /* 294 */
0x01000F01, 0x01000F01, 0x020F0302, 0x020F0302, 0x020F0302, /* 299 */
0x020F0302, 0x000000E2, 0x000000F3, 0x000000FC, 0x00000105, /* 304 */
0xFF000001, 0x010F0202, 0x010F0001, 0xFF000004, 0x000000FA, /* 309 */
0x000000FF, 0x00000104, 0x00000109, 0x0000010C, 0x00000111, /* 314 */
0x00000116, 0x00000119, 0x0000011E, 0x00000123, 0x00000128, /* 319 */
0x04030E02, 0x0000012D, 0x00000130, 0x00000133, 0x00000136, /* 324 */
0xFF000004, 0x00000128, 0x0000012B, 0x0000012E, 0x040D0001, /* 329 */
0x00000131, 0x00000134, 0x00000137, 0x040C0302, 0x0000013A, /* 334 */
0x040C0102, 0x04000C01, 0x0000013D, 0x03020E02, 0x03020E02, /* 339 */
0x040E0202, 0x040E0102, 0xFF000004, 0x04030D02, 0x040D0202, /* 344 */
0x04020D02, 0x04010D02, 0x040B0302, 0x0000012F, 0x030D0102, /* 349 */
0x030D0102, 0x04040C02, 0x040B0602, 0x04030C02, 0x04070A02, /* 354 */
0x030C0202, 0x030C0202, 0x04020C02, 0x04050B02, 0xFF000004, /* 359 */
0x04010C02, 0x040C0001, 0x040B0402, 0x04040B02, 0x040A0602, /* 364 */
0x04060A02, 0x03030B02, 0x03030B02, 0x040A0502, 0x04050A02, /* 369 */
0x030B0202, 0x030B0202, 0x03020B02, 0x03020B02, 0x030B0102, /* 374 */
0x030B0102, 0xFF000004, 0x03010B02, 0x03010B02, 0x040B0001, /* 379 */
0x04000B01, 0x04090602, 0x04060902, 0x040A0402, 0x04040A02, /* 384 */
0x04080702, 0x04070802, 0x03030A02, 0x03030A02, 0x040A0302, /* 389 */
0x04090502, 0x030A0202, 0x030A0202, 0xFF000004, 0x04050902, /* 394 */
0x04080602, 0x03010A02, 0x03010A02, 0x04060802, 0x04070702, /* 399 */
0x03040902, 0x03040902, 0x04090402, 0x04070502, 0x03070602, /* 404 */
0x03070602, 0x02020A02, 0x02020A02, 0x02020A02, 0x02020A02, /* 409 */
0xFF000003, 0x020A0102, 0x020A0102, 0x030A0001, 0x03000A01, /* 414 */
0x03090302, 0x03030902, 0x03080502, 0x03050802, 0xFF000003, /* 419 */
0x02090202, 0x02090202, 0x02020902, 0x02020902, 0x03060702, /* 424 */
0x03090001, 0x02090102, 0x02090102, 0xFF000003, 0x02010902, /* 429 */
0x02010902, 0x03000901, 0x03080402, 0x03040802, 0x03050702, /* 434 */
0x03080302, 0x03030802, 0xFF000003, 0x03060602, 0x03080202, /* 439 */
0x02020802, 0x02020802, 0x03070402, 0x03040702, 0x02080102, /* 444 */
0x02080102, 0xFF000003, 0x02010802, 0x02010802, 0x02000801, /* 449 */
0x02000801, 0x03080001, 0x03060502, 0x02070302, 0x02070302, /* 454 */
0xFF000003, 0x02030702, 0x02030702, 0x03050602, 0x03060402, /* 459 */
0x02070202, 0x02070202, 0x02020702, 0x02020702, 0xFF000003, /* 464 */
0x03040602, 0x03050502, 0x02070001, 0x02070001, 0x01070102, /* 469 */
0x01070102, 0x01070102, 0x01070102, 0xFF000002, 0x01010702, /* 474 */
0x01010702, 0x02000701, 0x02060302, 0xFF000002, 0x02030602, /* 479 */
0x02050402, 0x02040502, 0x02060202, 0xFF000001, 0x01020602, /* 484 */
0x01060102, 0xFF000002, 0x01010602, 0x01010602, 0x02060001, /* 489 */
0x02000601, 0xFF000002, 0x01030502, 0x01030502, 0x02050302, /* 494 */
0x02040402, 0xFF000001, 0x01050202, 0x01020502, 0xFF000001, /* 499 */
0x01050102, 0x01050001, 0xFF000001, 0x01040302, 0x01030402, /* 504 */
0xFF000001, 0x01000501, 0x01040202, 0xFF000001, 0x01020402, /* 509 */
0x01030302, 0xFF000001, 0x01040001, 0x01000401, 0xFF000004, /* 514 */
0x040E0C02, 0x00000086, 0x030E0D02, 0x030E0D02, 0x03090E02, /* 519 */
0x03090E02, 0x040A0E02, 0x04090D02, 0x020E0E02, 0x020E0E02, /* 524 */
0x020E0E02, 0x020E0E02, 0x030D0E02, 0x030D0E02, 0x030B0E02, /* 529 */
0x030B0E02, 0xFF000003, 0x020E0B02, 0x020E0B02, 0x020D0C02, /* 534 */
0x020D0C02, 0x030C0D02, 0x030B0D02, 0x020E0A02, 0x020E0A02, /* 539 */
0xFF000003, 0x020C0C02, 0x020C0C02, 0x030D0A02, 0x030A0D02, /* 544 */
0x030E0702, 0x030C0A02, 0x020A0C02, 0x020A0C02, 0xFF000003, /* 549 */
0x03090C02, 0x030D0702, 0x020E0502, 0x020E0502, 0x010D0B02, /* 554 */
0x010D0B02, 0x010D0B02, 0x010D0B02, 0xFF000002, 0x010E0902, /* 559 */
0x010E0902, 0x020C0B02, 0x020B0C02, 0xFF000002, 0x020E0802, /* 564 */
0x02080E02, 0x020D0902, 0x02070E02, 0xFF000002, 0x020B0B02, /* 569 */
0x020D0802, 0x02080D02, 0x020E0602, 0xFF000001, 0x01060E02, /* 574 */
0x010C0902, 0xFF000002, 0x020B0A02, 0x020A0B02, 0x02050E02, /* 579 */
0x02070D02, 0xFF000002, 0x010E0402, 0x010E0402, 0x02040E02, /* 584 */
0x020C0802, 0xFF000001, 0x01080C02, 0x010E0302, 0xFF000002, /* 589 */
0x010D0602, 0x010D0602, 0x02060D02, 0x020B0902, 0xFF000002, /* 594 */
0x02090B02, 0x020A0A02, 0x01010E02, 0x01010E02, 0xFF000002, /* 599 */
0x01040D02, 0x01040D02, 0x02080B02, 0x02090A02, 0xFF000002, /* 604 */
0x010B0702, 0x010B0702, 0x02070B02, 0x02000D01, 0xFF000001, /* 609 */
0x010E0001, 0x01000E01, 0xFF000001, 0x010D0502, 0x01050D02, /* 614 */
0xFF000001, 0x010C0702, 0x01070C02, 0xFF000001, 0x010D0402, /* 619 */
0x010B0802, 0xFF000001, 0x010A0902, 0x010C0602, 0xFF000001, /* 624 */
0x01060C02, 0x010D0302, 0xFF000001, 0x010C0502, 0x01050C02, /* 629 */
0xFF000001, 0x010A0802, 0x01080A02, 0xFF000001, 0x01090902, /* 634 */
0x010C0402, 0xFF000001, 0x01060B02, 0x010A0702, 0xFF000001, /* 639 */
0x010B0502, 0x01090802, 0xFF000001, 0x01080902, 0x01090702, /* 644 */
0xFF000001, 0x01070902, 0x01080802, 0xFF000001, 0x010C0E02, /* 649 */
0x010D0D02,};
/* max table bits 8 */
/* NO XING TABLE 17 */
/* NO XING TABLE 18 */
/* NO XING TABLE 19 */
/* NO XING TABLE 20 */
/* NO XING TABLE 21 */
/* NO XING TABLE 22 */
/* NO XING TABLE 23 */
/* TABLE 24 256 entries maxbits 12 linbits 0 */
static HUFF_ELEMENT huff_table_24[] =
{
0xFF000009, 0x080F0E02, 0x080F0E02, 0x080E0F02, 0x080E0F02, /* 4 */
0x080F0D02, 0x080F0D02, 0x080D0F02, 0x080D0F02, 0x080F0C02, /* 9 */
0x080F0C02, 0x080C0F02, 0x080C0F02, 0x080F0B02, 0x080F0B02, /* 14 */
0x080B0F02, 0x080B0F02, 0x070A0F02, 0x070A0F02, 0x070A0F02, /* 19 */
0x070A0F02, 0x080F0A02, 0x080F0A02, 0x080F0902, 0x080F0902, /* 24 */
0x07090F02, 0x07090F02, 0x07090F02, 0x07090F02, 0x07080F02, /* 29 */
0x07080F02, 0x07080F02, 0x07080F02, 0x080F0802, 0x080F0802, /* 34 */
0x080F0702, 0x080F0702, 0x07070F02, 0x07070F02, 0x07070F02, /* 39 */
0x07070F02, 0x070F0602, 0x070F0602, 0x070F0602, 0x070F0602, /* 44 */
0x07060F02, 0x07060F02, 0x07060F02, 0x07060F02, 0x070F0502, /* 49 */
0x070F0502, 0x070F0502, 0x070F0502, 0x07050F02, 0x07050F02, /* 54 */
0x07050F02, 0x07050F02, 0x070F0402, 0x070F0402, 0x070F0402, /* 59 */
0x070F0402, 0x07040F02, 0x07040F02, 0x07040F02, 0x07040F02, /* 64 */
0x070F0302, 0x070F0302, 0x070F0302, 0x070F0302, 0x07030F02, /* 69 */
0x07030F02, 0x07030F02, 0x07030F02, 0x070F0202, 0x070F0202, /* 74 */
0x070F0202, 0x070F0202, 0x07020F02, 0x07020F02, 0x07020F02, /* 79 */
0x07020F02, 0x07010F02, 0x07010F02, 0x07010F02, 0x07010F02, /* 84 */
0x080F0102, 0x080F0102, 0x08000F01, 0x08000F01, 0x090F0001, /* 89 */
0x00000201, 0x00000206, 0x0000020B, 0x00000210, 0x00000215, /* 94 */
0x0000021A, 0x0000021F, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 99 */
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 104 */
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 109 */
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 114 */
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 119 */
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, /* 124 */
0x040F0F02, 0x040F0F02, 0x040F0F02, 0x040F0F02, 0x00000224, /* 129 */
0x00000229, 0x00000232, 0x00000237, 0x0000023A, 0x0000023F, /* 134 */
0x00000242, 0x00000245, 0x0000024A, 0x0000024D, 0x00000250, /* 139 */
0x00000253, 0x00000256, 0x00000259, 0x0000025C, 0x0000025F, /* 144 */
0x00000262, 0x00000265, 0x00000268, 0x0000026B, 0x0000026E, /* 149 */
0x00000271, 0x00000274, 0x00000277, 0x0000027A, 0x0000027D, /* 154 */
0x00000280, 0x00000283, 0x00000288, 0x0000028B, 0x0000028E, /* 159 */
0x00000291, 0x00000294, 0x00000297, 0x0000029A, 0x0000029F, /* 164 */
0x09040B02, 0x000002A4, 0x000002A7, 0x000002AA, 0x09030B02, /* 169 */
0x09080802, 0x000002AF, 0x09020B02, 0x000002B2, 0x000002B5, /* 174 */
0x09060902, 0x09040A02, 0x000002B8, 0x09070802, 0x090A0302, /* 179 */
0x09030A02, 0x09090502, 0x09050902, 0x090A0202, 0x09020A02, /* 184 */
0x09010A02, 0x09080602, 0x09060802, 0x09070702, 0x09090402, /* 189 */
0x09040902, 0x09090302, 0x09030902, 0x09080502, 0x09050802, /* 194 */
0x09090202, 0x09070602, 0x09060702, 0x09020902, 0x09090102, /* 199 */
0x09010902, 0x09080402, 0x09040802, 0x09070502, 0x09050702, /* 204 */
0x09080302, 0x09030802, 0x09060602, 0x09080202, 0x09020802, /* 209 */
0x09080102, 0x09070402, 0x09040702, 0x09010802, 0x000002BB, /* 214 */
0x09060502, 0x09050602, 0x09070102, 0x000002BE, 0x08030702, /* 219 */
0x08030702, 0x09070302, 0x09070202, 0x08020702, 0x08020702, /* 224 */
0x08060402, 0x08060402, 0x08040602, 0x08040602, 0x08050502, /* 229 */
0x08050502, 0x08010702, 0x08010702, 0x08060302, 0x08060302, /* 234 */
0x08030602, 0x08030602, 0x08050402, 0x08050402, 0x08040502, /* 239 */
0x08040502, 0x08060202, 0x08060202, 0x08020602, 0x08020602, /* 244 */
0x08060102, 0x08060102, 0x08010602, 0x08010602, 0x09060001, /* 249 */
0x09000601, 0x08050302, 0x08050302, 0x08030502, 0x08030502, /* 254 */
0x08040402, 0x08040402, 0x08050202, 0x08050202, 0x08020502, /* 259 */
0x08020502, 0x08050102, 0x08050102, 0x09050001, 0x09000501, /* 264 */
0x07010502, 0x07010502, 0x07010502, 0x07010502, 0x08040302, /* 269 */
0x08040302, 0x08030402, 0x08030402, 0x07040202, 0x07040202, /* 274 */
0x07040202, 0x07040202, 0x07020402, 0x07020402, 0x07020402, /* 279 */
0x07020402, 0x07030302, 0x07030302, 0x07030302, 0x07030302, /* 284 */
0x07040102, 0x07040102, 0x07040102, 0x07040102, 0x07010402, /* 289 */
0x07010402, 0x07010402, 0x07010402, 0x08040001, 0x08040001, /* 294 */
0x08000401, 0x08000401, 0x07030202, 0x07030202, 0x07030202, /* 299 */
0x07030202, 0x07020302, 0x07020302, 0x07020302, 0x07020302, /* 304 */
0x06030102, 0x06030102, 0x06030102, 0x06030102, 0x06030102, /* 309 */
0x06030102, 0x06030102, 0x06030102, 0x06010302, 0x06010302, /* 314 */
0x06010302, 0x06010302, 0x06010302, 0x06010302, 0x06010302, /* 319 */
0x06010302, 0x07030001, 0x07030001, 0x07030001, 0x07030001, /* 324 */
0x07000301, 0x07000301, 0x07000301, 0x07000301, 0x06020202, /* 329 */
0x06020202, 0x06020202, 0x06020202, 0x06020202, 0x06020202, /* 334 */
0x06020202, 0x06020202, 0x05020102, 0x05020102, 0x05020102, /* 339 */
0x05020102, 0x05020102, 0x05020102, 0x05020102, 0x05020102, /* 344 */
0x05020102, 0x05020102, 0x05020102, 0x05020102, 0x05020102, /* 349 */
0x05020102, 0x05020102, 0x05020102, 0x05010202, 0x05010202, /* 354 */
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 359 */
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x05010202, /* 364 */
0x05010202, 0x05010202, 0x05010202, 0x05010202, 0x06020001, /* 369 */
0x06020001, 0x06020001, 0x06020001, 0x06020001, 0x06020001, /* 374 */
0x06020001, 0x06020001, 0x06000201, 0x06000201, 0x06000201, /* 379 */
0x06000201, 0x06000201, 0x06000201, 0x06000201, 0x06000201, /* 384 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 389 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 394 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 399 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 404 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 409 */
0x04010102, 0x04010102, 0x04010102, 0x04010102, 0x04010102, /* 414 */
0x04010102, 0x04010102, 0x04010001, 0x04010001, 0x04010001, /* 419 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 424 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 429 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 434 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 439 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04010001, /* 444 */
0x04010001, 0x04010001, 0x04010001, 0x04010001, 0x04000101, /* 449 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 454 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 459 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 464 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 469 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 474 */
0x04000101, 0x04000101, 0x04000101, 0x04000101, 0x04000101, /* 479 */
0x04000101, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 484 */
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 489 */
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 494 */
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 499 */
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 504 */
0x04000000, 0x04000000, 0x04000000, 0x04000000, 0x04000000, /* 509 */
0x04000000, 0x04000000, 0x04000000, 0xFF000002, 0x020E0E02, /* 514 */
0x020E0D02, 0x020D0E02, 0x020E0C02, 0xFF000002, 0x020C0E02, /* 519 */
0x020D0D02, 0x020E0B02, 0x020B0E02, 0xFF000002, 0x020D0C02, /* 524 */
0x020C0D02, 0x020E0A02, 0x020A0E02, 0xFF000002, 0x020D0B02, /* 529 */
0x020B0D02, 0x020C0C02, 0x020E0902, 0xFF000002, 0x02090E02, /* 534 */
0x020D0A02, 0x020A0D02, 0x020C0B02, 0xFF000002, 0x020B0C02, /* 539 */
0x020E0802, 0x02080E02, 0x020D0902, 0xFF000002, 0x02090D02, /* 544 */
0x020E0702, 0x02070E02, 0x020C0A02, 0xFF000002, 0x020A0C02, /* 549 */
0x020B0B02, 0x020D0802, 0x02080D02, 0xFF000003, 0x030E0001, /* 554 */
0x03000E01, 0x020D0001, 0x020D0001, 0x01060E02, 0x01060E02, /* 559 */
0x01060E02, 0x01060E02, 0xFF000002, 0x020E0602, 0x020C0902, /* 564 */
0x01090C02, 0x01090C02, 0xFF000001, 0x010E0502, 0x010A0B02, /* 569 */
0xFF000002, 0x01050E02, 0x01050E02, 0x020B0A02, 0x020D0702, /* 574 */
0xFF000001, 0x01070D02, 0x01040E02, 0xFF000001, 0x010C0802, /* 579 */
0x01080C02, 0xFF000002, 0x020E0402, 0x020E0202, 0x010E0302, /* 584 */
0x010E0302, 0xFF000001, 0x010D0602, 0x01060D02, 0xFF000001, /* 589 */
0x01030E02, 0x010B0902, 0xFF000001, 0x01090B02, 0x010A0A02, /* 594 */
0xFF000001, 0x01020E02, 0x010E0102, 0xFF000001, 0x01010E02, /* 599 */
0x010D0502, 0xFF000001, 0x01050D02, 0x010C0702, 0xFF000001, /* 604 */
0x01070C02, 0x010D0402, 0xFF000001, 0x010B0802, 0x01080B02, /* 609 */
0xFF000001, 0x01040D02, 0x010A0902, 0xFF000001, 0x01090A02, /* 614 */
0x010C0602, 0xFF000001, 0x01060C02, 0x010D0302, 0xFF000001, /* 619 */
0x01030D02, 0x010D0202, 0xFF000001, 0x01020D02, 0x010D0102, /* 624 */
0xFF000001, 0x010B0702, 0x01070B02, 0xFF000001, 0x01010D02, /* 629 */
0x010C0502, 0xFF000001, 0x01050C02, 0x010A0802, 0xFF000001, /* 634 */
0x01080A02, 0x01090902, 0xFF000001, 0x010C0402, 0x01040C02, /* 639 */
0xFF000001, 0x010B0602, 0x01060B02, 0xFF000002, 0x02000D01, /* 644 */
0x020C0001, 0x010C0302, 0x010C0302, 0xFF000001, 0x01030C02, /* 649 */
0x010A0702, 0xFF000001, 0x01070A02, 0x010C0202, 0xFF000001, /* 654 */
0x01020C02, 0x010B0502, 0xFF000001, 0x01050B02, 0x010C0102, /* 659 */
0xFF000001, 0x01090802, 0x01080902, 0xFF000001, 0x01010C02, /* 664 */
0x010B0402, 0xFF000002, 0x02000C01, 0x020B0001, 0x010B0302, /* 669 */
0x010B0302, 0xFF000002, 0x02000B01, 0x020A0001, 0x010A0102, /* 674 */
0x010A0102, 0xFF000001, 0x010A0602, 0x01060A02, 0xFF000001, /* 679 */
0x01090702, 0x01070902, 0xFF000002, 0x02000A01, 0x02090001, /* 684 */
0x01000901, 0x01000901, 0xFF000001, 0x010B0202, 0x010A0502, /* 689 */
0xFF000001, 0x01050A02, 0x010B0102, 0xFF000001, 0x01010B02, /* 694 */
0x01090602, 0xFF000001, 0x010A0402, 0x01080702, 0xFF000001, /* 699 */
0x01080001, 0x01000801, 0xFF000001, 0x01070001, 0x01000701, /* 704 */ };
/* max table bits 9 */
/* NO XING TABLE 25 */
/* NO XING TABLE 26 */
/* NO XING TABLE 27 */
/* NO XING TABLE 28 */
/* NO XING TABLE 29 */
/* NO XING TABLE 30 */
/* NO XING TABLE 31 */
/* done */

265
programs/media/ac97 mp3/trunk/mp3dec/l3hybrid.c Normal file
View File

@ -0,0 +1,265 @@
#include <math.h>
extern int m_band_limit;
/* "imdct.c" */
void imdct18(float f[]); /* 18 point */
void imdct6_3(float f[]); /* 6 point */
/*-- windows by block type --*/
static float win[4][36];
void hwin_init()
{
int i, j;
double pi;
pi = 4.0 * atan(1.0);
/* type 0 */
for (i = 0; i < 36; i++)
win[0][i] = (float) sin(pi / 36 * (i + 0.5));
/* type 1 */
for (i = 0; i < 18; i++)
win[1][i] = (float) sin(pi / 36 * (i + 0.5));
for (i = 18; i < 24; i++)
win[1][i] = 1.0F;
for (i = 24; i < 30; i++)
win[1][i] = (float) sin(pi / 12 * (i + 0.5 - 18));
for (i = 30; i < 36; i++)
win[1][i] = 0.0F;
/* type 3 */
for (i = 0; i < 6; i++)
win[3][i] = 0.0F;
for (i = 6; i < 12; i++)
win[3][i] = (float) sin(pi / 12 * (i + 0.5 - 6));
for (i = 12; i < 18; i++)
win[3][i] = 1.0F;
for (i = 18; i < 36; i++)
win[3][i] = (float) sin(pi / 36 * (i + 0.5));
/* type 2 */
for (i = 0; i < 12; i++)
win[2][i] = (float) sin(pi / 12 * (i + 0.5));
for (i = 12; i < 36; i++)
win[2][i] = 0.0F;
/*--- invert signs by region to match mdct 18pt --> 36pt mapping */
for (j = 0; j < 4; j++)
{
if (j == 2)
continue;
for (i = 9; i < 36; i++)
win[j][i] = -win[j][i];
}
/*-- invert signs for short blocks --*/
for (i = 3; i < 12; i++)
win[2][i] = -win[2][i];
return;
}
/*====================================================================*/
int hybrid(float xin[], float xprev[], float y[18][32],
int btype, int nlong, int ntot, int nprev)
{
int i, j;
float *x, *x0;
float xa, xb;
int n;
int nout;
int band_limit_nsb;
if (btype == 2)
btype = 0;
x = xin;
x0 = xprev;
/*-- do long blocks (if any) --*/
n = (nlong + 17) / 18; /* number of dct's to do */
for (i = 0; i < n; i++)
{
imdct18(x);
for (j = 0; j < 9; j++)
{
y[j][i] = x0[j] + win[btype][j] * x[9 + j];
y[9 + j][i] = x0[9 + j] + win[btype][9 + j] * x[17 - j];
}
/* window x for next time x0 */
for (j = 0; j < 4; j++)
{
xa = x[j];
xb = x[8 - j];
x[j] = win[btype][18 + j] * xb;
x[8 - j] = win[btype][(18 + 8) - j] * xa;
x[9 + j] = win[btype][(18 + 9) + j] * xa;
x[17 - j] = win[btype][(18 + 17) - j] * xb;
}
xa = x[j];
x[j] = win[btype][18 + j] * xa;
x[9 + j] = win[btype][(18 + 9) + j] * xa;
x += 18;
x0 += 18;
}
/*-- do short blocks (if any) --*/
n = (ntot + 17) / 18; /* number of 6 pt dct's triples to do */
for (; i < n; i++)
{
imdct6_3(x);
for (j = 0; j < 3; j++)
{
y[j][i] = x0[j];
y[3 + j][i] = x0[3 + j];
y[6 + j][i] = x0[6 + j] + win[2][j] * x[3 + j];
y[9 + j][i] = x0[9 + j] + win[2][3 + j] * x[5 - j];
y[12 + j][i] = x0[12 + j] + win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
y[15 + j][i] = x0[15 + j] + win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
}
/* window x for next time x0 */
for (j = 0; j < 3; j++)
{
x[j] = win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
x[3 + j] = win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
}
for (j = 0; j < 3; j++)
{
x[6 + j] = win[2][6 + j] * x[(12 + 2) - j];
x[9 + j] = win[2][9 + j] * x[12 + j];
}
for (j = 0; j < 3; j++)
{
x[12 + j] = 0.0f;
x[15 + j] = 0.0f;
}
x += 18;
x0 += 18;
}
/*--- overlap prev if prev longer that current --*/
n = (nprev + 17) / 18;
for (; i < n; i++)
{
for (j = 0; j < 18; j++)
y[j][i] = x0[j];
x0 += 18;
}
nout = 18 * i;
/*--- clear remaining only to band limit --*/
band_limit_nsb = (m_band_limit + 17) / 18; /* limit nsb's rounded up */
for (; i < band_limit_nsb; i++)
{
for (j = 0; j < 18; j++)
y[j][i] = 0.0f;
}
return nout;
}
/*--------------------------------------------------------------------*/
/*--------------------------------------------------------------------*/
/*-- convert to mono, add curr result to y,
window and add next time to current left */
int hybrid_sum(float xin[], float xin_left[], float y[18][32],
int btype, int nlong, int ntot)
{
int i, j;
float *x, *x0;
float xa, xb;
int n;
int nout;
if (btype == 2)
btype = 0;
x = xin;
x0 = xin_left;
/*-- do long blocks (if any) --*/
n = (nlong + 17) / 18; /* number of dct's to do */
for (i = 0; i < n; i++)
{
imdct18(x);
for (j = 0; j < 9; j++)
{
y[j][i] += win[btype][j] * x[9 + j];
y[9 + j][i] += win[btype][9 + j] * x[17 - j];
}
/* window x for next time x0 */
for (j = 0; j < 4; j++)
{
xa = x[j];
xb = x[8 - j];
x0[j] += win[btype][18 + j] * xb;
x0[8 - j] += win[btype][(18 + 8) - j] * xa;
x0[9 + j] += win[btype][(18 + 9) + j] * xa;
x0[17 - j] += win[btype][(18 + 17) - j] * xb;
}
xa = x[j];
x0[j] += win[btype][18 + j] * xa;
x0[9 + j] += win[btype][(18 + 9) + j] * xa;
x += 18;
x0 += 18;
}
/*-- do short blocks (if any) --*/
n = (ntot + 17) / 18; /* number of 6 pt dct's triples to do */
for (; i < n; i++)
{
imdct6_3(x);
for (j = 0; j < 3; j++)
{
y[6 + j][i] += win[2][j] * x[3 + j];
y[9 + j][i] += win[2][3 + j] * x[5 - j];
y[12 + j][i] += win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
y[15 + j][i] += win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
}
/* window x for next time */
for (j = 0; j < 3; j++)
{
x0[j] += win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
x0[3 + j] += win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
}
for (j = 0; j < 3; j++)
{
x0[6 + j] += win[2][6 + j] * x[(12 + 2) - j];
x0[9 + j] += win[2][9 + j] * x[12 + j];
}
x += 18;
x0 += 18;
}
nout = 18 * i;
return nout;
}
/*--------------------------------------------------------------------*/
void sum_f_bands(float a[], float b[], int n)
{
int i;
for (i = 0; i < n; i++)
a[i] += b[i];
}
/*--------------------------------------------------------------------*/
void freq_invert(float y[18][32], int n)
{
int i, j;
n = (n + 17) / 18;
for (j = 0; j < 18; j += 2)
{
for (i = 0; i < n; i += 2)
{
y[1 + j][1 + i] = -y[1 + j][1 + i];
}
}
}
/*--------------------------------------------------------------------*/

212
programs/media/ac97 mp3/trunk/mp3dec/l3init.c Normal file
View File

@ -0,0 +1,212 @@
#include "layer3.h"
extern MPEG_DECODE_OPTION m_option;
extern SAMPLE m_sample[2][2][576];
extern int m_frequency;
extern SBT_PROC m_sbt_proc;
extern XFORM_PROC m_xform_proc;
extern int m_channels;
extern int m_sfBandIndex[2][22];// [long/short][cb]
extern int m_nBand[2][22];
extern int m_band_limit;
extern int m_band_limit21; // limit for sf band 21
extern int m_band_limit12; // limit for sf band 12 short
extern int m_band_limit_nsb;
extern int m_ncbl_mixed;
extern int m_nsb_limit;
extern int m_gr;
extern int m_buf_ptr0, m_buf_ptr1;
extern float m_yout[576];
//extern "l3sbt.c"
void sbt_mono_L3(float *sample, signed short *pcm, int ch);
void sbt_dual_L3(float *sample, signed short *pcm, int ch);
void sbt16_mono_L3(float *sample, signed short *pcm, int ch);
void sbt16_dual_L3(float *sample, signed short *pcm, int ch);
void sbt8_mono_L3(float *sample, signed short *pcm, int ch);
void sbt8_dual_L3(float *sample, signed short *pcm, int ch);
void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch);
void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch);
void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch);
void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch);
void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch);
void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch);
//extern "l3dec.c"
void xform_mono(void *pcm, int igr);
void xform_dual(void *pcm, int igr);
void xform_dual_mono(void *pcm, int igr);
void xform_dual_right(void *pcm, int igr);
static const SBT_PROC sbt_table[2][3][2] =
{
sbt_mono_L3,
sbt_dual_L3,
sbt16_mono_L3,
sbt16_dual_L3,
sbt8_mono_L3,
sbt8_dual_L3,
// 8 bit output
sbtB_mono_L3,
sbtB_dual_L3,
sbtB16_mono_L3,
sbtB16_dual_L3,
sbtB8_mono_L3,
sbtB8_dual_L3,
};
static const XFORM_PROC xform_table[5] =
{
xform_mono,
xform_dual,
xform_dual_mono,
xform_mono, /* left */
xform_dual_right,
};
static const struct {
int l[23];
int s[14];
} sfBandTable[3][3] = {
// MPEG-1
{{
{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},
{0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192}
},{
{0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},
{0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192}
},{
{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},
{0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192}
}},
// MPEG-2
{{
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
{0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192}
},{
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192}
},{
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
}},
// MPEG-2.5, 11 & 12 KHz seem ok, 8 ok
{{
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
},{
{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
{0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
},{
// this 8khz table, and only 8khz, from mpeg123)
{0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},
{0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192}
}},
};
void quant_init();
void alias_init();
void msis_init();
void fdct_init();
void imdct_init();
void hwin_init();
void L3table_init()
{
quant_init();
alias_init();
msis_init();
fdct_init();
imdct_init();
hwin_init();
}
int L3decode_start(MPEG_HEADER* h)
{
int i, j, k, v;
int channels, limit;
int bit_code;
m_buf_ptr0 = 0;
m_buf_ptr1 = 0;
m_gr = 0;
v = h->version - 1;
if (h->version == 1) //MPEG-1
m_ncbl_mixed = 8;
else //MPEG-2, MPEG-2.5
m_ncbl_mixed = 6;
// compute nsb_limit
m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
// caller limit
limit = (32 >> m_option.reduction);
if (limit > 8)
limit--;
if (m_nsb_limit > limit)
m_nsb_limit = limit;
limit = 18 * m_nsb_limit;
if (h->version == 1) {
//MPEG-1
m_band_limit12 = 3 * sfBandTable[v][h->fr_index].s[13];
m_band_limit = m_band_limit21 = sfBandTable[v][h->fr_index].l[22];
}
else {
//MPEG-2, MPEG-2.5
m_band_limit12 = 3 * sfBandTable[v][h->fr_index].s[12];
m_band_limit = m_band_limit21 = sfBandTable[v][h->fr_index].l[21];
}
m_band_limit += 8; // allow for antialias
if (m_band_limit > limit)
m_band_limit = limit;
if (m_band_limit21 > m_band_limit)
m_band_limit21 = m_band_limit;
if (m_band_limit12 > m_band_limit)
m_band_limit12 = m_band_limit;
m_band_limit_nsb = (m_band_limit + 17) / 18; // limit nsb's rounded up
/*
gain_adjust = 0; // adjust gain e.g. cvt to mono sum channel
if ((h->mode != 3) && (m_option.convert == 1))
gain_adjust = -4;
*/
m_channels = (h->mode == 3) ? 1 : 2;
if (m_option.convert) channels = 1;
else channels = m_channels;
bit_code = (m_option.convert & 8) ? 1 : 0;
m_sbt_proc = sbt_table[bit_code][m_option.reduction][channels - 1];//[2][3][2]
k = (h->mode != 3) ? (1 + m_option.convert) : 0;
m_xform_proc = xform_table[k];//[5]
/*
if (bit_code)
zero_level_pcm = 128;// 8 bit output
else
zero_level_pcm = 0;
*/
// init band tables
for (i = 0; i < 22; i ++)
m_sfBandIndex[0][i] = sfBandTable[v][h->fr_index].l[i + 1];
for (i = 0; i < 13; i ++)
m_sfBandIndex[1][i] = 3 * sfBandTable[v][h->fr_index].s[i + 1];
for (i = 0; i < 22; i ++)
m_nBand[0][i] = sfBandTable[v][h->fr_index].l[i + 1]
- sfBandTable[v][h->fr_index].l[i];
for (i = 0; i < 13; i ++)
m_nBand[1][i] = sfBandTable[v][h->fr_index].s[i + 1]
- sfBandTable[v][h->fr_index].s[i];
// clear buffers
for (i = 0; i < 576; i++)
m_yout[i] = 0.0f;
for (i = 0; i < 2; i ++)
{ for (j = 0; j < 2; j ++)
{ for (k = 0; k < 576; k++)
{ m_sample[i][j][k].x = 0.0f;
m_sample[i][j][k].s = 0;
}
}
}
return 1;
}

332
programs/media/ac97 mp3/trunk/mp3dec/l3msis.c Normal file
View File

@ -0,0 +1,332 @@
#include "layer3.h"
#include <math.h>
//#include <windows.h>
extern IS_SF_INFO m_is_sf_info;
extern int m_ms_mode, m_is_mode;
extern int m_sfBandIndex[2][22];// [long/short][cb]
extern int m_nBand[2][22];
/* intensity stereo */
/* if ms mode quant pre-scales all values by 1.0/sqrt(2.0) ms_mode in table
compensates */
/* [ms_mode 0/1][sf][left/right] */
static float lr[2][8][2];
/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
static float lr2[2][2][64][2];
/*-------*msis_init_addr()
pi = 4.0*atan(1.0);
t = pi/12.0;
for(i=0;i<7;i++) {
s = sin(i*t);
c = cos(i*t);
// ms_mode = 0
lr[0][i][0] = (float)(s/(s+c));
lr[0][i][1] = (float)(c/(s+c));
// ms_mode = 1
lr[1][i][0] = (float)(sqrt(2.0)*(s/(s+c)));
lr[1][i][1] = (float)(sqrt(2.0)*(c/(s+c)));
}
//sf = 7
//ms_mode = 0
lr[0][i][0] = 1.0f;
lr[0][i][1] = 0.0f;
// ms_mode = 1, in is bands is routine does ms processing
lr[1][i][0] = 1.0f;
lr[1][i][1] = 1.0f;
------------*/
/*===============================================================*/
void msis_init1()
{
int i;
double s, c;
double pi;
double t;
pi = 4.0 * atan(1.0);
t = pi / 12.0;
for (i = 0; i < 7; i++)
{
s = sin(i * t);
c = cos(i * t);
/* ms_mode = 0 */
lr[0][i][0] = (float) (s / (s + c));
lr[0][i][1] = (float) (c / (s + c));
/* ms_mode = 1 */
lr[1][i][0] = (float) (sqrt(2.0) * (s / (s + c)));
lr[1][i][1] = (float) (sqrt(2.0) * (c / (s + c)));
}
/* sf = 7 */
/* ms_mode = 0 */
lr[0][i][0] = 1.0f;
lr[0][i][1] = 0.0f;
/* ms_mode = 1, in is bands is routine does ms processing */
lr[1][i][0] = 1.0f;
lr[1][i][1] = 1.0f;
/*-------
for(i=0;i<21;i++) m_nBand[0][i] =
sfBandTable[sr_index].l[i+1] - sfBandTable[sr_index].l[i];
for(i=0;i<12;i++) m_nBand[1][i] =
sfBandTable[sr_index].s[i+1] - sfBandTable[sr_index].s[i];
-------------*/
}
/*===============================================================*/
void msis_init2()
{
int k, n;
double t;
int intensity_scale, ms_mode, sf, sflen;
float ms_factor[2];
ms_factor[0] = 1.0;
ms_factor[1] = (float) sqrt(2.0);
/* intensity stereo MPEG2 */
/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
for (intensity_scale = 0; intensity_scale < 2; intensity_scale++)
{
t = pow_test(2.0, -0.25 * (1 + intensity_scale));
for (ms_mode = 0; ms_mode < 2; ms_mode++)
{
n = 1;
k = 0;
for (sflen = 0; sflen < 6; sflen++)
{
for (sf = 0; sf < (n - 1); sf++, k++)
{
if (sf == 0)
{
lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
}
else if ((sf & 1))
{
lr2[intensity_scale][ms_mode][k][0] =
(float) (ms_factor[ms_mode] * pow_test(t, (sf + 1) / 2));
lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
}
else
{
lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
lr2[intensity_scale][ms_mode][k][1] =
(float) (ms_factor[ms_mode] * pow_test(t, sf / 2));
}
}
/* illegal is_pos used to do ms processing */
if (ms_mode == 0)
{ /* ms_mode = 0 */
lr2[intensity_scale][ms_mode][k][0] = 1.0f;
lr2[intensity_scale][ms_mode][k][1] = 0.0f;
}
else
{
/* ms_mode = 1, in is bands is routine does ms processing */
lr2[intensity_scale][ms_mode][k][0] = 1.0f;
lr2[intensity_scale][ms_mode][k][1] = 1.0f;
}
k++;
n = n + n;
}
}
}
}
void msis_init()
{
msis_init1();
msis_init2();
}
/*===============================================================*/
void ms_process(float x[][1152], int n) /* sum-difference stereo */
{
int i;
float xl, xr;
/*-- note: sqrt(2) done scaling by dequant ---*/
for (i = 0; i < n; i++)
{
xl = x[0][i] + x[1][i];
xr = x[0][i] - x[1][i];
x[0][i] = xl;
x[1][i] = xr;
}
return;
}
void is_process1(float x[][1152], /* intensity stereo */
SCALE_FACTOR* sf,
CB_INFO cb_info[2], /* [ch] */
int nsamp)
{
int i, j, n, cb, w;
float fl, fr;
int m;
int isf;
float fls[3], frs[3];
int cb0;
cb0 = cb_info[1].cbmax; /* start at end of right */
i = m_sfBandIndex[cb_info[1].cbtype][cb0];
cb0++;
m = nsamp - i; /* process to len of left */
if (cb_info[1].cbtype)
goto short_blocks;
/*------------------------*/
/* long_blocks: */
for (cb = cb0; cb < 21; cb++)
{
isf = sf->l[cb];
n = m_nBand[0][cb];
fl = lr[m_ms_mode][isf][0];
fr = lr[m_ms_mode][isf][1];
for (j = 0; j < n; j++, i++)
{
if (--m < 0)
goto exit;
x[1][i] = fr * x[0][i];
x[0][i] = fl * x[0][i];
}
}
return;
/*------------------------*/
short_blocks:
for (cb = cb0; cb < 12; cb++)
{
for (w = 0; w < 3; w++)
{
isf = sf->s[w][cb];
fls[w] = lr[m_ms_mode][isf][0];
frs[w] = lr[m_ms_mode][isf][1];
}
n = m_nBand[1][cb];
for (j = 0; j < n; j++)
{
m -= 3;
if (m < 0)
goto exit;
x[1][i] = frs[0] * x[0][i];
x[0][i] = fls[0] * x[0][i];
x[1][1 + i] = frs[1] * x[0][1 + i];
x[0][1 + i] = fls[1] * x[0][1 + i];
x[1][2 + i] = frs[2] * x[0][2 + i];
x[0][2 + i] = fls[2] * x[0][2 + i];
i += 3;
}
}
exit:
return;
}
typedef float ARRAY2[2];
void is_process2(float x[][1152], /* intensity stereo */
SCALE_FACTOR* sf,
CB_INFO cb_info[2], /* [ch] */
int nsamp)
{
int i, j, k, n, cb, w;
float fl, fr;
int m;
int isf;
int il[21];
int tmp;
int r;
ARRAY2 *lr;
int cb0, cb1;
lr = lr2[m_is_sf_info.intensity_scale][m_ms_mode];
if (cb_info[1].cbtype)
goto short_blocks;
/*------------------------*/
/* long_blocks: */
cb0 = cb_info[1].cbmax; /* start at end of right */
i = m_sfBandIndex[0][cb0];
m = nsamp - i; /* process to len of left */
/* gen sf info */
for (k = r = 0; r < 3; r++)
{
tmp = (1 << m_is_sf_info.slen[r]) - 1;
for (j = 0; j < m_is_sf_info.nr[r]; j++, k++)
il[k] = tmp;
}
for (cb = cb0 + 1; cb < 21; cb++)
{
isf = il[cb] + sf->l[cb];
// X-MaD 27-02-02
if (isf < 0) { isf = 0; }
fl = 0;
fr = 0;
//try
//{
fl = lr[isf][0];
fr = lr[isf][1];
n = m_nBand[0][cb];
//}
//catch(...)
//{
// isf = 0;
//}
// X-MaD 27-02-02
for (j = 0; j < n; j++, i++)
{
if (--m < 0)
{
goto exit;
}
x[1][i] = fr * x[0][i];
x[0][i] = fl * x[0][i];
}
}
return;
/*------------------------*/
short_blocks:
for (k = r = 0; r < 3; r++)
{
tmp = (1 << m_is_sf_info.slen[r]) - 1;
for (j = 0; j < m_is_sf_info.nr[r]; j++, k++)
il[k] = tmp;
}
for (w = 0; w < 3; w++)
{
cb0 = cb_info[1].cbmax_s[w]; /* start at end of right */
i = m_sfBandIndex[1][cb0] + w;
cb1 = cb_info[0].cbmax_s[w]; /* process to end of left */
for (cb = cb0 + 1; cb <= cb1; cb++)
{
isf = il[cb] + sf->s[w][cb];
fl = lr[isf][0];
fr = lr[isf][1];
n = m_nBand[1][cb];
for (j = 0; j < n; j++)
{
x[1][i] = fr * x[0][i];
x[0][i] = fl * x[0][i];
i += 3;
}
}
}
exit:
return;
}

217
programs/media/ac97 mp3/trunk/mp3dec/l3quant.c Normal file
View File

@ -0,0 +1,217 @@
#include "layer3.h"
#include <math.h>
#include <string.h> //memmove
extern SIDE_INFO m_side_info;
extern SCALE_FACTOR m_scale_fac[2][2]; // [gr][ch]
extern CB_INFO m_cb_info[2][2]; // [gr][ch]
extern int m_nsamp[2][2];
extern int m_nBand[2][22];
extern int m_ncbl_mixed;
#define GLOBAL_GAIN_SCALE (4*15)
static const int pretab[2][22] =
{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0},
};
/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
/* two extra slots to do 1/sqrt(2) scaling for ms */
/* 4 extra slots to do 1/2 scaling for cvt to mono */
static float look_global[256 + 2 + 4];
/*-------- scaling lookup
x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp)
look_scale[scalefact_scale][preemp][scalefac]
-----------------------*/
static float look_scale[2][4][32];
/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
#define ISMAX 32
static float look_pow[2 * ISMAX];
/*-- pow(2.0, -0.25*8.0*subblock_gain) --*/
static float look_subblock[8];
/*-- reorder buffer ---*/
static float re_buf[192][3];
typedef float ARRAY3[3];
void quant_init()
{
int i;
int scalefact_scale, preemp, scalefac;
double tmp;
/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
/* extra 2 for ms scaling by 1/sqrt(2) */
/* extra 4 for cvt to mono scaling by 1/2 */
for (i = 0; i < 256 + 2 + 4; i++)
look_global[i] = (float) pow_test(2.0, 0.25 * ((i - (2 + 4)) - 210 + GLOBAL_GAIN_SCALE));
/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
for (scalefact_scale = 0; scalefact_scale < 2; scalefact_scale++)
{
for (preemp = 0; preemp < 4; preemp++)
{
for (scalefac = 0; scalefac < 32; scalefac++)
{
look_scale[scalefact_scale][preemp][scalefac] =
(float) pow_test(2.0, -0.5 * (1 + scalefact_scale) * (scalefac + preemp));
}
}
}
/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
for (i = 0; i < 64; i++)
{
tmp = i - 32;
look_pow[i] = (float) (tmp * pow_test(fabs(tmp), (1.0 / 3.0)));
}
/*-- pow(2.0, -0.25*8.0*subblock_gain) 3 bits --*/
for (i = 0; i < 8; i++)
{
look_subblock[i] = (float) pow_test(2.0, 0.25 * -8.0 * i);
}
// quant_init_sf_band(sr_index); replaced by code in sup.c
}
void dequant(SAMPLE Sample[], int gr, int ch)
{
SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
GR_INFO* gr_info = &m_side_info.gr[gr][ch];
CB_INFO* cb_info = &m_cb_info[gr][ch];
int* nsamp = &m_nsamp[gr][ch];
int i, j;
int cb, n, w;
float x0, xs;
float xsb[3];
double tmp;
int ncbl;
int cbs0;
ARRAY3 *buf; /* short block reorder */
int nbands;
int i0;
int non_zero;
int cbmax[3];
nbands = *nsamp;
ncbl = 22; /* long block cb end */
cbs0 = 12; /* short block cb start */
/* ncbl_mixed = 8 or 6 mpeg1 or 2 */
if (gr_info->block_type == 2)
{
ncbl = 0;
cbs0 = 0;
if (gr_info->mixed_block_flag)
{
ncbl = m_ncbl_mixed;
cbs0 = 3;
}
}
/* fill in cb_info -- */
cb_info->lb_type = gr_info->block_type;
if (gr_info->block_type == 2)
cb_info->lb_type;
cb_info->cbs0 = cbs0;
cb_info->ncbl = ncbl;
cbmax[2] = cbmax[1] = cbmax[0] = 0;
/* global gain pre-adjusted by 2 if ms_mode, 0 otherwise */
x0 = look_global[(2 + 4) + gr_info->global_gain];
i = 0;
/*----- long blocks ---*/
for (cb = 0; cb < ncbl; cb++)
{
non_zero = 0;
xs = x0 * look_scale[gr_info->scalefac_scale][pretab[gr_info->preflag][cb]][sf->l[cb]];
n = m_nBand[0][cb];
for (j = 0; j < n; j++, i++)
{
if (Sample[i].s == 0)
Sample[i].x = 0.0F;
else
{
non_zero = 1;
if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
Sample[i].x = xs * look_pow[ISMAX + Sample[i].s];
else
{
tmp = (double) Sample[i].s;
Sample[i].x = (float) (xs * tmp * pow_test(fabs(tmp), (1.0 / 3.0)));
}
}
}
if (non_zero)
cbmax[0] = cb;
if (i >= nbands)
break;
}
cb_info->cbmax = cbmax[0];
cb_info->cbtype = 0; // type = long
if (cbs0 >= 12)
return;
/*---------------------------
block type = 2 short blocks
----------------------------*/
cbmax[2] = cbmax[1] = cbmax[0] = cbs0;
i0 = i; /* save for reorder */
buf = re_buf;
for (w = 0; w < 3; w++)
xsb[w] = x0 * look_subblock[gr_info->subblock_gain[w]];
for (cb = cbs0; cb < 13; cb++)
{
n = m_nBand[1][cb];
for (w = 0; w < 3; w++)
{
non_zero = 0;
xs = xsb[w] * look_scale[gr_info->scalefac_scale][0][sf->s[w][cb]];
for (j = 0; j < n; j++, i++)
{
if (Sample[i].s == 0)
buf[j][w] = 0.0F;
else
{
non_zero = 1;
if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
buf[j][w] = xs * look_pow[ISMAX + Sample[i].s];
else
{
tmp = (double) Sample[i].s;
buf[j][w] = (float) (xs * tmp * pow_test(fabs(tmp), (1.0 / 3.0)));
}
}
}
if (non_zero)
cbmax[w] = cb;
}
if (i >= nbands)
break;
buf += n;
}
memmove(&Sample[i0].x, &re_buf[0][0], sizeof(float) * (i - i0));
*nsamp = i; /* update nsamp */
cb_info->cbmax_s[0] = cbmax[0];
cb_info->cbmax_s[1] = cbmax[1];
cb_info->cbmax_s[2] = cbmax[2];
if (cbmax[1] > cbmax[0])
cbmax[0] = cbmax[1];
if (cbmax[2] > cbmax[0])
cbmax[0] = cbmax[2];
cb_info->cbmax = cbmax[0];
cb_info->cbtype = 1; /* type = short */
}

353
programs/media/ac97 mp3/trunk/mp3dec/l3sf.c Normal file
View File

@ -0,0 +1,353 @@
#include "layer3.h"
extern SIDE_INFO m_side_info;
extern SCALE_FACTOR m_scale_fac[2][2]; // [gr][ch]
extern IS_SF_INFO m_is_sf_info;
extern int m_is_mode;
static const int slen_table[16][2] =
{
0, 0, 0, 1,
0, 2, 0, 3,
3, 0, 1, 1,
1, 2, 1, 3,
2, 1, 2, 2,
2, 3, 3, 1,
3, 2, 3, 3,
4, 2, 4, 3,
};
/* nr_table[size+3*is_right][block type 0,1,3 2, 2+mixed][4] */
/* for bt=2 nr is count for group of 3 */
static const int nr_table[6][3][4] =
{
6, 5, 5, 5,
3, 3, 3, 3,
6, 3, 3, 3,
6, 5, 7, 3,
3, 3, 4, 2,
6, 3, 4, 2,
11, 10, 0, 0,
6, 6, 0, 0,
6, 3, 6, 0, /* adjusted *//* 15, 18, 0, 0, */
/*-intensity stereo right chan--*/
7, 7, 7, 0,
4, 4, 4, 0,
6, 5, 4, 0,
6, 6, 6, 3,
4, 3, 3, 2,
6, 4, 3, 2,
8, 8, 5, 0,
5, 4, 3, 0,
6, 6, 3, 0,
};
void L3get_scale_factor1(int gr, int ch)
{
SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
GR_INFO* grdat = &m_side_info.gr[gr][ch];
int scfsi = m_side_info.scfsi[ch];
int sfb;
int slen0, slen1;
int block_type, mixed_block_flag, scalefac_compress;
block_type = grdat->block_type;
mixed_block_flag = grdat->mixed_block_flag;
scalefac_compress = grdat->scalefac_compress;
slen0 = slen_table[scalefac_compress][0];
slen1 = slen_table[scalefac_compress][1];
if (block_type == 2) {
if (mixed_block_flag) { /* mixed */
for (sfb = 0; sfb < 8; sfb++)
sf[0].l[sfb] = bitget(slen0);
for (sfb = 3; sfb < 6; sfb++) {
sf[0].s[0][sfb] = bitget(slen0);
sf[0].s[1][sfb] = bitget(slen0);
sf[0].s[2][sfb] = bitget(slen0);
}
for (sfb = 6; sfb < 12; sfb++) {
sf[0].s[0][sfb] = bitget(slen1);
sf[0].s[1][sfb] = bitget(slen1);
sf[0].s[2][sfb] = bitget(slen1);
}
return;
}
for (sfb = 0; sfb < 6; sfb++) {
sf[0].s[0][sfb] = bitget(slen0);
sf[0].s[1][sfb] = bitget(slen0);
sf[0].s[2][sfb] = bitget(slen0);
}
for (; sfb < 12; sfb++) {
sf[0].s[0][sfb] = bitget(slen1);
sf[0].s[1][sfb] = bitget(slen1);
sf[0].s[2][sfb] = bitget(slen1);
}
return;
}
/* long blocks types 0 1 3, first granule */
if (gr == 0)
{
for (sfb = 0; sfb < 11; sfb++)
sf[0].l[sfb] = bitget(slen0);
for (; sfb < 21; sfb++)
sf[0].l[sfb] = bitget(slen1);
return;
}
/* long blocks 0, 1, 3, second granule */
sfb = 0;
if (scfsi & 8)
for (; sfb < 6; sfb++)
sf[0].l[sfb] = sf[-2].l[sfb];
else
for (; sfb < 6; sfb++)
sf[0].l[sfb] = bitget(slen0);
if (scfsi & 4)
for (; sfb < 11; sfb++)
sf[0].l[sfb] = sf[-2].l[sfb];
else
for (; sfb < 11; sfb++)
sf[0].l[sfb] = bitget(slen0);
if (scfsi & 2)
for (; sfb < 16; sfb++)
sf[0].l[sfb] = sf[-2].l[sfb];
else
for (; sfb < 16; sfb++)
sf[0].l[sfb] = bitget(slen1);
if (scfsi & 1)
for (; sfb < 21; sfb++)
sf[0].l[sfb] = sf[-2].l[sfb];
else
for (; sfb < 21; sfb++)
sf[0].l[sfb] = bitget(slen1);
}
void L3get_scale_factor2(int gr, int ch)
{
SCALE_FACTOR* sf = &m_scale_fac[gr][ch];
GR_INFO* grdat = &m_side_info.gr[gr][ch];
int is_and_ch = m_is_mode & ch;
int sfb;
int slen1, slen2, slen3, slen4;
int nr1, nr2, nr3, nr4;
int i, k;
int preflag, intensity_scale;
int block_type, mixed_block_flag, scalefac_compress;
block_type = grdat->block_type;
mixed_block_flag = grdat->mixed_block_flag;
scalefac_compress = grdat->scalefac_compress;
preflag = 0;
intensity_scale = 0; /* to avoid compiler warning */
if (is_and_ch == 0)
{
if (scalefac_compress < 400)
{
slen2 = scalefac_compress >> 4;
slen1 = slen2 / 5;
slen2 = slen2 % 5;
slen4 = scalefac_compress & 15;
slen3 = slen4 >> 2;
slen4 = slen4 & 3;
k = 0;
}
else if (scalefac_compress < 500)
{
scalefac_compress -= 400;
slen2 = scalefac_compress >> 2;
slen1 = slen2 / 5;
slen2 = slen2 % 5;
slen3 = scalefac_compress & 3;
slen4 = 0;
k = 1;
}
else
{
scalefac_compress -= 500;
slen1 = scalefac_compress / 3;
slen2 = scalefac_compress % 3;
slen3 = slen4 = 0;
if (mixed_block_flag)
{
slen3 = slen2; /* adjust for long/short mix logic */
slen2 = slen1;
}
preflag = 1;
k = 2;
}
}
else
{ /* intensity stereo ch = 1 (right) */
intensity_scale = scalefac_compress & 1;
scalefac_compress >>= 1;
if (scalefac_compress < 180)
{
slen1 = scalefac_compress / 36;
slen2 = scalefac_compress % 36;
slen3 = slen2 % 6;
slen2 = slen2 / 6;
slen4 = 0;
k = 3 + 0;
}
else if (scalefac_compress < 244)
{
scalefac_compress -= 180;
slen3 = scalefac_compress & 3;
scalefac_compress >>= 2;
slen2 = scalefac_compress & 3;
slen1 = scalefac_compress >> 2;
slen4 = 0;
k = 3 + 1;
}
else
{
scalefac_compress -= 244;
slen1 = scalefac_compress / 3;
slen2 = scalefac_compress % 3;
slen3 = slen4 = 0;
k = 3 + 2;
}
}
i = 0;
if (block_type == 2)
i = (mixed_block_flag & 1) + 1;
nr1 = nr_table[k][i][0];
nr2 = nr_table[k][i][1];
nr3 = nr_table[k][i][2];
nr4 = nr_table[k][i][3];
/* return is scale factor info (for right chan is mode) */
if (is_and_ch)
{
m_is_sf_info.nr[0] = nr1;
m_is_sf_info.nr[1] = nr2;
m_is_sf_info.nr[2] = nr3;
m_is_sf_info.slen[0] = slen1;
m_is_sf_info.slen[1] = slen2;
m_is_sf_info.slen[2] = slen3;
m_is_sf_info.intensity_scale = intensity_scale;
}
grdat->preflag = preflag; /* return preflag */
/*--------------------------------------*/
if (block_type == 2)
{
if (mixed_block_flag)
{ /* mixed */
if (slen1 != 0) /* long block portion */
for (sfb = 0; sfb < 6; sfb++)
sf[0].l[sfb] = bitget(slen1);
else
for (sfb = 0; sfb < 6; sfb++)
sf[0].l[sfb] = 0;
sfb = 3; /* start sfb for short */
}
else
{ /* all short, initial short blocks */
sfb = 0;
if (slen1 != 0)
for (i = 0; i < nr1; i++, sfb++)
{
sf[0].s[0][sfb] = bitget(slen1);
sf[0].s[1][sfb] = bitget(slen1);
sf[0].s[2][sfb] = bitget(slen1);
}
else
for (i = 0; i < nr1; i++, sfb++)
{
sf[0].s[0][sfb] = 0;
sf[0].s[1][sfb] = 0;
sf[0].s[2][sfb] = 0;
}
}
/* remaining short blocks */
if (slen2 != 0)
for (i = 0; i < nr2; i++, sfb++)
{
sf[0].s[0][sfb] = bitget(slen2);
sf[0].s[1][sfb] = bitget(slen2);
sf[0].s[2][sfb] = bitget(slen2);
}
else
for (i = 0; i < nr2; i++, sfb++)
{
sf[0].s[0][sfb] = 0;
sf[0].s[1][sfb] = 0;
sf[0].s[2][sfb] = 0;
}
if (slen3 != 0)
for (i = 0; i < nr3; i++, sfb++)
{
sf[0].s[0][sfb] = bitget(slen3);
sf[0].s[1][sfb] = bitget(slen3);
sf[0].s[2][sfb] = bitget(slen3);
}
else
for (i = 0; i < nr3; i++, sfb++)
{
sf[0].s[0][sfb] = 0;
sf[0].s[1][sfb] = 0;
sf[0].s[2][sfb] = 0;
}
if (slen4 != 0)
for (i = 0; i < nr4; i++, sfb++)
{
sf[0].s[0][sfb] = bitget(slen4);
sf[0].s[1][sfb] = bitget(slen4);
sf[0].s[2][sfb] = bitget(slen4);
}
else
for (i = 0; i < nr4; i++, sfb++)
{
sf[0].s[0][sfb] = 0;
sf[0].s[1][sfb] = 0;
sf[0].s[2][sfb] = 0;
}
return;
}
/* long blocks types 0 1 3 */
sfb = 0;
if (slen1 != 0)
for (i = 0; i < nr1; i++, sfb++)
sf[0].l[sfb] = bitget(slen1);
else
for (i = 0; i < nr1; i++, sfb++)
sf[0].l[sfb] = 0;
if (slen2 != 0)
for (i = 0; i < nr2; i++, sfb++)
sf[0].l[sfb] = bitget(slen2);
else
for (i = 0; i < nr2; i++, sfb++)
sf[0].l[sfb] = 0;
if (slen3 != 0)
for (i = 0; i < nr3; i++, sfb++)
sf[0].l[sfb] = bitget(slen3);
else
for (i = 0; i < nr3; i++, sfb++)
sf[0].l[sfb] = 0;
if (slen4 != 0)
for (i = 0; i < nr4; i++, sfb++)
sf[0].l[sfb] = bitget(slen4);
else
for (i = 0; i < nr4; i++, sfb++)
sf[0].l[sfb] = 0;
}

127
programs/media/ac97 mp3/trunk/mp3dec/l3side.c Normal file
View File

@ -0,0 +1,127 @@
#include "layer3.h"
extern int m_channels;
extern int m_ms_mode, m_is_mode;
extern SIDE_INFO m_side_info;
int L3get_side_info1()
{
int gr, ch, size;
m_side_info.main_data_begin = bitget(9);
if (m_channels == 1) {
m_side_info.private_bits = bitget(5);
size = 17;
}
else {
m_side_info.private_bits = bitget(3);
size = 32;
}
for (ch = 0; ch < m_channels; ch ++)
m_side_info.scfsi[ch] = bitget(4);
for (gr = 0; gr < 2; gr ++) {
for (ch = 0; ch < m_channels; ch ++) {
GR_INFO* gr_info = &m_side_info.gr[gr][ch];
gr_info->part2_3_length = bitget(12);
gr_info->big_values = bitget(9);
gr_info->global_gain = bitget(8);
//gr_info->global_gain += gain_adjust;
if (m_ms_mode) gr_info->global_gain -= 2;
gr_info->scalefac_compress = bitget(4);
gr_info->window_switching_flag = bitget(1);
if (gr_info->window_switching_flag) {
gr_info->block_type = bitget(2);
gr_info->mixed_block_flag = bitget(1);
gr_info->table_select[0] = bitget(5);
gr_info->table_select[1] = bitget(5);
gr_info->subblock_gain[0] = bitget(3);
gr_info->subblock_gain[1] = bitget(3);
gr_info->subblock_gain[2] = bitget(3);
/* region count set in terms of long block cb's/bands */
/* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
/* if(window_switching_flag) always 36 samples in region0 */
gr_info->region0_count = (8 - 1); /* 36 samples */
gr_info->region1_count = 20 - (8 - 1);
}
else {
gr_info->mixed_block_flag = 0;
gr_info->block_type = 0;
gr_info->table_select[0] = bitget(5);
gr_info->table_select[1] = bitget(5);
gr_info->table_select[2] = bitget(5);
gr_info->region0_count = bitget(4);
gr_info->region1_count = bitget(3);
}
gr_info->preflag = bitget(1);
gr_info->scalefac_scale = bitget(1);
gr_info->count1table_select = bitget(1);
}
}
return size;
}
int L3get_side_info2(int gr)
{
int ch, size;
m_side_info.main_data_begin = bitget(8);
if (m_channels == 1) {
m_side_info.private_bits = bitget(1);
size = 9;
}
else {
m_side_info.private_bits = bitget(2);
size = 17;
}
m_side_info.scfsi[0] = 0;
m_side_info.scfsi[1] = 0;
for (ch = 0; ch < m_channels; ch ++) {
m_side_info.gr[gr][ch].part2_3_length = bitget(12);
m_side_info.gr[gr][ch].big_values = bitget(9);
m_side_info.gr[gr][ch].global_gain = bitget(8);// + gain_adjust;
if (m_ms_mode) m_side_info.gr[gr][ch].global_gain -= 2;
m_side_info.gr[gr][ch].scalefac_compress = bitget(9);
m_side_info.gr[gr][ch].window_switching_flag = bitget(1);
if (m_side_info.gr[gr][ch].window_switching_flag) {
m_side_info.gr[gr][ch].block_type = bitget(2);
m_side_info.gr[gr][ch].mixed_block_flag = bitget(1);
m_side_info.gr[gr][ch].table_select[0] = bitget(5);
m_side_info.gr[gr][ch].table_select[1] = bitget(5);
m_side_info.gr[gr][ch].subblock_gain[0] = bitget(3);
m_side_info.gr[gr][ch].subblock_gain[1] = bitget(3);
m_side_info.gr[gr][ch].subblock_gain[2] = bitget(3);
/* region count set in terms of long block cb's/bands */
/* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
/* bt=1 or 3 54 samples */
/* bt=2 mixed=0 36 samples */
/* bt=2 mixed=1 54 (8 long sf) samples? or maybe 36 */
/* region0 discussion says 54 but this would mix long */
/* and short in region0 if scale factors switch */
/* at band 36 (6 long scale factors) */
if ((m_side_info.gr[gr][ch].block_type == 2)) {
m_side_info.gr[gr][ch].region0_count = (6 - 1); /* 36 samples */
m_side_info.gr[gr][ch].region1_count = 20 - (6 - 1);
}
else {/* long block type 1 or 3 */
m_side_info.gr[gr][ch].region0_count = (8 - 1); /* 54 samples */
m_side_info.gr[gr][ch].region1_count = 20 - (8 - 1);
}
}
else {
m_side_info.gr[gr][ch].mixed_block_flag = 0;
m_side_info.gr[gr][ch].block_type = 0;
m_side_info.gr[gr][ch].table_select[0] = bitget(5);
m_side_info.gr[gr][ch].table_select[1] = bitget(5);
m_side_info.gr[gr][ch].table_select[2] = bitget(5);
m_side_info.gr[gr][ch].region0_count = bitget(4);
m_side_info.gr[gr][ch].region1_count = bitget(3);
}
m_side_info.gr[gr][ch].preflag = 0;
m_side_info.gr[gr][ch].scalefac_scale = bitget(1);
m_side_info.gr[gr][ch].count1table_select = bitget(1);
}
return size;
}

52
programs/media/ac97 mp3/trunk/mp3dec/layer3.h Normal file
View File

@ -0,0 +1,52 @@
#include "bstream.h"
#include "mp3dec.h"
typedef struct {
uint part2_3_length;
uint big_values;
uint global_gain;
uint scalefac_compress;
uint window_switching_flag;
uint block_type;
uint mixed_block_flag;
uint table_select[3];
uint subblock_gain[3];
uint region0_count;
uint region1_count;
uint preflag;
uint scalefac_scale;
uint count1table_select;
} GR_INFO;
typedef struct {
uint main_data_begin;
uint private_bits;
uint scfsi[2]; /* 4 bit flags [ch] */
GR_INFO gr[2][2]; /* [gr][ch] */
} SIDE_INFO;
typedef struct {
int l[23]; /* [cb] */
int s[3][13]; /* [window][cb] */
} SCALE_FACTOR;
typedef struct {
int cbtype; /* long=0 short=1 */
int cbmax; /* max crit band */
int lb_type; /* long block type 0 1 3 */
int cbs0; /* short band start index 0 3 12 (12=no shorts */
int ncbl; /* number long cb's 0 8 21 */
int cbmax_s[3]; /* cbmax by individual short blocks */
} CB_INFO;
typedef struct {
int nr[3];
int slen[3];
int intensity_scale;
} IS_SF_INFO;
typedef union {
int s;
float x;
} SAMPLE;

209
programs/media/ac97 mp3/trunk/mp3dec/math_private.h Normal file
View File

@ -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_ */

513
programs/media/ac97 mp3/trunk/mp3dec/mp3dec.c Normal file
View File

@ -0,0 +1,513 @@
#include "mp3dec.h"
#include <string.h>
#include <math.h>
typedef unsigned char byte;
typedef unsigned int uint;
typedef unsigned short ushort;
static const int br_tbl[3][3][16] = {
{// MPEG-1
// Layer1
{ 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },
// Layer2
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },
// Layer3
{ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0 },
},
{// MPEG-2
// Layer1
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
// Layer2
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
// Layer3
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
},
{// MPEG-2.5
// Layer1 (not available)
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
// Layer2 (not available)
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
// Layer3
{ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
},
};
static const int fr_tbl[3][4] = {
// MPEG-1
{ 44100, 48000, 32000, 0/*reserved*/ },
// MPEG-2
{ 22050, 24000, 16000, 0/*reserved*/ },
// MPEG-2.5
{ 11025, 12000, 8000, 0/*reserved*/ },
};
/* 1999/11/01<30>í<EFBFBD>œ
static const double ms_p_f_table[3][3] =
{
// Layer1
{8.707483f, 8.0f, 12.0f},
// Layer2
{26.12245f, 24.0f, 36.0f},
// Layer3
{26.12245f, 24.0f, 36.0f},
};
*/
typedef void (*FRAME_PROC) (MPEG_HEADER* h, byte* mpeg, byte* pcm);
MPEG_DECODE_OPTION m_option;
FRAME_PROC m_frame_proc;
int m_last_error;
int m_frequency;
int m_frame_size, m_pcm_size;
int m_enableEQ;
float m_equalizer[32];
//float m_band_tbl[2][32];
void L1table_init();
void L2table_init();
void L3table_init();
void L1decode_start(MPEG_HEADER* h);
void L2decode_start(MPEG_HEADER* h);
void L3decode_start(MPEG_HEADER* h);
void L1decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
void L2decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
void L3decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
void _stdcall debug_out_hex(unsigned int val);
void debug_out_str(char* str);
void mp3DecodeInit()
{
// _set_SSE2_enable(0);
m_option.reduction = 0;
m_option.convert = 0;
m_option.freqLimit = 24000;
L1table_init();
L2table_init();
L3table_init();
}
int mp3GetHeader(byte* buf, MPEG_HEADER* h)
{
h->version = (buf[1] & 0x08) >> 3;
h->layer = (buf[1] & 0x06) >> 1;
h->error_prot = (buf[1] & 0x01);
h->br_index = (buf[2] & 0xf0) >> 4;
h->fr_index = (buf[2] & 0x0c) >> 2;
h->padding = (buf[2] & 0x02) >> 1;
h->extension = (buf[2] & 0x01);
h->mode = (buf[3] & 0xc0) >> 6;
h->mode_ext = (buf[3] & 0x30) >> 4;
h->copyright = (buf[3] & 0x08) >> 3;
h->original = (buf[3] & 0x04) >> 2;
h->emphasis = (buf[3] & 0x03);
if (buf[0] != 0xFF) {//sync error
m_last_error = MP3_ERROR_INVALID_SYNC;
return 0;
}
if ((buf[1] & 0xF0) == 0xF0) //MPEG-1, MPEG-2
h->version = (h->version) ? 1 : 2;
else if ((buf[1] & 0xF0) == 0xE0) //MPEG-2.5
h->version = 3;
else {
m_last_error = MP3_ERROR_INVALID_SYNC;
return 0;
}
if (h->fr_index >= 3 ||
h->br_index == 0 || h->br_index >= 15 ||
h->layer == 0 || h->layer >= 4) {
m_last_error = MP3_ERROR_INVALID_HEADER;
return 0;
}
h->layer = 4 - h->layer;
h->error_prot = (h->error_prot) ? 0 : 1;
return 1;
}
int mp3GetLastError()
{
return m_last_error;
}
int mp3FindSync(byte* buf, int size, int* sync)
{
int i;
*sync = 0;
size -= 3;
if (size <= 0) {
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
return 0;
}
for (i = 0; i < size; i ++) {
if (buf[i] == 0xFF) {
if ((buf[i + 1] & 0xF0) == 0xF0) {
break;
}
else if ((buf[i + 1] & 0xF0) == 0xE0) {
break;
}
}
}
if (i == size) {
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
return 0;
}
*sync = i;
return 1;
}
void mp3GetDecodeOption(MPEG_DECODE_OPTION* option)
{
*option = m_option;
}
int mp3SetDecodeOption(MPEG_DECODE_OPTION* option)
{
m_option = *option;
return 1;
}
int mp3SetEqualizer(int* value)
{
int i;
if (value == (void*)0) {
m_enableEQ = 0;
return 1;
}
m_enableEQ = 1;
//60, 170, 310, 600, 1K, 3K
for (i = 0; i < 6; i ++) {
m_equalizer[i] = (float)pow_test(10,(double)value[i]/200);
}
//6K
m_equalizer[6] = (float)pow_test(10,(double)value[6]/200);
m_equalizer[7] = m_equalizer[6];
//12K
m_equalizer[8] = (float)pow_test(10,(double)value[7]/200);
m_equalizer[9] = m_equalizer[8];
m_equalizer[10] = m_equalizer[8];
m_equalizer[11] = m_equalizer[8];
//14K
m_equalizer[12] = (float)pow_test(10,(double)value[8]/200);
m_equalizer[13] = m_equalizer[12];
m_equalizer[14] = m_equalizer[12];
m_equalizer[15] = m_equalizer[12];
m_equalizer[16] = m_equalizer[12];
m_equalizer[17] = m_equalizer[12];
m_equalizer[18] = m_equalizer[12];
m_equalizer[19] = m_equalizer[12];
//16K
m_equalizer[20] = (float)pow_test(10,(double)value[9]/200);
m_equalizer[21] = m_equalizer[20];
m_equalizer[22] = m_equalizer[20];
m_equalizer[23] = m_equalizer[20];
m_equalizer[24] = m_equalizer[20];
m_equalizer[25] = m_equalizer[20];
m_equalizer[26] = m_equalizer[20];
m_equalizer[27] = m_equalizer[20];
m_equalizer[28] = m_equalizer[20];
m_equalizer[29] = m_equalizer[20];
m_equalizer[30] = m_equalizer[20];
m_equalizer[31] = m_equalizer[20];
return 1;
}
#define VBR_FRAMES_FLAG 0x0001
#define VBR_BYTES_FLAG 0x0002
#define VBR_TOC_FLAG 0x0004
#define VBR_SCALE_FLAG 0x0008
static int extractInt4(byte* buf)
{// big endian extract
return buf[3] | (buf[2] << 8) |
(buf[1] << 16) | (buf[0] << 24);
}
int mp3GetDecodeInfo(byte* mpeg, int size, MPEG_DECODE_INFO* info, int decFlag)
{
MPEG_HEADER* h = &info->header;
byte* p = mpeg;
int vbr;
uint minBitRate, maxBitRate;
uint i, j, flags;
//int bitRate;
//int frame_size;
if (size < 156) {//max vbr header size
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
return 0;
}
if (!mp3GetHeader(p, h)) {
return 0;
}
//check VBR Header
p += 4;//skip mpeg header
if (h->error_prot) p += 2;//skip crc
if (h->layer == 3) {//skip side info
if (h->version == 1) {//MPEG-1
if (h->mode != 3) p += 32;
else p += 17;
}
else {//MPEG-2, MPEG-2.5
if (h->mode != 3) p += 17;
else p += 9;
}
}
info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
info->frequency = fr_tbl[h->version-1][h->fr_index];
if (memcmp(p, "Xing", 4) == 0) {//VBR
p += 4;
flags = extractInt4(p);
p += 4;
if (!(flags & (VBR_FRAMES_FLAG | VBR_BYTES_FLAG))) {
m_last_error = MP3_ERROR_INVALID_HEADER;
return 0;
}
info->frames = extractInt4(p);
p += 4;
info->dataSize = extractInt4(p);
p += 4;
if (flags & VBR_TOC_FLAG) p += 100;
if (flags & VBR_SCALE_FLAG) p += 4;
/*/////////////////////////////////
//•W<E280A2>€VBR‘Ήž
if ( p[0] == mpeg[0] && p[1] == mpeg[1] ) {
info->skipSize = (int)(p - mpeg);
} else {
info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
switch (h->layer) {
case 1://layer1
m_frame_size = (12 * info->bitRate / fr_tbl[h->version-1][h->fr_index]) * 4;//one slot is 4 bytes long
if (h->padding) m_frame_size += 4;
break;
case 2://layer2
m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index];
if (h->padding) m_frame_size ++;
break;
case 3://layer3
m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index];
if (h->version != 1) //MPEG-2, MPEG-2.5
m_frame_size /= 2;
if (h->padding) m_frame_size;
break;
}
info->skipSize = (int)(m_frame_size);
}
info->bitRate = 0;
/////////////////////////////////*/
vbr = 1;
minBitRate = 0xffffffff;
maxBitRate = 0;
for (i = 1; i < 15; i ++) {
j = br_tbl[h->version-1][h->layer-1][i] * 1000;
if (j < minBitRate) minBitRate = j;
if (j > maxBitRate) maxBitRate = j;
}
}
else if (memcmp(p, "VBRI", 4) == 0) {//VBRI
p += 10;
info->dataSize = extractInt4(p);
p += 4;
info->frames = extractInt4(p);
p += 4;
vbr = 1;
minBitRate = 0xffffffff;
maxBitRate = 0;
for (i = 1; i < 15; i ++) {
j = br_tbl[h->version-1][h->layer-1][i] * 1000;
if (j < minBitRate) minBitRate = j;
if (j > maxBitRate) maxBitRate = j;
}
}
else {//not VBR
vbr = 0;
info->frames = 0;
//info->skipSize = 0;
info->dataSize = 0;
//info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
}
// info->frequency = fr_tbl[h->version-1][h->fr_index];
// info->msPerFrame = ms_p_f_table[h->layer-1][h->fr_index];
// if (h->version == 3) info->msPerFrame *= 2;
switch (h->layer) {
case 1://layer1
info->outputSize = 384 >> m_option.reduction;
//if (info->bitRate) {
if (!vbr) {
info->skipSize = 0;
info->minInputSize = (12 * info->bitRate / info->frequency) * 4;//one slot is 4 bytes long
info->maxInputSize = info->minInputSize + 4;
}
else {
info->skipSize = (12 * info->bitRate / info->frequency + h->padding) * 4;
info->minInputSize = (12 * minBitRate / info->frequency) * 4;
info->maxInputSize = (12 * maxBitRate / info->frequency) * 4 + 4;
}
break;
case 2://layer2
info->outputSize = 1152 >> m_option.reduction;
//if (info->bitRate) {
if (!vbr) {
info->skipSize = 0;
info->minInputSize = 144 * info->bitRate / info->frequency;
info->maxInputSize = info->minInputSize + 1;
}
else {
info->skipSize = 144 * info->bitRate / info->frequency + h->padding;
info->minInputSize = 144 * minBitRate / info->frequency;
info->maxInputSize = 144 * maxBitRate / info->frequency + 1;
}
break;
case 3://layer3
i = (h->version == 1) ? 1 : 2;
//info->outputSize = 1152 >> m_option.reduction;
info->outputSize = (1152 >> m_option.reduction) / i;
//if (info->bitRate) {
if (!vbr) {
info->skipSize = 0;
info->minInputSize = 144 * info->bitRate / info->frequency / i;
info->maxInputSize = info->minInputSize + 1;
}
else {
info->skipSize = 144 * info->bitRate / info->frequency / i + h->padding;
info->minInputSize = 144 * minBitRate / info->frequency / i;
info->maxInputSize = 144 * maxBitRate / info->frequency / i + 1;
}
break;
/*
if (h->version != 1) {
//MPEG-2, MPEG-2.5
info->outputSize /= 2;
info->minInputSize /= 2;
info->maxInputSize /= 2;
}
info->maxInputSize ++;
break; */
}
if ((h->mode == 3) || (m_option.convert & 3))
info->channels = 1;
else
info->channels = 2;
if (m_option.convert & 8) {
//not available
info->bitsPerSample = 8;
info->outputSize *= info->channels;
}
else {
info->bitsPerSample = 16;
info->outputSize *= info->channels * 2;
}
if ( decFlag == 1 ) {
m_frequency = info->frequency;
m_pcm_size = info->outputSize;
}
info->frequency >>= m_option.reduction;
if (vbr) info->bitRate = 0;
return 1;
}
void sbt_init();
int mp3DecodeStart(byte* mpeg, int size)
{
MPEG_DECODE_INFO info;
MPEG_HEADER* h = &info.header;
if (!mp3GetDecodeInfo(mpeg, size, &info, 1)) {
return 0;
}
sbt_init();
switch (h->layer) {
case 1:
L1decode_start(h);
m_frame_proc = L1decode_frame;
break;
case 2:
L2decode_start(h);
m_frame_proc = L2decode_frame;
break;
case 3:
L3decode_start(h);
m_frame_proc = L3decode_frame;
break;
}
return 1;
}
int mp3DecodeFrame(MPEG_DECODE_PARAM* param)
{
MPEG_HEADER* h = &param->header;
if (param->inputSize <= 4) {
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
return 0;
}
if (!mp3GetHeader(param->inputBuf, h)) {
return 0;
}
param->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
switch (h->layer) {
case 1://layer1
m_frame_size = (12 * param->bitRate / m_frequency + h->padding) * 4;
break;
case 2://layer2
m_frame_size = 144 * param->bitRate / m_frequency + h->padding;
break;
case 3://layer3
if (h->version == 1) m_frame_size = 144 * param->bitRate / m_frequency + h->padding;
else m_frame_size = (144 * param->bitRate / m_frequency) / 2 + h->padding;
break;
}
if (param->inputSize < m_frame_size) {
m_last_error = MP3_ERROR_OUT_OF_BUFFER;
return 0;
}
m_frame_proc(h, param->inputBuf, param->outputBuf);
param->inputSize = m_frame_size;
param->outputSize = m_pcm_size;
return 1;
}
void null_frame_proc(MPEG_HEADER* h, byte* mpeg, byte* pcm) {}
void L3decode_reset();
void mp3MuteStart(MPEG_DECODE_PARAM* param)
{
m_frame_proc = null_frame_proc;
}
void mp3MuteEnd(MPEG_DECODE_PARAM* param)
{
MPEG_HEADER* h = &param->header;
switch (h->layer) {
case 1:
m_frame_proc = L1decode_frame;
break;
case 2:
m_frame_proc = L2decode_frame;
break;
case 3:
L3decode_reset();
m_frame_proc = L3decode_frame;
break;
}
}

76
programs/media/ac97 mp3/trunk/mp3dec/mp3dec.h Normal file
View File

@ -0,0 +1,76 @@
#ifdef __cplusplus
extern "C" {
#endif
#define MP3_ERROR_UNKNOWN 1
#define MP3_ERROR_INVALID_PARAMETER 2
#define MP3_ERROR_INVALID_SYNC 3
#define MP3_ERROR_INVALID_HEADER 4
#define MP3_ERROR_OUT_OF_BUFFER 5
typedef struct {
int version; //1:MPEG-1, 2:MPEG-2, 3:MPEG-2.5
int layer; //1:Layer1, 2:Layer2, 3:Layer3
int error_prot; //1:CRC on, 0:CRC off
int br_index;
int fr_index;
int padding;
int extension;
int mode;
int mode_ext;
int copyright;
int original;
int emphasis;
} MPEG_HEADER;
typedef struct {
int reduction;
int convert;
int freqLimit;
} MPEG_DECODE_OPTION;
typedef struct {
MPEG_HEADER header;
int channels; //出力チャネル
int bitsPerSample; //
int frequency; //サンプリングレート（Hz）
int bitRate; //ビットレート（bps）
int frames; //フレーム数（VBR only）
int skipSize; //（VBR only）
int dataSize; //データサイズ（VBR only）
int minInputSize; //1フレームの最小入力サイズ
int maxInputSize; //1フレームの最大入力サイズ
int outputSize; //1フレームの出力サイズ
} MPEG_DECODE_INFO;
typedef struct {
MPEG_HEADER header;
int bitRate; //ビットレート（bps）
void* inputBuf;
int inputSize;
void* outputBuf;
int outputSize;
} MPEG_DECODE_PARAM;
void mp3DecodeInit();
int mp3GetLastError();
int mp3SetDecodeOption(MPEG_DECODE_OPTION* option);
void mp3GetDecodeOption(MPEG_DECODE_OPTION* option);
int mp3SetEqualizer(int* value);
int mp3FindSync(void* buf, int size, int* sync);
int mp3GetDecodeInfo(void* mpeg, int size, MPEG_DECODE_INFO* info, int decFlag);
int mp3DecodeStart(void* buf, int size);
int mp3DecodeFrame(MPEG_DECODE_PARAM* param);
void mp3MuteStart(MPEG_DECODE_PARAM* param);
void mp3MuteEnd(MPEG_DECODE_PARAM* param);
double pow_test(double, double);
#ifdef __cplusplus
}
#endif

280
programs/media/ac97 mp3/trunk/mp3dec/mp3dec.vcproj Normal file
View File

@ -0,0 +1,280 @@
<?xml version="1.0" encoding="windows-1251"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="mp3dec"
ProjectGUID="{97BF69A3-826A-47D6-94E4-05FDD8CFF1FC}"
RootNamespace="mp3dec"
Keyword="Win32Proj"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="2"
EnableIntrinsicFunctions="true"
FavorSizeOrSpeed="1"
OmitFramePointers="true"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
ExceptionHandling="0"
RuntimeLibrary="0"
StructMemberAlignment="1"
BufferSecurityCheck="false"
FloatingPointModel="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
CompileAs="1"
/>
<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=".\bstream.c"
>
</File>
<File
RelativePath=".\e_pow.c"
>
</File>
<File
RelativePath=".\fdct.c"
>
</File>
<File
RelativePath=".\imdct.c"
>
</File>
<File
RelativePath=".\l1dec.c"
>
</File>
<File
RelativePath=".\l1init.c"
>
</File>
<File
RelativePath=".\l2dec.c"
>
</File>
<File
RelativePath=".\l2init.c"
>
</File>
<File
RelativePath=".\l3alias.c"
>
</File>
<File
RelativePath=".\l3dec.c"
>
</File>
<File
RelativePath=".\l3huff.c"
>
</File>
<File
RelativePath=".\l3hybrid.c"
>
</File>
<File
RelativePath=".\l3init.c"
>
</File>
<File
RelativePath=".\l3msis.c"
>
</File>
<File
RelativePath=".\l3quant.c"
>
</File>
<File
RelativePath=".\l3sf.c"
>
</File>
<File
RelativePath=".\l3side.c"
>
</File>
<File
RelativePath=".\mp3dec.c"
>
</File>
<File
RelativePath=".\pow.asm"
>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCustomBuildTool"
CommandLine="e:\fasm\fasm.exe $(InputPath) $(TargetDir)\$(InputName).obj&#x0D;&#x0A;"
Outputs="$(OutDir)\$(InputName).obj"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\sbt.c"
>
</File>
<File
RelativePath=".\sbtb.c"
>
</File>
<File
RelativePath=".\window.c"
>
</File>
<File
RelativePath=".\windowb.c"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
</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>

355
programs/media/ac97 mp3/trunk/mp3dec/pow.asm Normal file
View File

@ -0,0 +1,355 @@
; ix87 specific implementation of pow function.
; Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
; This file is part of the GNU C Library.
; Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
; The GNU C Library is free software; you can redistribute it and/or
; modify it under the terms of the GNU Library General Public License as
; published by the Free Software Foundation; either version 2 of the
; License, or (at your option) any later version.
; The GNU C Library is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
; Library General Public License for more details.
; You should have received a copy of the GNU Library General Public
; License along with the GNU C Library; see the file COPYING.LIB. If not,
; write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
; Boston, MA 02111-1307, USA. */
format MS COFF
include 'proc32.inc'
section '.text' code readable executable
;public _pow_test@8
public _scalbn
align 4
proc _scalbn
fild dword [esp+12]
fld qword [esp+4]
fscale
fstp st1
ret
endp
proc _pow_test@8 stdcall x:dword, y:dword
fld [x]
fld [y]
jmp __CIpow
__CIpow:
; fldl 12(%esp) // y
fxam
fnstsw ax
mov dl,ah
and ah, 0x45
cmp ah, 0x40 ; is y == 0 ?
je .L_11
cmp ah, 0x05 ; is y == ±inf ?
je .L_12
cmp ah, 0x01 ; is y == NaN ?
je .L_30
fxch
sub esp, 8
fxam
fnstsw ax
mov dh, ah
and ah, 0x45
cmp ah, 0x40
je .L_20 ; x is ±0
cmp ah, 0x05
je .L_15 ; x is ±inf
fxch ; y : x
; First see whether `y' is a natural number. In this case we
; can use a more precise algorithm. */
fld st ; y : y : x
fistp qword [esp] ; y : x
fild qword [esp] ; int(y) : y : x
fucomp st1 ; y : x
fnstsw ax
sahf
jne .L_2
; OK, we have an integer value for y. */
pop eax
pop edx
or edx,0
fstp st0 ; x
jns .L_4 ; y >= 0, jump
fidiv dword [one] ; 1/x (now referred to as x)
neg eax
adc edx,0
neg edx
.L_4:
fld1 ; 1 : x
fxch
.L_6:
shrd edx, eax,1
jnc .L_5
fxch
fmul st1,st0 ; x : ST*x
fxch
.L_5:
fmul st0, st0 ; x*x : ST*x
shr edx,1
mov ecx, eax
or ecx, edx
jnz .L_6
fstp st0 ; ST*x
.L_30:
ret
align 4
; y is a real number. */
.L_2:
fxch ; x : y
fld1 ; 1.0 : x : y
fld st1 ; x : 1.0 : x : y
fsub st0,st1 ; x-1 : 1.0 : x : y
fabs ; |x-1| : 1.0 : x : y
fcomp qword [limit] ; 1.0 : x : y
fnstsw ax
fxch ; x : 1.0 : y
sahf
ja .L_7
fsub st0, st1 ; x-1 : 1.0 : y
fyl2xp1 ; log2(x) : y
jmp .L_8
.L_7:
fyl2x ; log2(x) : y
.L_8:
fmul st0,st1 ; y*log2(x) : y
fst st1 ; y*log2(x) : y*log2(x)
frndint ; int(y*log2(x)) : y*log2(x)
fsubr st1, st0 ; int(y*log2(x)) : fract(y*log2(x))
fxch ; fract(y*log2(x)) : int(y*log2(x))
f2xm1 ; 2^fract(y*log2(x))-1 : int(y*log2(x))
fld1
faddp ; 2^fract(y*log2(x)) : int(y*log2(x))
fscale ; 2^fract(y*log2(x))*2^int(y*log2(x)) : int(y*log2(x))
add esp,8
fstp st1 ; 2^fract(y*log2(x))*2^int(y*log2(x))
ret
align 4
; // pow(x,±0) = 1
.L_11:
fstp st0 ; pop y
fld1
ret
align 4
; y == ±inf
.L_12:
fstp st0 ; pop y
; fld 4(%esp) ; x
fabs
fcomp qword [one] ; < 1, == 1, or > 1
fnstsw ax
and ah,0x45
cmp ah,0x45
je .L_13 ; jump if x is NaN
cmp ah,0x40
je .L_14 ; jump if |x| == 1
shl ah, 1
xor ah, dl
and edx, 2
fld qword [inf_zero+edx+4]
ret
align 4
.L_14:
fld qword [infinity]
fmul qword [zero] ; raise invalid exception
ret
align 4
.L_13:
; //fld 4(%esp) // load x == NaN
ret
align 4
; // x is ±inf
.L_15:
fstp st0 ; y
test dh, 2
jz .L_16 ; jump if x == +inf
; We must find out whether y is an odd integer.
fld st ; y : y
fistp qword [esp] ; y
fild qword [esp] ; int(y) : y
fucompp ; <empty>
fnstsw ax
sahf
jne .L_17
; OK, the value is an integer, but is the number of bits small
; enough so that all are coming from the mantissa?
pop eax
pop edx
and al, 1
jz .L_18 ;// jump if not odd
mov eax, edx
or edx, eax
jns .L_155
neg eax
.L_155:
cmp eax, 0x00200000
ja .L_18 ;// does not fit in mantissa bits
; It's an odd integer.
shr edx, 31
fld qword [minf_mzero+edx+8]
ret
align 4
.L_16:
fcomp qword [zero]
add esp, 8
fnstsw ax
shr eax, 5
and eax, 8
fld qword [inf_zero+eax+1]
ret
align 4
.L_17:
shl edx, 30 ;// sign bit for y in right position
add esp ,8
.L_18:
shr edx, 31
fld qword [inf_zero+edx+8]
ret
align 4
; x is ±0
.L_20:
fstp st0 ; y
test dl,2
jz .L_21 ; y > 0
;x is ±0 and y is < 0. We must find out whether y is an odd integer.
test dh, 2
jz .L_25
fld st ; y : y
fistp qword [esp] ; y
fild qword [esp] ; int(y) : y
fucompp ; <empty>
fnstsw ax
sahf
jne .L_26
;OK, the value is an integer, but is the number of bits small
;enough so that all are coming from the mantissa?
pop eax
pop edx
and al, 1
jz .L_27 ; jump if not odd
cmp edx,0xffe00000
jbe .L_27 ; does not fit in mantissa bits
; It's an odd integer.
; Raise divide-by-zero exception and get minus infinity value.
fld1
fdiv qword [zero]
fchs
ret
.L_25:
fstp st0
.L_26:
add esp,8
.L_27:
;Raise divide-by-zero exception and get infinity value.
fld1
fdiv qword [zero]
ret
align 4
; x is ±0 and y is > 0. We must find out whether y is an odd integer.
.L_21:
test dh,2
jz .L_22
fld st ; y : y
fistp qword [esp] ; y
fild qword [esp] ; int(y) : y
fucompp ; <empty>
fnstsw ax
sahf
jne .L_23
; OK, the value is an integer, but is the number of bits small
; enough so that all are coming from the mantissa?
pop eax
pop edx
and al,1
jz .L_24 ; jump if not odd
cmp edx,0xffe00000
jae .L_24 ; does not fit in mantissa bits
; It's an odd integer.
fld qword [mzero]
ret
.L_22:
fstp st0
.L_23:
add esp,8 ; Don't use 2 x pop
.L_24:
fldz
ret
endp
align 4
inf_zero:
infinity:
db 0,0,0,0,0,0,0xf0,0x7f
zero: dq 0.0
minf_mzero:
minfinity:
db 0,0,0,0,0,0,0xf0,0xff
mzero:
db 0,0,0,0,0,0,0,0x80
one:
dq 1.0
limit:
dq 0.29

394
programs/media/ac97 mp3/trunk/mp3dec/sbt.c Normal file
View File

@ -0,0 +1,394 @@
#include <math.h>
/* "fdct.c" */
void fdct32(float *, float *);
void fdct32_dual(float *, float *);
void fdct32_dual_mono(float *, float *);
void fdct16(float *, float *);
void fdct16_dual(float *, float *);
void fdct16_dual_mono(float *, float *);
void fdct8(float *, float *);
void fdct8_dual(float *, float *);
void fdct8_dual_mono(float *, float *);
/* "window.c" */
void window(float *vbuf, int vb_ptr, short *pcm);
void window_dual(float *vbuf, int vb_ptr, short *pcm);
void window16(float *vbuf, int vb_ptr, short *pcm);
void window16_dual(float *vbuf, int vb_ptr, short *pcm);
void window8(float *vbuf, int vb_ptr, short *pcm);
void window8_dual(float *vbuf, int vb_ptr, short *pcm);
/* circular window buffers */
int vb_ptr;
int vb2_ptr;
float vbuf[512];
float vbuf2[512];
void sbt_init()
{
int i;
/* clear window vbuf */
for (i = 0; i < 512; i++)
{
vbuf[i] = 0.0F;
vbuf2[i] = 0.0F;
}
vb2_ptr = vb_ptr = 0;
}
void sbt_mono(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32(sample, vbuf + vb_ptr);
window(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbt_dual(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32_dual(sample, vbuf + vb_ptr);
fdct32_dual(sample + 1, vbuf2 + vb_ptr);
window_dual(vbuf, vb_ptr, pcm);
window_dual(vbuf2, vb_ptr, pcm + 1);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 64;
}
}
void sbt_dual_mono(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32_dual_mono(sample, vbuf + vb_ptr);
window(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbt_dual_left(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32_dual(sample, vbuf + vb_ptr);
window(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbt_dual_right(float *sample, short *pcm, int n)
{
int i;
sample++; /* point to right chan */
for (i = 0; i < n; i++)
{
fdct32_dual(sample, vbuf + vb_ptr);
window(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbt16_mono(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16(sample, vbuf + vb_ptr);
window16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbt16_dual(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16_dual(sample, vbuf + vb_ptr);
fdct16_dual(sample + 1, vbuf2 + vb_ptr);
window16_dual(vbuf, vb_ptr, pcm);
window16_dual(vbuf2, vb_ptr, pcm + 1);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 32;
}
}
void sbt16_dual_mono(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16_dual_mono(sample, vbuf + vb_ptr);
window16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbt16_dual_left(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16_dual(sample, vbuf + vb_ptr);
window16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbt16_dual_right(float *sample, short *pcm, int n)
{
int i;
sample++;
for (i = 0; i < n; i++)
{
fdct16_dual(sample, vbuf + vb_ptr);
window16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbt8_mono(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8(sample, vbuf + vb_ptr);
window8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbt8_dual(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8_dual(sample, vbuf + vb_ptr);
fdct8_dual(sample + 1, vbuf2 + vb_ptr);
window8_dual(vbuf, vb_ptr, pcm);
window8_dual(vbuf2, vb_ptr, pcm + 1);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 16;
}
}
void sbt8_dual_mono(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8_dual_mono(sample, vbuf + vb_ptr);
window8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbt8_dual_left(float *sample, short *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8_dual(sample, vbuf + vb_ptr);
window8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbt8_dual_right(float *sample, short *pcm, int n)
{
int i;
sample++;
for (i = 0; i < n; i++)
{
fdct8_dual(sample, vbuf + vb_ptr);
window8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbt_mono_L3(float *sample, short *pcm, int ch)
{
int i;
ch = 0;
for (i = 0; i < 18; i++)
{
fdct32(sample, vbuf + vb_ptr);
window(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbt_dual_L3(float *sample, short *pcm, int ch)
{
int i;
if (ch == 0)
for (i = 0; i < 18; i++) {
fdct32(sample, vbuf + vb_ptr);
window_dual(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 64;
}
else
for (i = 0; i < 18; i++) {
fdct32(sample, vbuf2 + vb2_ptr);
window_dual(vbuf2, vb2_ptr, pcm + 1);
sample += 32;
vb2_ptr = (vb2_ptr - 32) & 511;
pcm += 64;
}
}
void sbt16_mono_L3(float *sample, short *pcm, int ch)
{
int i;
ch = 0;
for (i = 0; i < 18; i++)
{
fdct16(sample, vbuf + vb_ptr);
window16(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbt16_dual_L3(float *sample, short *pcm, int ch)
{
int i;
if (ch == 0)
{
for (i = 0; i < 18; i++)
{
fdct16(sample, vbuf + vb_ptr);
window16_dual(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 32;
}
}
else
{
for (i = 0; i < 18; i++)
{
fdct16(sample, vbuf2 + vb2_ptr);
window16_dual(vbuf2, vb2_ptr, pcm + 1);
sample += 32;
vb2_ptr = (vb2_ptr - 16) & 255;
pcm += 32;
}
}
}
void sbt8_mono_L3(float *sample, short *pcm, int ch)
{
int i;
ch = 0;
for (i = 0; i < 18; i++)
{
fdct8(sample, vbuf + vb_ptr);
window8(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbt8_dual_L3(float *sample, short *pcm, int ch)
{
int i;
if (ch == 0)
{
for (i = 0; i < 18; i++)
{
fdct8(sample, vbuf + vb_ptr);
window8_dual(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 16;
}
}
else
{
for (i = 0; i < 18; i++)
{
fdct8(sample, vbuf2 + vb2_ptr);
window8_dual(vbuf2, vb2_ptr, pcm + 1);
sample += 32;
vb2_ptr = (vb2_ptr - 8) & 127;
pcm += 16;
}
}
}

382
programs/media/ac97 mp3/trunk/mp3dec/sbtb.c Normal file
View File

@ -0,0 +1,382 @@
#include <math.h>
/* "fdct.c" */
void fdct32(float *, float *);
void fdct32_dual(float *, float *);
void fdct32_dual_mono(float *, float *);
void fdct16(float *, float *);
void fdct16_dual(float *, float *);
void fdct16_dual_mono(float *, float *);
void fdct8(float *, float *);
void fdct8_dual(float *, float *);
void fdct8_dual_mono(float *, float *);
/* "windowb.c" */
void windowB(float *vbuf, int vb_ptr, unsigned char *pcm);
void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm);
void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm);
void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
extern int vb_ptr;
extern int vb2_ptr;
extern float vbuf[512];
extern float vbuf2[512];
void sbtB_mono(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32(sample, vbuf + vb_ptr);
windowB(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbtB_dual(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32_dual(sample, vbuf + vb_ptr);
fdct32_dual(sample + 1, vbuf2 + vb_ptr);
windowB_dual(vbuf, vb_ptr, pcm);
windowB_dual(vbuf2, vb_ptr, pcm + 1);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 64;
}
}
void sbtB_dual_mono(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32_dual_mono(sample, vbuf + vb_ptr);
windowB(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbtB_dual_left(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct32_dual(sample, vbuf + vb_ptr);
windowB(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbtB_dual_right(float *sample, unsigned char *pcm, int n)
{
int i;
sample++; /* point to right chan */
for (i = 0; i < n; i++)
{
fdct32_dual(sample, vbuf + vb_ptr);
windowB(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbtB16_mono(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16(sample, vbuf + vb_ptr);
windowB16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbtB16_dual(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16_dual(sample, vbuf + vb_ptr);
fdct16_dual(sample + 1, vbuf2 + vb_ptr);
windowB16_dual(vbuf, vb_ptr, pcm);
windowB16_dual(vbuf2, vb_ptr, pcm + 1);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 32;
}
}
void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16_dual_mono(sample, vbuf + vb_ptr);
windowB16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbtB16_dual_left(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct16_dual(sample, vbuf + vb_ptr);
windowB16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbtB16_dual_right(float *sample, unsigned char *pcm, int n)
{
int i;
sample++;
for (i = 0; i < n; i++)
{
fdct16_dual(sample, vbuf + vb_ptr);
windowB16(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbtB8_mono(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8(sample, vbuf + vb_ptr);
windowB8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbtB8_dual(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8_dual(sample, vbuf + vb_ptr);
fdct8_dual(sample + 1, vbuf2 + vb_ptr);
windowB8_dual(vbuf, vb_ptr, pcm);
windowB8_dual(vbuf2, vb_ptr, pcm + 1);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 16;
}
}
void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8_dual_mono(sample, vbuf + vb_ptr);
windowB8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbtB8_dual_left(float *sample, unsigned char *pcm, int n)
{
int i;
for (i = 0; i < n; i++)
{
fdct8_dual(sample, vbuf + vb_ptr);
windowB8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbtB8_dual_right(float *sample, unsigned char *pcm, int n)
{
int i;
sample++;
for (i = 0; i < n; i++)
{
fdct8_dual(sample, vbuf + vb_ptr);
windowB8(vbuf, vb_ptr, pcm);
sample += 64;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch)
{
int i;
ch = 0;
for (i = 0; i < 18; i++)
{
fdct32(sample, vbuf + vb_ptr);
windowB(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 32;
}
}
void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch)
{
int i;
if (ch == 0)
for (i = 0; i < 18; i++)
{
fdct32(sample, vbuf + vb_ptr);
windowB_dual(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 32) & 511;
pcm += 64;
}
else
for (i = 0; i < 18; i++)
{
fdct32(sample, vbuf2 + vb2_ptr);
windowB_dual(vbuf2, vb2_ptr, pcm + 1);
sample += 32;
vb2_ptr = (vb2_ptr - 32) & 511;
pcm += 64;
}
}
void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch)
{
int i;
ch = 0;
for (i = 0; i < 18; i++)
{
fdct16(sample, vbuf + vb_ptr);
windowB16(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 16;
}
}
void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch)
{
int i;
if (ch == 0)
{
for (i = 0; i < 18; i++)
{
fdct16(sample, vbuf + vb_ptr);
windowB16_dual(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 16) & 255;
pcm += 32;
}
}
else
{
for (i = 0; i < 18; i++)
{
fdct16(sample, vbuf2 + vb2_ptr);
windowB16_dual(vbuf2, vb2_ptr, pcm + 1);
sample += 32;
vb2_ptr = (vb2_ptr - 16) & 255;
pcm += 32;
}
}
}
void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch)
{
int i;
ch = 0;
for (i = 0; i < 18; i++)
{
fdct8(sample, vbuf + vb_ptr);
windowB8(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 8;
}
}
void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch)
{
int i;
if (ch == 0)
{
for (i = 0; i < 18; i++)
{
fdct8(sample, vbuf + vb_ptr);
windowB8_dual(vbuf, vb_ptr, pcm);
sample += 32;
vb_ptr = (vb_ptr - 8) & 127;
pcm += 16;
}
}
else
{
for (i = 0; i < 18; i++)
{
fdct8(sample, vbuf2 + vb2_ptr);
windowB8_dual(vbuf2, vb2_ptr, pcm + 1);
sample += 32;
vb2_ptr = (vb2_ptr - 8) & 127;
pcm += 16;
}
}
}

503
programs/media/ac97 mp3/trunk/mp3dec/window.c Normal file
View File

@ -0,0 +1,503 @@
// disable precision loss warning on type conversion
#ifdef _MSC_VER
#pragma warning(disable:4244 4056)
#endif
float wincoef[264] =
{ // window coefs
0.000000000f, 0.000442505f, -0.003250122f, 0.007003784f,
-0.031082151f, 0.078628540f, -0.100311279f, 0.572036743f,
-1.144989014f, -0.572036743f, -0.100311279f, -0.078628540f,
-0.031082151f, -0.007003784f, -0.003250122f, -0.000442505f,
0.000015259f, 0.000473022f, -0.003326416f, 0.007919312f,
-0.030517576f, 0.084182739f, -0.090927124f, 0.600219727f,
-1.144287109f, -0.543823242f, -0.108856201f, -0.073059082f,
-0.031478882f, -0.006118774f, -0.003173828f, -0.000396729f,
0.000015259f, 0.000534058f, -0.003387451f, 0.008865356f,
-0.029785154f, 0.089706421f, -0.080688477f, 0.628295898f,
-1.142211914f, -0.515609741f, -0.116577141f, -0.067520142f,
-0.031738281f, -0.005294800f, -0.003082275f, -0.000366211f,
0.000015259f, 0.000579834f, -0.003433228f, 0.009841919f,
-0.028884888f, 0.095169067f, -0.069595337f, 0.656219482f,
-1.138763428f, -0.487472534f, -0.123474121f, -0.061996460f,
-0.031845093f, -0.004486084f, -0.002990723f, -0.000320435f,
0.000015259f, 0.000625610f, -0.003463745f, 0.010848999f,
-0.027801514f, 0.100540161f, -0.057617184f, 0.683914185f,
-1.133926392f, -0.459472656f, -0.129577637f, -0.056533810f,
-0.031814575f, -0.003723145f, -0.002899170f, -0.000289917f,
0.000015259f, 0.000686646f, -0.003479004f, 0.011886597f,
-0.026535034f, 0.105819702f, -0.044784546f, 0.711318970f,
-1.127746582f, -0.431655884f, -0.134887695f, -0.051132202f,
-0.031661987f, -0.003005981f, -0.002792358f, -0.000259399f,
0.000015259f, 0.000747681f, -0.003479004f, 0.012939452f,
-0.025085449f, 0.110946655f, -0.031082151f, 0.738372803f,
-1.120223999f, -0.404083252f, -0.139450073f, -0.045837402f,
-0.031387329f, -0.002334595f, -0.002685547f, -0.000244141f,
0.000030518f, 0.000808716f, -0.003463745f, 0.014022826f,
-0.023422241f, 0.115921021f, -0.016510010f, 0.765029907f,
-1.111373901f, -0.376800537f, -0.143264771f, -0.040634155f,
-0.031005858f, -0.001693726f, -0.002578735f, -0.000213623f,
0.000030518f, 0.000885010f, -0.003417969f, 0.015121460f,
-0.021575928f, 0.120697014f, -0.001068115f, 0.791213989f,
-1.101211548f, -0.349868774f, -0.146362305f, -0.035552979f,
-0.030532837f, -0.001098633f, -0.002456665f, -0.000198364f,
0.000030518f, 0.000961304f, -0.003372192f, 0.016235352f,
-0.019531250f, 0.125259399f, 0.015228271f, 0.816864014f,
-1.089782715f, -0.323318481f, -0.148773193f, -0.030609131f,
-0.029937742f, -0.000549316f, -0.002349854f, -0.000167847f,
0.000030518f, 0.001037598f, -0.003280640f, 0.017349243f,
-0.017257690f, 0.129562378f, 0.032379150f, 0.841949463f,
-1.077117920f, -0.297210693f, -0.150497437f, -0.025817871f,
-0.029281614f, -0.000030518f, -0.002243042f, -0.000152588f,
0.000045776f, 0.001113892f, -0.003173828f, 0.018463135f,
-0.014801024f, 0.133590698f, 0.050354004f, 0.866363525f,
-1.063217163f, -0.271591187f, -0.151596069f, -0.021179199f,
-0.028533936f, 0.000442505f, -0.002120972f, -0.000137329f,
0.000045776f, 0.001205444f, -0.003051758f, 0.019577026f,
-0.012115479f, 0.137298584f, 0.069168091f, 0.890090942f,
-1.048156738f, -0.246505737f, -0.152069092f, -0.016708374f,
-0.027725220f, 0.000869751f, -0.002014160f, -0.000122070f,
0.000061035f, 0.001296997f, -0.002883911f, 0.020690918f,
-0.009231566f, 0.140670776f, 0.088775635f, 0.913055420f,
-1.031936646f, -0.221984863f, -0.151962280f, -0.012420653f,
-0.026840210f, 0.001266479f, -0.001907349f, -0.000106812f,
0.000061035f, 0.001388550f, -0.002700806f, 0.021789551f,
-0.006134033f, 0.143676758f, 0.109161377f, 0.935195923f,
-1.014617920f, -0.198059082f, -0.151306152f, -0.008316040f,
-0.025909424f, 0.001617432f, -0.001785278f, -0.000106812f,
0.000076294f, 0.001480103f, -0.002487183f, 0.022857666f,
-0.002822876f, 0.146255493f, 0.130310059f, 0.956481934f,
-0.996246338f, -0.174789429f, -0.150115967f, -0.004394531f,
-0.024932859f, 0.001937866f, -0.001693726f, -0.000091553f,
-0.001586914f, -0.023910521f, -0.148422241f, -0.976852417f,
0.152206421f, 0.000686646f, -0.002227783f, 0.000076294f,
};
void window(float *vbuf, int vb_ptr, short *pcm)
{
int i, j;
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 16;
bx = (si + 32) & 511;
coef = wincoef;
/*-- first 16 --*/
for (i = 0; i < 16; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 64) & 511;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
si++;
bx--;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
/*-- last 15 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 15; i++)
{
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 64) & 511;
sum += (*coef--) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
}
}
/*------------------------------------------------------------*/
void window_dual(float *vbuf, int vb_ptr, short *pcm)
{
int i, j; /* dual window interleaves output */
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 16;
bx = (si + 32) & 511;
coef = wincoef;
/*-- first 16 --*/
for (i = 0; i < 16; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 64) & 511;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
si++;
bx--;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
/*-- last 15 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 15; i++)
{
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 64) & 511;
sum += (*coef--) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
}
}
/*------------------------------------------------------------*/
/*------------------- 16 pt window ------------------------------*/
void window16(float *vbuf, int vb_ptr, short *pcm)
{
int i, j;
unsigned char si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 8;
bx = si + 16;
coef = wincoef;
/*-- first 8 --*/
for (i = 0; i < 8; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si += 32;
sum -= (*coef++) * vbuf[bx];
bx += 32;
}
si++;
bx--;
coef += 16;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
/*-- last 7 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 7; i++)
{
coef -= 16;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si += 32;
sum += (*coef--) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
}
}
/*--------------- 16 pt dual window (interleaved output) -----------------*/
void window16_dual(float *vbuf, int vb_ptr, short *pcm)
{
int i, j;
unsigned char si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 8;
bx = si + 16;
coef = wincoef;
/*-- first 8 --*/
for (i = 0; i < 8; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si += 32;
sum -= (*coef++) * vbuf[bx];
bx += 32;
}
si++;
bx--;
coef += 16;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
/*-- last 7 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 7; i++)
{
coef -= 16;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si += 32;
sum += (*coef--) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
}
}
/*------------------- 8 pt window ------------------------------*/
void window8(float *vbuf, int vb_ptr, short *pcm)
{
int i, j;
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 4;
bx = (si + 8) & 127;
coef = wincoef;
/*-- first 4 --*/
for (i = 0; i < 4; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 16) & 127;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
si++;
bx--;
coef += 48;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
/*-- last 3 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 3; i++)
{
coef -= 48;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 16) & 127;
sum += (*coef--) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = tmp;
}
}
/*--------------- 8 pt dual window (interleaved output) -----------------*/
void window8_dual(float *vbuf, int vb_ptr, short *pcm)
{
int i, j;
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 4;
bx = (si + 8) & 127;
coef = wincoef;
/*-- first 4 --*/
for (i = 0; i < 4; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 16) & 127;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
si++;
bx--;
coef += 48;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
/*-- last 3 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 3; i++)
{
coef -= 48;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 16) & 127;
sum += (*coef--) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = tmp;
pcm += 2;
}
}

427
programs/media/ac97 mp3/trunk/mp3dec/windowb.c Normal file
View File

@ -0,0 +1,427 @@
extern float wincoef[264];
void windowB(float *vbuf, int vb_ptr, unsigned char *pcm)
{
int i, j;
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 16;
bx = (si + 32) & 511;
coef = wincoef;
/*-- first 16 --*/
for (i = 0; i < 16; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 64) & 511;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
si++;
bx--;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
/*-- last 15 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 15; i++)
{
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 64) & 511;
sum += (*coef--) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
}
}
/*------------------------------------------------------------*/
void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
{
int i, j; /* dual window interleaves output */
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 16;
bx = (si + 32) & 511;
coef = wincoef;
/*-- first 16 --*/
for (i = 0; i < 16; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 64) & 511;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
si++;
bx--;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
/*-- last 15 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 15; i++)
{
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 64) & 511;
sum += (*coef--) * vbuf[bx];
bx = (bx + 64) & 511;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
}
}
/*------------------------------------------------------------*/
/*------------------- 16 pt window ------------------------------*/
void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm)
{
int i, j;
unsigned char si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 8;
bx = si + 16;
coef = wincoef;
/*-- first 8 --*/
for (i = 0; i < 8; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si += 32;
sum -= (*coef++) * vbuf[bx];
bx += 32;
}
si++;
bx--;
coef += 16;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
/*-- last 7 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 7; i++)
{
coef -= 16;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si += 32;
sum += (*coef--) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
}
}
/*--------------- 16 pt dual window (interleaved output) -----------------*/
void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
{
int i, j;
unsigned char si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 8;
bx = si + 16;
coef = wincoef;
/*-- first 8 --*/
for (i = 0; i < 8; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si += 32;
sum -= (*coef++) * vbuf[bx];
bx += 32;
}
si++;
bx--;
coef += 16;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
/*-- last 7 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 7; i++)
{
coef -= 16;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si += 32;
sum += (*coef--) * vbuf[bx];
bx += 32;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
}
}
/*------------------- 8 pt window ------------------------------*/
void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm)
{
int i, j;
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 4;
bx = (si + 8) & 127;
coef = wincoef;
/*-- first 4 --*/
for (i = 0; i < 4; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 16) & 127;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
si++;
bx--;
coef += 48;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
/*-- last 3 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 3; i++)
{
coef -= 48;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 16) & 127;
sum += (*coef--) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
}
}
/*--------------- 8 pt dual window (interleaved output) -----------------*/
void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
{
int i, j;
int si, bx;
float *coef;
float sum;
long tmp;
si = vb_ptr + 4;
bx = (si + 8) & 127;
coef = wincoef;
/*-- first 4 --*/
for (i = 0; i < 4; i++)
{
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[si];
si = (si + 16) & 127;
sum -= (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
si++;
bx--;
coef += 48;
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
}
/*-- special case --*/
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef++) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
/*-- last 3 --*/
coef = wincoef + 255; /* back pass through coefs */
for (i = 0; i < 3; i++)
{
coef -= 48;
si--;
bx++;
sum = 0.0F;
for (j = 0; j < 8; j++)
{
sum += (*coef--) * vbuf[si];
si = (si + 16) & 127;
sum += (*coef--) * vbuf[bx];
bx = (bx + 16) & 127;
}
tmp = (long) sum;
if (tmp > 32767)
tmp = 32767;
else if (tmp < -32768)
tmp = -32768;
*pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
pcm += 2;
}
}