/programs/media/ac97 mp3/trunk/PROC32.INC |
---|
0,0 → 1,268 |
; Macroinstructions for defining and calling procedures |
macro stdcall proc,[arg] ; directly call STDCALL procedure |
{ common |
if ~ arg eq |
reverse |
pushd arg |
common |
end if |
call proc } |
macro invoke proc,[arg] ; indirectly call STDCALL procedure |
{ common |
if ~ arg eq |
reverse |
pushd arg |
common |
end if |
call [proc] } |
macro ccall proc,[arg] ; directly call CDECL procedure |
{ common |
size@ccall = 0 |
if ~ arg eq |
reverse |
pushd arg |
size@ccall = size@ccall+4 |
common |
end if |
call proc |
if size@ccall |
add esp,size@ccall |
end if } |
macro cinvoke proc,[arg] ; indirectly call CDECL procedure |
{ common |
size@ccall = 0 |
if ~ arg eq |
reverse |
pushd arg |
size@ccall = size@ccall+4 |
common |
end if |
call [proc] |
if size@ccall |
add esp,size@ccall |
end if } |
macro proc [args] ; define procedure |
{ common |
match name params, args> |
\{ define@proc name,<params \} } |
prologue@proc equ prologuedef |
macro prologuedef procname,flag,parmbytes,localbytes,reglist |
{ if parmbytes | localbytes |
push ebp |
mov ebp,esp |
if localbytes |
sub esp,localbytes |
end if |
end if |
irps reg, reglist \{ push reg \} } |
epilogue@proc equ epiloguedef |
macro epiloguedef procname,flag,parmbytes,localbytes,reglist |
{ irps reg, reglist \{ reverse pop reg \} |
if parmbytes | localbytes |
leave |
end if |
if flag and 10000b |
retn |
else |
retn parmbytes |
end if } |
macro define@proc name,statement |
{ local params,flag,regs,parmbytes,localbytes,current |
if used name |
name: |
match =stdcall args, statement \{ params equ args |
flag = 11b \} |
match =stdcall, statement \{ params equ |
flag = 11b \} |
match =c args, statement \{ params equ args |
flag = 10001b \} |
match =c, statement \{ params equ |
flag = 10001b \} |
match =params, params \{ params equ statement |
flag = 0 \} |
virtual at ebp+8 |
match =uses reglist=,args, params \{ regs equ reglist |
params equ args \} |
match =regs =uses reglist, regs params \{ regs equ reglist |
params equ \} |
match =regs, regs \{ regs equ \} |
match =,args, params \{ defargs@proc args \} |
match =args@proc args, args@proc params \{ defargs@proc args \} |
parmbytes = $ - (ebp+8) |
end virtual |
name # % = parmbytes/4 |
all@vars equ |
current = 0 |
match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \} |
macro locals |
\{ virtual at ebp-localbytes+current |
macro label . \\{ deflocal@proc .,:, \\} |
struc db [val] \\{ \common deflocal@proc .,db,val \\} |
struc dw [val] \\{ \common deflocal@proc .,dw,val \\} |
struc dp [val] \\{ \common deflocal@proc .,dp,val \\} |
struc dd [val] \\{ \common deflocal@proc .,dd,val \\} |
struc dt [val] \\{ \common deflocal@proc .,dt,val \\} |
struc dq [val] \\{ \common deflocal@proc .,dq,val \\} |
struc rb cnt \\{ deflocal@proc .,rb cnt, \\} |
struc rw cnt \\{ deflocal@proc .,rw cnt, \\} |
struc rp cnt \\{ deflocal@proc .,rp cnt, \\} |
struc rd cnt \\{ deflocal@proc .,rd cnt, \\} |
struc rt cnt \\{ deflocal@proc .,rt cnt, \\} |
struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \} |
macro endl |
\{ purge label |
restruc db,dw,dp,dd,dt,dq |
restruc rb,rw,rp,rd,rt,rq |
restruc byte,word,dword,pword,tword,qword |
current = $-(ebp-localbytes) |
end virtual \} |
macro ret operand |
\{ match any, operand \\{ retn operand \\} |
match , operand \\{ match epilogue:reglist, epilogue@proc:<regs> |
\\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \} |
macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2 |
end if \} } |
macro defargs@proc [arg] |
{ common |
if ~ arg eq |
forward |
local ..arg,current@arg |
match argname:type, arg |
\{ current@arg equ argname |
label ..arg type |
argname equ ..arg |
if dqword eq type |
dd ?,?,?,? |
else if tbyte eq type |
dd ?,?,? |
else if qword eq type | pword eq type |
dd ?,? |
else |
dd ? |
end if \} |
match =current@arg,current@arg |
\{ current@arg equ arg |
arg equ ..arg |
..arg dd ? \} |
common |
args@proc equ current@arg |
forward |
restore current@arg |
common |
end if } |
macro deflocal@proc name,def,[val] |
{ common |
match vars, all@vars \{ all@vars equ all@vars, \} |
all@vars equ all@vars name |
forward |
local ..var,..tmp |
..var def val |
match =?, val \{ ..tmp equ \} |
match any =dup (=?), val \{ ..tmp equ \} |
match tmp : value, ..tmp : val |
\{ tmp: end virtual |
initlocal@proc ..var,def value |
virtual at tmp\} |
common |
match first rest, ..var, \{ name equ first \} } |
macro initlocal@proc name,def |
{ virtual at name |
def |
size@initlocal = $ - name |
end virtual |
position@initlocal = 0 |
while size@initlocal > position@initlocal |
virtual at name |
def |
if size@initlocal - position@initlocal < 2 |
current@initlocal = 1 |
load byte@initlocal byte from name+position@initlocal |
else if size@initlocal - position@initlocal < 4 |
current@initlocal = 2 |
load word@initlocal word from name+position@initlocal |
else |
current@initlocal = 4 |
load dword@initlocal dword from name+position@initlocal |
end if |
end virtual |
if current@initlocal = 1 |
mov byte [name+position@initlocal],byte@initlocal |
else if current@initlocal = 2 |
mov word [name+position@initlocal],word@initlocal |
else |
mov dword [name+position@initlocal],dword@initlocal |
end if |
position@initlocal = position@initlocal + current@initlocal |
end while } |
macro endp |
{ purge ret,locals,endl |
finish@proc |
purge finish@proc |
restore regs@proc |
match all,args@proc \{ restore all \} |
restore args@proc |
match all,all@vars \{ restore all \} } |
macro local [var] |
{ common |
locals |
forward done@local equ |
match varname[count]:vartype, var |
\{ match =BYTE, vartype \\{ varname rb count |
restore done@local \\} |
match =WORD, vartype \\{ varname rw count |
restore done@local \\} |
match =DWORD, vartype \\{ varname rd count |
restore done@local \\} |
match =PWORD, vartype \\{ varname rp count |
restore done@local \\} |
match =QWORD, vartype \\{ varname rq count |
restore done@local \\} |
match =TBYTE, vartype \\{ varname rt count |
restore done@local \\} |
match =DQWORD, vartype \\{ label varname dqword |
rq count+count |
restore done@local \\} |
match , done@local \\{ virtual |
varname vartype |
end virtual |
rb count*sizeof.\#vartype |
restore done@local \\} \} |
match :varname:vartype, done@local:var |
\{ match =BYTE, vartype \\{ varname db ? |
restore done@local \\} |
match =WORD, vartype \\{ varname dw ? |
restore done@local \\} |
match =DWORD, vartype \\{ varname dd ? |
restore done@local \\} |
match =PWORD, vartype \\{ varname dp ? |
restore done@local \\} |
match =QWORD, vartype \\{ varname dq ? |
restore done@local \\} |
match =TBYTE, vartype \\{ varname dt ? |
restore done@local \\} |
match =DQWORD, vartype \\{ label varname dqword |
dq ?,? |
restore done@local \\} |
match , done@local \\{ varname vartype |
restore done@local \\} \} |
match ,done@local |
\{ var |
restore done@local \} |
common |
endl } |
/programs/media/ac97 mp3/trunk/ac97.sln |
---|
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 |
/programs/media/ac97 mp3/trunk/ac97wav.c |
---|
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(¶m)) |
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"); |
/programs/media/ac97 mp3/trunk/ac97wav.h |
---|
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(); |
/programs/media/ac97 mp3/trunk/crt.c |
---|
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(); |
} |
/programs/media/ac97 mp3/trunk/crt.h |
---|
0,0 → 1,13 |
typedef unsigned __int32 Dword; |
typedef unsigned __int16 Word; |
typedef unsigned __int8 Byte; |
typedef unsigned __int32 size_t; |
extern char *__argv; |
void crtStartUp(); |
int __cdecl _purecall(); |
int __cdecl atexit( void (__cdecl *func )( void )); |
void exit(); |
int main(); |
/programs/media/ac97 mp3/trunk/k_lib.asm |
---|
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 |
/programs/media/ac97 mp3/trunk/kolibri.h |
---|
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); |
/programs/media/ac97 mp3/trunk/mp3dec/PROC32.INC |
---|
0,0 → 1,268 |
; Macroinstructions for defining and calling procedures |
macro stdcall proc,[arg] ; directly call STDCALL procedure |
{ common |
if ~ arg eq |
reverse |
pushd arg |
common |
end if |
call proc } |
macro invoke proc,[arg] ; indirectly call STDCALL procedure |
{ common |
if ~ arg eq |
reverse |
pushd arg |
common |
end if |
call [proc] } |
macro ccall proc,[arg] ; directly call CDECL procedure |
{ common |
size@ccall = 0 |
if ~ arg eq |
reverse |
pushd arg |
size@ccall = size@ccall+4 |
common |
end if |
call proc |
if size@ccall |
add esp,size@ccall |
end if } |
macro cinvoke proc,[arg] ; indirectly call CDECL procedure |
{ common |
size@ccall = 0 |
if ~ arg eq |
reverse |
pushd arg |
size@ccall = size@ccall+4 |
common |
end if |
call [proc] |
if size@ccall |
add esp,size@ccall |
end if } |
macro proc [args] ; define procedure |
{ common |
match name params, args> |
\{ define@proc name,<params \} } |
prologue@proc equ prologuedef |
macro prologuedef procname,flag,parmbytes,localbytes,reglist |
{ if parmbytes | localbytes |
push ebp |
mov ebp,esp |
if localbytes |
sub esp,localbytes |
end if |
end if |
irps reg, reglist \{ push reg \} } |
epilogue@proc equ epiloguedef |
macro epiloguedef procname,flag,parmbytes,localbytes,reglist |
{ irps reg, reglist \{ reverse pop reg \} |
if parmbytes | localbytes |
leave |
end if |
if flag and 10000b |
retn |
else |
retn parmbytes |
end if } |
macro define@proc name,statement |
{ local params,flag,regs,parmbytes,localbytes,current |
if used name |
name: |
match =stdcall args, statement \{ params equ args |
flag = 11b \} |
match =stdcall, statement \{ params equ |
flag = 11b \} |
match =c args, statement \{ params equ args |
flag = 10001b \} |
match =c, statement \{ params equ |
flag = 10001b \} |
match =params, params \{ params equ statement |
flag = 0 \} |
virtual at ebp+8 |
match =uses reglist=,args, params \{ regs equ reglist |
params equ args \} |
match =regs =uses reglist, regs params \{ regs equ reglist |
params equ \} |
match =regs, regs \{ regs equ \} |
match =,args, params \{ defargs@proc args \} |
match =args@proc args, args@proc params \{ defargs@proc args \} |
parmbytes = $ - (ebp+8) |
end virtual |
name # % = parmbytes/4 |
all@vars equ |
current = 0 |
match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \} |
macro locals |
\{ virtual at ebp-localbytes+current |
macro label . \\{ deflocal@proc .,:, \\} |
struc db [val] \\{ \common deflocal@proc .,db,val \\} |
struc dw [val] \\{ \common deflocal@proc .,dw,val \\} |
struc dp [val] \\{ \common deflocal@proc .,dp,val \\} |
struc dd [val] \\{ \common deflocal@proc .,dd,val \\} |
struc dt [val] \\{ \common deflocal@proc .,dt,val \\} |
struc dq [val] \\{ \common deflocal@proc .,dq,val \\} |
struc rb cnt \\{ deflocal@proc .,rb cnt, \\} |
struc rw cnt \\{ deflocal@proc .,rw cnt, \\} |
struc rp cnt \\{ deflocal@proc .,rp cnt, \\} |
struc rd cnt \\{ deflocal@proc .,rd cnt, \\} |
struc rt cnt \\{ deflocal@proc .,rt cnt, \\} |
struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \} |
macro endl |
\{ purge label |
restruc db,dw,dp,dd,dt,dq |
restruc rb,rw,rp,rd,rt,rq |
restruc byte,word,dword,pword,tword,qword |
current = $-(ebp-localbytes) |
end virtual \} |
macro ret operand |
\{ match any, operand \\{ retn operand \\} |
match , operand \\{ match epilogue:reglist, epilogue@proc:<regs> |
\\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \} |
macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2 |
end if \} } |
macro defargs@proc [arg] |
{ common |
if ~ arg eq |
forward |
local ..arg,current@arg |
match argname:type, arg |
\{ current@arg equ argname |
label ..arg type |
argname equ ..arg |
if dqword eq type |
dd ?,?,?,? |
else if tbyte eq type |
dd ?,?,? |
else if qword eq type | pword eq type |
dd ?,? |
else |
dd ? |
end if \} |
match =current@arg,current@arg |
\{ current@arg equ arg |
arg equ ..arg |
..arg dd ? \} |
common |
args@proc equ current@arg |
forward |
restore current@arg |
common |
end if } |
macro deflocal@proc name,def,[val] |
{ common |
match vars, all@vars \{ all@vars equ all@vars, \} |
all@vars equ all@vars name |
forward |
local ..var,..tmp |
..var def val |
match =?, val \{ ..tmp equ \} |
match any =dup (=?), val \{ ..tmp equ \} |
match tmp : value, ..tmp : val |
\{ tmp: end virtual |
initlocal@proc ..var,def value |
virtual at tmp\} |
common |
match first rest, ..var, \{ name equ first \} } |
macro initlocal@proc name,def |
{ virtual at name |
def |
size@initlocal = $ - name |
end virtual |
position@initlocal = 0 |
while size@initlocal > position@initlocal |
virtual at name |
def |
if size@initlocal - position@initlocal < 2 |
current@initlocal = 1 |
load byte@initlocal byte from name+position@initlocal |
else if size@initlocal - position@initlocal < 4 |
current@initlocal = 2 |
load word@initlocal word from name+position@initlocal |
else |
current@initlocal = 4 |
load dword@initlocal dword from name+position@initlocal |
end if |
end virtual |
if current@initlocal = 1 |
mov byte [name+position@initlocal],byte@initlocal |
else if current@initlocal = 2 |
mov word [name+position@initlocal],word@initlocal |
else |
mov dword [name+position@initlocal],dword@initlocal |
end if |
position@initlocal = position@initlocal + current@initlocal |
end while } |
macro endp |
{ purge ret,locals,endl |
finish@proc |
purge finish@proc |
restore regs@proc |
match all,args@proc \{ restore all \} |
restore args@proc |
match all,all@vars \{ restore all \} } |
macro local [var] |
{ common |
locals |
forward done@local equ |
match varname[count]:vartype, var |
\{ match =BYTE, vartype \\{ varname rb count |
restore done@local \\} |
match =WORD, vartype \\{ varname rw count |
restore done@local \\} |
match =DWORD, vartype \\{ varname rd count |
restore done@local \\} |
match =PWORD, vartype \\{ varname rp count |
restore done@local \\} |
match =QWORD, vartype \\{ varname rq count |
restore done@local \\} |
match =TBYTE, vartype \\{ varname rt count |
restore done@local \\} |
match =DQWORD, vartype \\{ label varname dqword |
rq count+count |
restore done@local \\} |
match , done@local \\{ virtual |
varname vartype |
end virtual |
rb count*sizeof.\#vartype |
restore done@local \\} \} |
match :varname:vartype, done@local:var |
\{ match =BYTE, vartype \\{ varname db ? |
restore done@local \\} |
match =WORD, vartype \\{ varname dw ? |
restore done@local \\} |
match =DWORD, vartype \\{ varname dd ? |
restore done@local \\} |
match =PWORD, vartype \\{ varname dp ? |
restore done@local \\} |
match =QWORD, vartype \\{ varname dq ? |
restore done@local \\} |
match =TBYTE, vartype \\{ varname dt ? |
restore done@local \\} |
match =DQWORD, vartype \\{ label varname dqword |
dq ?,? |
restore done@local \\} |
match , done@local \\{ varname vartype |
restore done@local \\} \} |
match ,done@local |
\{ var |
restore done@local \} |
common |
endl } |
/programs/media/ac97 mp3/trunk/mp3dec/bstream.c |
---|
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 ) |
*/ |
/programs/media/ac97 mp3/trunk/mp3dec/bstream.h |
---|
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); |
/programs/media/ac97 mp3/trunk/mp3dec/e_pow.c |
---|
0,0 → 1,358 |
/* @(#)e_pow.c 5.1 93/09/24 */ |
/* |
* ==================================================== |
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. |
* |
* Developed at SunPro, a Sun Microsystems, Inc. business. |
* Permission to use, copy, modify, and distribute this |
* software is freely granted, provided that this notice |
* is preserved. |
* ==================================================== |
*/ |
/* Modified by Naohiko Shimizu/Tokai University, Japan 1997/08/25, |
for performance improvement on pipelined processors. |
*/ |
#if defined(LIBM_SCCS) && !defined(lint) |
static char rcsid[] = "$NetBSD: e_pow.c,v 1.9 1995/05/12 04:57:32 jtc Exp $"; |
#endif |
/* __ieee754_pow(x,y) return x**y |
* |
* n |
* Method: Let x = 2 * (1+f) |
* 1. Compute and return log2(x) in two pieces: |
* log2(x) = w1 + w2, |
* where w1 has 53-24 = 29 bit trailing zeros. |
* 2. Perform y*log2(x) = n+y' by simulating muti-precision |
* arithmetic, where |y'|<=0.5. |
* 3. Return x**y = 2**n*exp(y'*log2) |
* |
* Special cases: |
* 1. (anything) ** 0 is 1 |
* 2. (anything) ** 1 is itself |
* 3. (anything) ** NAN is NAN |
* 4. NAN ** (anything except 0) is NAN |
* 5. +-(|x| > 1) ** +INF is +INF |
* 6. +-(|x| > 1) ** -INF is +0 |
* 7. +-(|x| < 1) ** +INF is +0 |
* 8. +-(|x| < 1) ** -INF is +INF |
* 9. +-1 ** +-INF is NAN |
* 10. +0 ** (+anything except 0, NAN) is +0 |
* 11. -0 ** (+anything except 0, NAN, odd integer) is +0 |
* 12. +0 ** (-anything except 0, NAN) is +INF |
* 13. -0 ** (-anything except 0, NAN, odd integer) is +INF |
* 14. -0 ** (odd integer) = -( +0 ** (odd integer) ) |
* 15. +INF ** (+anything except 0,NAN) is +INF |
* 16. +INF ** (-anything except 0,NAN) is +0 |
* 17. -INF ** (anything) = -0 ** (-anything) |
* 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer) |
* 19. (-anything except 0 and inf) ** (non-integer) is NAN |
* |
* Accuracy: |
* pow(x,y) returns x**y nearly rounded. In particular |
* pow(integer,integer) |
* always returns the correct integer provided it is |
* representable. |
* |
* Constants : |
* The hexadecimal values are the intended ones for the following |
* constants. The decimal values may be used, provided that the |
* compiler will convert from decimal to binary accurately enough |
* to produce the hexadecimal values shown. |
*/ |
#include "math.h" |
#include "math_private.h" |
#define zero C[0] |
#define one C[1] |
#define two C[2] |
#define two53 C[3] |
#define huge C[4] |
#define tiny C[5] |
#define L1 C[6] |
#define L2 C[7] |
#define L3 C[8] |
#define L4 C[9] |
#define L5 C[10] |
#define L6 C[11] |
#define P1 C[12] |
#define P2 C[13] |
#define P3 C[14] |
#define P4 C[15] |
#define P5 C[16] |
#define lg2 C[17] |
#define lg2_h C[18] |
#define lg2_l C[19] |
#define ovt C[20] |
#define cp C[21] |
#define cp_h C[22] |
#define cp_l C[23] |
#define ivln2 C[24] |
#define ivln2_h C[25] |
#define ivln2_l C[26] |
double scalbn(double,int); |
#define EXTRACT_WORDS(ix0,ix1,d) \ |
do { \ |
ieee_double_shape_type ew_u; \ |
ew_u.value = (d); \ |
(ix0) = ew_u.parts.msw; \ |
(ix1) = ew_u.parts.lsw; \ |
} while (0) |
#ifdef __STDC__ |
static const double |
#else |
static double |
#endif |
bp[] = {1.0, 1.5,}, |
dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */ |
dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */ |
C[] = { |
0.0, |
1.0, |
2.0, |
9007199254740992.0 , |
1.0e300, |
1.0e-300, |
5.99999999999994648725e-01 , |
4.28571428578550184252e-01 , |
3.33333329818377432918e-01 , |
2.72728123808534006489e-01 , |
2.30660745775561754067e-01 , |
2.06975017800338417784e-01 , |
1.66666666666666019037e-01 , |
-2.77777777770155933842e-03 , |
6.61375632143793436117e-05 , |
-1.65339022054652515390e-06 , |
4.13813679705723846039e-08 , |
6.93147180559945286227e-01 , |
6.93147182464599609375e-01 , |
-1.90465429995776804525e-09 , |
8.0085662595372944372e-0017 , |
9.61796693925975554329e-01 , |
9.61796700954437255859e-01 , |
-7.02846165095275826516e-09 , |
1.44269504088896338700e+00 , |
1.44269502162933349609e+00 , |
1.92596299112661746887e-08 }; |
double pow_test(x,y) |
double x, y; |
{ |
double z,ax,z_h,z_l,p_h,p_l; |
double y1,t1,t2,r,s,t,u,v,w, t12,t14,r_1,r_2,r_3; |
int32_t i,j,k,yisint,n; |
int32_t hx,hy,ix,iy; |
u_int32_t lx,ly; |
EXTRACT_WORDS(hx,lx,x); |
EXTRACT_WORDS(hy,ly,y); |
ix = hx&0x7fffffff; iy = hy&0x7fffffff; |
/* y==zero: x**0 = 1 */ |
if((iy|ly)==0) return C[1]; |
/* +-NaN return x+y */ |
if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) || |
iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0))) |
return x+y; |
/* determine if y is an odd int when x < 0 |
* yisint = 0 ... y is not an integer |
* yisint = 1 ... y is an odd int |
* yisint = 2 ... y is an even int |
*/ |
yisint = 0; |
if(hx<0) { |
if(iy>=0x43400000) yisint = 2; /* even integer y */ |
else if(iy>=0x3ff00000) { |
k = (iy>>20)-0x3ff; /* exponent */ |
if(k>20) { |
j = ly>>(52-k); |
if((u_int32_t)(j<<(52-k))==ly) yisint = 2-(j&1); |
} else if(ly==0) { |
j = iy>>(20-k); |
if((int32_t)(j<<(20-k))==iy) yisint = 2-(j&1); |
} |
} |
} |
/* special value of y */ |
if(ly==0) { |
if (iy==0x7ff00000) { /* y is +-inf */ |
if(((ix-0x3ff00000)|lx)==0) |
return y - y; /* inf**+-1 is NaN */ |
else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */ |
return (hy>=0)? y: C[0]; |
else /* (|x|<1)**-,+inf = inf,0 */ |
return (hy<0)?-y: C[0]; |
} |
if(iy==0x3ff00000) { /* y is +-1 */ |
if(hy<0) return C[1]/x; else return x; |
} |
if(hy==0x40000000) return x*x; /* y is 2 */ |
if(hy==0x3fe00000) { /* y is 0.5 */ |
if(hx>=0) /* x >= +0 */ |
return sqrt(x); |
} |
} |
ax = fabs(x); |
/* special value of x */ |
if(lx==0) { |
if(ix==0x7ff00000||ix==0||ix==0x3ff00000){ |
z = ax; /*x is +-0,+-inf,+-1*/ |
if(hy<0) z = C[1]/z; /* z = (1/|x|) */ |
if(hx<0) { |
if(((ix-0x3ff00000)|yisint)==0) { |
z = (z-z)/(z-z); /* (-1)**non-int is NaN */ |
} else if(yisint==1) |
z = -z; /* (x<0)**odd = -(|x|**odd) */ |
} |
return z; |
} |
} |
/* (x<0)**(non-int) is NaN */ |
if(((((u_int32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x); |
/* |y| is huge */ |
if(iy>0x41e00000) { /* if |y| > 2**31 */ |
if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */ |
if(ix<=0x3fefffff) return (hy<0)? C[4]*C[4]:C[5]*C[5]; |
if(ix>=0x3ff00000) return (hy>0)? C[4]*C[4]:C[5]*C[5]; |
} |
/* over/underflow if x is not close to one */ |
if(ix<0x3fefffff) return (hy<0)? C[4]*C[4]:C[5]*C[5]; |
if(ix>0x3ff00000) return (hy>0)? C[4]*C[4]:C[5]*C[5]; |
/* now |1-x| is tiny <= 2**-20, suffice to compute |
log(x) by x-x^2/2+x^3/3-x^4/4 */ |
t = x-1; /* t has 20 trailing zeros */ |
w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25)); |
u = C[25]*t; /* ivln2_h has 21 sig. bits */ |
v = t*C[26]-w*C[24]; |
t1 = u+v; |
SET_LOW_WORD(t1,0); |
t2 = v-(t1-u); |
} else { |
double s2,s_h,s_l,t_h,t_l,s22,s24,s26,r1,r2,r3; |
n = 0; |
/* take care subnormal number */ |
if(ix<0x00100000) |
{ax *= C[3]; n -= 53; GET_HIGH_WORD(ix,ax); } |
n += ((ix)>>20)-0x3ff; |
j = ix&0x000fffff; |
/* determine interval */ |
ix = j|0x3ff00000; /* normalize ix */ |
if(j<=0x3988E) k=0; /* |x|<sqrt(3/2) */ |
else if(j<0xBB67A) k=1; /* |x|<sqrt(3) */ |
else {k=0;n+=1;ix -= 0x00100000;} |
SET_HIGH_WORD(ax,ix); |
/* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */ |
u = ax-bp[k]; /* bp[0]=1.0, bp[1]=1.5 */ |
v = C[1]/(ax+bp[k]); |
s = u*v; |
s_h = s; |
SET_LOW_WORD(s_h,0); |
/* t_h=ax+bp[k] High */ |
t_h = C[0]; |
SET_HIGH_WORD(t_h,((ix>>1)|0x20000000)+0x00080000+(k<<18)); |
t_l = ax - (t_h-bp[k]); |
s_l = v*((u-s_h*t_h)-s_h*t_l); |
/* compute log(ax) */ |
s2 = s*s; |
#ifdef DO_NOT_USE_THIS |
r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6))))); |
#else |
r1 = C[10]+s2*C[11]; s22=s2*s2; |
r2 = C[8]+s2*C[9]; s24=s22*s22; |
r3 = C[6]+s2*C[7]; s26=s24*s22; |
r = r3*s22 + r2*s24 + r1*s26; |
#endif |
r += s_l*(s_h+s); |
s2 = s_h*s_h; |
t_h = 3.0+s2+r; |
SET_LOW_WORD(t_h,0); |
t_l = r-((t_h-3.0)-s2); |
/* u+v = s*(1+...) */ |
u = s_h*t_h; |
v = s_l*t_h+t_l*s; |
/* 2/(3log2)*(s+...) */ |
p_h = u+v; |
SET_LOW_WORD(p_h,0); |
p_l = v-(p_h-u); |
z_h = C[22]*p_h; /* cp_h+cp_l = 2/(3*log2) */ |
z_l = C[23]*p_h+p_l*C[21]+dp_l[k]; |
/* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */ |
t = (double)n; |
t1 = (((z_h+z_l)+dp_h[k])+t); |
SET_LOW_WORD(t1,0); |
t2 = z_l-(((t1-t)-dp_h[k])-z_h); |
} |
s = C[1]; /* s (sign of result -ve**odd) = -1 else = 1 */ |
if(((((u_int32_t)hx>>31)-1)|(yisint-1))==0) |
s = -C[1];/* (-ve)**(odd int) */ |
/* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */ |
y1 = y; |
SET_LOW_WORD(y1,0); |
p_l = (y-y1)*t1+y*t2; |
p_h = y1*t1; |
z = p_l+p_h; |
EXTRACT_WORDS(j,i,z); |
if (j>=0x40900000) { /* z >= 1024 */ |
if(((j-0x40900000)|i)!=0) /* if z > 1024 */ |
return s*C[4]*C[4]; /* overflow */ |
else { |
if(p_l+C[20]>z-p_h) return s*C[4]*C[4]; /* overflow */ |
} |
} else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */ |
if(((j-0xc090cc00)|i)!=0) /* z < -1075 */ |
return s*C[5]*C[5]; /* underflow */ |
else { |
if(p_l<=z-p_h) return s*C[5]*C[5]; /* underflow */ |
} |
} |
/* |
* compute 2**(p_h+p_l) |
*/ |
i = j&0x7fffffff; |
k = (i>>20)-0x3ff; |
n = 0; |
if(i>0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */ |
n = j+(0x00100000>>(k+1)); |
k = ((n&0x7fffffff)>>20)-0x3ff; /* new k for n */ |
t = C[0]; |
SET_HIGH_WORD(t,n&~(0x000fffff>>k)); |
n = ((n&0x000fffff)|0x00100000)>>(20-k); |
if(j<0) n = -n; |
p_h -= t; |
} |
t = p_l+p_h; |
SET_LOW_WORD(t,0); |
u = t*C[18]; |
v = (p_l-(t-p_h))*C[17]+t*C[19]; |
z = u+v; |
w = v-(z-u); |
t = z*z; |
#ifdef DO_NOT_USE_THIS |
t1 = z - t*(C[12]+t*(C[13]+t*(C[14]+t*(C[15]+t*C[16])))); |
#else |
r_1 = C[15]+t*C[16]; t12 = t*t; |
r_2 = C[13]+t*C[14]; t14 = t12*t12; |
r_3 = t*C[12]; |
t1 = z - r_3 - t12*r_2 - t14*r_1; |
#endif |
r = (z*t1)/(t1-C[2])-(w+z*w); |
z = C[1]-(r-z); |
GET_HIGH_WORD(j,z); |
j += (n<<20); |
if((j>>20)<=0) z = scalbn(z,n); /* subnormal output */ |
else SET_HIGH_WORD(z,j); |
return s*z; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/fdct.c |
---|
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); |
} |
/programs/media/ac97 mp3/trunk/mp3dec/imdct.c |
---|
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; |
} |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l1dec.c |
---|
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 */ |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l1init.c |
---|
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; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l2dec.c |
---|
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 */ |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l2init.c |
---|
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; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3alias.c |
---|
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; |
} |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3dec.c |
---|
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); |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3huff.c |
---|
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) */ |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3huff.h |
---|
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 */ |
/programs/media/ac97 mp3/trunk/mp3dec/l3hybrid.c |
---|
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]; |
} |
} |
} |
/*--------------------------------------------------------------------*/ |
/programs/media/ac97 mp3/trunk/mp3dec/l3init.c |
---|
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; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3msis.c |
---|
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; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3quant.c |
---|
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 */ |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3sf.c |
---|
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; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/l3side.c |
---|
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; |
} |
/programs/media/ac97 mp3/trunk/mp3dec/layer3.h |
---|
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; |
/programs/media/ac97 mp3/trunk/mp3dec/math_private.h |
---|
0,0 → 1,209 |
/* |
* ==================================================== |
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. |
* |
* Developed at SunPro, a Sun Microsystems, Inc. business. |
* Permission to use, copy, modify, and distribute this |
* software is freely granted, provided that this notice |
* is preserved. |
* ==================================================== |
*/ |
/* |
* from: @(#)fdlibm.h 5.1 93/09/24 |
* $Id: math_private.h,v 1.8 1998/11/27 11:33:46 drepper Exp $ |
*/ |
#ifndef _MATH_PRIVATE_H_ |
#define _MATH_PRIVATE_H_ |
/* The original fdlibm code used statements like: |
n0 = ((*(int*)&one)>>29)^1; * index of high word * |
ix0 = *(n0+(int*)&x); * high word of x * |
ix1 = *((1-n0)+(int*)&x); * low word of x * |
to dig two 32 bit words out of the 64 bit IEEE floating point |
value. That is non-ANSI, and, moreover, the gcc instruction |
scheduler gets it wrong. We instead use the following macros. |
Unlike the original code, we determine the endianness at compile |
time, not at run time; I don't see much benefit to selecting |
endianness at run time. */ |
/* A union which permits us to convert between a double and two 32 bit |
ints. */ |
typedef int int32_t; |
typedef unsigned int u_int32_t; |
typedef union |
{ |
double value; |
struct |
{ |
u_int32_t lsw; |
u_int32_t msw; |
} parts; |
} ieee_double_shape_type; |
/* Get two 32 bit ints from a double. */ |
#define EXTRACT_WORDS(ix0,ix1,d) \ |
do { \ |
ieee_double_shape_type ew_u; \ |
ew_u.value = (d); \ |
(ix0) = ew_u.parts.msw; \ |
(ix1) = ew_u.parts.lsw; \ |
} while (0) |
/* Get the more significant 32 bit int from a double. */ |
#define GET_HIGH_WORD(i,d) \ |
do { \ |
ieee_double_shape_type gh_u; \ |
gh_u.value = (d); \ |
(i) = gh_u.parts.msw; \ |
} while (0) |
/* Get the less significant 32 bit int from a double. */ |
#define GET_LOW_WORD(i,d) \ |
do { \ |
ieee_double_shape_type gl_u; \ |
gl_u.value = (d); \ |
(i) = gl_u.parts.lsw; \ |
} while (0) |
/* Set a double from two 32 bit ints. */ |
#define INSERT_WORDS(d,ix0,ix1) \ |
do { \ |
ieee_double_shape_type iw_u; \ |
iw_u.parts.msw = (ix0); \ |
iw_u.parts.lsw = (ix1); \ |
(d) = iw_u.value; \ |
} while (0) |
/* Set the more significant 32 bits of a double from an int. */ |
#define SET_HIGH_WORD(d,v) \ |
do { \ |
ieee_double_shape_type sh_u; \ |
sh_u.value = (d); \ |
sh_u.parts.msw = (v); \ |
(d) = sh_u.value; \ |
} while (0) |
/* Set the less significant 32 bits of a double from an int. */ |
#define SET_LOW_WORD(d,v) \ |
do { \ |
ieee_double_shape_type sl_u; \ |
sl_u.value = (d); \ |
sl_u.parts.lsw = (v); \ |
(d) = sl_u.value; \ |
} while (0) |
/* A union which permits us to convert between a float and a 32 bit |
int. */ |
typedef union |
{ |
float value; |
u_int32_t word; |
} ieee_float_shape_type; |
/* Get a 32 bit int from a float. */ |
#define GET_FLOAT_WORD(i,d) \ |
do { \ |
ieee_float_shape_type gf_u; \ |
gf_u.value = (d); \ |
(i) = gf_u.word; \ |
} while (0) |
/* Set a float from a 32 bit int. */ |
#define SET_FLOAT_WORD(d,i) \ |
do { \ |
ieee_float_shape_type sf_u; \ |
sf_u.word = (i); \ |
(d) = sf_u.value; \ |
} while (0) |
/* A union which permits us to convert between a long double and |
three 32 bit ints. */ |
typedef union |
{ |
long double value; |
struct |
{ |
u_int32_t lsw; |
u_int32_t msw; |
unsigned int sign_exponent:16; |
unsigned int empty:16; |
} parts; |
} ieee_long_double_shape_type; |
/* Get three 32 bit ints from a double. */ |
#define GET_LDOUBLE_WORDS(exp,ix0,ix1,d) \ |
do { \ |
ieee_long_double_shape_type ew_u; \ |
ew_u.value = (d); \ |
(exp) = ew_u.parts.sign_exponent; \ |
(ix0) = ew_u.parts.msw; \ |
(ix1) = ew_u.parts.lsw; \ |
} while (0) |
/* Set a double from two 32 bit ints. */ |
#define SET_LDOUBLE_WORDS(d,exp,ix0,ix1) \ |
do { \ |
ieee_long_double_shape_type iw_u; \ |
iw_u.parts.sign_exponent = (exp); \ |
iw_u.parts.msw = (ix0); \ |
iw_u.parts.lsw = (ix1); \ |
(d) = iw_u.value; \ |
} while (0) |
/* Get the more significant 32 bits of a long double mantissa. */ |
#define GET_LDOUBLE_MSW(v,d) \ |
do { \ |
ieee_long_double_shape_type sh_u; \ |
sh_u.value = (d); \ |
(v) = sh_u.parts.msw; \ |
} while (0) |
/* Set the more significant 32 bits of a long double mantissa from an int. */ |
#define SET_LDOUBLE_MSW(d,v) \ |
do { \ |
ieee_long_double_shape_type sh_u; \ |
sh_u.value = (d); \ |
sh_u.parts.msw = (v); \ |
(d) = sh_u.value; \ |
} while (0) |
/* Get int from the exponent of a long double. */ |
#define GET_LDOUBLE_EXP(exp,d) \ |
do { \ |
ieee_long_double_shape_type ge_u; \ |
ge_u.value = (d); \ |
(exp) = ge_u.parts.sign_exponent; \ |
} while (0) |
/* Set exponent of a long double from an int. */ |
#define SET_LDOUBLE_EXP(d,exp) \ |
do { \ |
ieee_long_double_shape_type se_u; \ |
se_u.value = (d); \ |
se_u.parts.sign_exponent = (exp); \ |
(d) = se_u.value; \ |
} while (0) |
#endif /* _MATH_PRIVATE_H_ */ |
/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.c |
---|
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í |
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; |
/*///////////////////////////////// |
//WVBRÎ |
if ( p[0] == mpeg[0] && p[1] == mpeg[1] ) { |
info->skipSize = (int)(p - mpeg); |
} else { |
info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000; |
switch (h->layer) { |
case 1://layer1 |
m_frame_size = (12 * info->bitRate / fr_tbl[h->version-1][h->fr_index]) * 4;//one slot is 4 bytes long |
if (h->padding) m_frame_size += 4; |
break; |
case 2://layer2 |
m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index]; |
if (h->padding) m_frame_size ++; |
break; |
case 3://layer3 |
m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index]; |
if (h->version != 1) //MPEG-2, MPEG-2.5 |
m_frame_size /= 2; |
if (h->padding) m_frame_size; |
break; |
} |
info->skipSize = (int)(m_frame_size); |
} |
info->bitRate = 0; |
/////////////////////////////////*/ |
vbr = 1; |
minBitRate = 0xffffffff; |
maxBitRate = 0; |
for (i = 1; i < 15; i ++) { |
j = br_tbl[h->version-1][h->layer-1][i] * 1000; |
if (j < minBitRate) minBitRate = j; |
if (j > maxBitRate) maxBitRate = j; |
} |
} |
else if (memcmp(p, "VBRI", 4) == 0) {//VBRI |
p += 10; |
info->dataSize = extractInt4(p); |
p += 4; |
info->frames = extractInt4(p); |
p += 4; |
vbr = 1; |
minBitRate = 0xffffffff; |
maxBitRate = 0; |
for (i = 1; i < 15; i ++) { |
j = br_tbl[h->version-1][h->layer-1][i] * 1000; |
if (j < minBitRate) minBitRate = j; |
if (j > maxBitRate) maxBitRate = j; |
} |
} |
else {//not VBR |
vbr = 0; |
info->frames = 0; |
//info->skipSize = 0; |
info->dataSize = 0; |
//info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000; |
} |
// info->frequency = fr_tbl[h->version-1][h->fr_index]; |
// info->msPerFrame = ms_p_f_table[h->layer-1][h->fr_index]; |
// if (h->version == 3) info->msPerFrame *= 2; |
switch (h->layer) { |
case 1://layer1 |
info->outputSize = 384 >> m_option.reduction; |
//if (info->bitRate) { |
if (!vbr) { |
info->skipSize = 0; |
info->minInputSize = (12 * info->bitRate / info->frequency) * 4;//one slot is 4 bytes long |
info->maxInputSize = info->minInputSize + 4; |
} |
else { |
info->skipSize = (12 * info->bitRate / info->frequency + h->padding) * 4; |
info->minInputSize = (12 * minBitRate / info->frequency) * 4; |
info->maxInputSize = (12 * maxBitRate / info->frequency) * 4 + 4; |
} |
break; |
case 2://layer2 |
info->outputSize = 1152 >> m_option.reduction; |
//if (info->bitRate) { |
if (!vbr) { |
info->skipSize = 0; |
info->minInputSize = 144 * info->bitRate / info->frequency; |
info->maxInputSize = info->minInputSize + 1; |
} |
else { |
info->skipSize = 144 * info->bitRate / info->frequency + h->padding; |
info->minInputSize = 144 * minBitRate / info->frequency; |
info->maxInputSize = 144 * maxBitRate / info->frequency + 1; |
} |
break; |
case 3://layer3 |
i = (h->version == 1) ? 1 : 2; |
//info->outputSize = 1152 >> m_option.reduction; |
info->outputSize = (1152 >> m_option.reduction) / i; |
//if (info->bitRate) { |
if (!vbr) { |
info->skipSize = 0; |
info->minInputSize = 144 * info->bitRate / info->frequency / i; |
info->maxInputSize = info->minInputSize + 1; |
} |
else { |
info->skipSize = 144 * info->bitRate / info->frequency / i + h->padding; |
info->minInputSize = 144 * minBitRate / info->frequency / i; |
info->maxInputSize = 144 * maxBitRate / info->frequency / i + 1; |
} |
break; |
/* |
if (h->version != 1) { |
//MPEG-2, MPEG-2.5 |
info->outputSize /= 2; |
info->minInputSize /= 2; |
info->maxInputSize /= 2; |
} |
info->maxInputSize ++; |
break; */ |
} |
if ((h->mode == 3) || (m_option.convert & 3)) |
info->channels = 1; |
else |
info->channels = 2; |
if (m_option.convert & 8) { |
//not available |
info->bitsPerSample = 8; |
info->outputSize *= info->channels; |
} |
else { |
info->bitsPerSample = 16; |
info->outputSize *= info->channels * 2; |
} |
if ( decFlag == 1 ) { |
m_frequency = info->frequency; |
m_pcm_size = info->outputSize; |
} |
info->frequency >>= m_option.reduction; |
if (vbr) info->bitRate = 0; |
return 1; |
} |
void sbt_init(); |
int mp3DecodeStart(byte* mpeg, int size) |
{ |
MPEG_DECODE_INFO info; |
MPEG_HEADER* h = &info.header; |
if (!mp3GetDecodeInfo(mpeg, size, &info, 1)) { |
return 0; |
} |
sbt_init(); |
switch (h->layer) { |
case 1: |
L1decode_start(h); |
m_frame_proc = L1decode_frame; |
break; |
case 2: |
L2decode_start(h); |
m_frame_proc = L2decode_frame; |
break; |
case 3: |
L3decode_start(h); |
m_frame_proc = L3decode_frame; |
break; |
} |
return 1; |
} |
int mp3DecodeFrame(MPEG_DECODE_PARAM* param) |
{ |
MPEG_HEADER* h = ¶m->header; |
if (param->inputSize <= 4) { |
m_last_error = MP3_ERROR_OUT_OF_BUFFER; |
return 0; |
} |
if (!mp3GetHeader(param->inputBuf, h)) { |
return 0; |
} |
param->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000; |
switch (h->layer) { |
case 1://layer1 |
m_frame_size = (12 * param->bitRate / m_frequency + h->padding) * 4; |
break; |
case 2://layer2 |
m_frame_size = 144 * param->bitRate / m_frequency + h->padding; |
break; |
case 3://layer3 |
if (h->version == 1) m_frame_size = 144 * param->bitRate / m_frequency + h->padding; |
else m_frame_size = (144 * param->bitRate / m_frequency) / 2 + h->padding; |
break; |
} |
if (param->inputSize < m_frame_size) { |
m_last_error = MP3_ERROR_OUT_OF_BUFFER; |
return 0; |
} |
m_frame_proc(h, param->inputBuf, param->outputBuf); |
param->inputSize = m_frame_size; |
param->outputSize = m_pcm_size; |
return 1; |
} |
void null_frame_proc(MPEG_HEADER* h, byte* mpeg, byte* pcm) {} |
void L3decode_reset(); |
void mp3MuteStart(MPEG_DECODE_PARAM* param) |
{ |
m_frame_proc = null_frame_proc; |
} |
void mp3MuteEnd(MPEG_DECODE_PARAM* param) |
{ |
MPEG_HEADER* h = ¶m->header; |
switch (h->layer) { |
case 1: |
m_frame_proc = L1decode_frame; |
break; |
case 2: |
m_frame_proc = L2decode_frame; |
break; |
case 3: |
L3decode_reset(); |
m_frame_proc = L3decode_frame; |
break; |
} |
} |
/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.h |
---|
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; //oÍ`l |
int bitsPerSample; // |
int frequency; //TvO[giHzj |
int bitRate; //rbg[gibpsj |
int frames; //t[iVBR onlyj |
int skipSize; //iVBR onlyj |
int dataSize; //f[^TCYiVBR onlyj |
int minInputSize; //1t[ÌŬüÍTCY |
int maxInputSize; //1t[ÌÅåüÍTCY |
int outputSize; //1t[ÌoÍTCY |
} MPEG_DECODE_INFO; |
typedef struct { |
MPEG_HEADER header; |
int bitRate; //rbg[gibpsj |
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 |
/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.vcproj |
---|
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
" |
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> |
/programs/media/ac97 mp3/trunk/mp3dec/pow.asm |
---|
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 |
/programs/media/ac97 mp3/trunk/mp3dec/sbt.c |
---|
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; |
} |
} |
} |
/programs/media/ac97 mp3/trunk/mp3dec/sbtb.c |
---|
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; |
} |
} |
} |
/programs/media/ac97 mp3/trunk/mp3dec/window.c |
---|
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; |
} |
} |
/programs/media/ac97 mp3/trunk/mp3dec/windowb.c |
---|
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; |
} |
} |
/programs/. |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |