diff --git a/programs/media/ac97 mp3/trunk/PROC32.INC b/programs/media/ac97 mp3/trunk/PROC32.INC new file mode 100644 index 0000000000..23c56b03c1 --- /dev/null +++ b/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, \{ 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: + \\\{ 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 } diff --git a/programs/media/ac97 mp3/trunk/ac97.sln b/programs/media/ac97 mp3/trunk/ac97.sln new file mode 100644 index 0000000000..f0751f6193 --- /dev/null +++ b/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 diff --git a/programs/media/ac97 mp3/trunk/ac97wav.c b/programs/media/ac97 mp3/trunk/ac97wav.c new file mode 100644 index 0000000000..1056641779 --- /dev/null +++ b/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"); + + + diff --git a/programs/media/ac97 mp3/trunk/ac97wav.h b/programs/media/ac97 mp3/trunk/ac97wav.h new file mode 100644 index 0000000000..2e179815ca --- /dev/null +++ b/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(); diff --git a/programs/media/ac97 mp3/trunk/crt.c b/programs/media/ac97 mp3/trunk/crt.c new file mode 100644 index 0000000000..800763bbed --- /dev/null +++ b/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(); +} + + diff --git a/programs/media/ac97 mp3/trunk/crt.h b/programs/media/ac97 mp3/trunk/crt.h new file mode 100644 index 0000000000..0c00649423 --- /dev/null +++ b/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(); diff --git a/programs/media/ac97 mp3/trunk/k_lib.asm b/programs/media/ac97 mp3/trunk/k_lib.asm new file mode 100644 index 0000000000..257d9947ef --- /dev/null +++ b/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 + diff --git a/programs/media/ac97 mp3/trunk/kolibri.h b/programs/media/ac97 mp3/trunk/kolibri.h new file mode 100644 index 0000000000..f2711e74ca --- /dev/null +++ b/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); + diff --git a/programs/media/ac97 mp3/trunk/mp3dec/PROC32.INC b/programs/media/ac97 mp3/trunk/mp3dec/PROC32.INC new file mode 100644 index 0000000000..23c56b03c1 --- /dev/null +++ b/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, \{ 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: + \\\{ 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 } diff --git a/programs/media/ac97 mp3/trunk/mp3dec/bstream.c b/programs/media/ac97 mp3/trunk/mp3dec/bstream.c new file mode 100644 index 0000000000..722aa61320 --- /dev/null +++ b/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 ) +*/ \ No newline at end of file diff --git a/programs/media/ac97 mp3/trunk/mp3dec/bstream.h b/programs/media/ac97 mp3/trunk/mp3dec/bstream.h new file mode 100644 index 0000000000..8bb956932f --- /dev/null +++ b/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); diff --git a/programs/media/ac97 mp3/trunk/mp3dec/e_pow.c b/programs/media/ac97 mp3/trunk/mp3dec/e_pow.c new file mode 100644 index 0000000000..bc9e88e267 --- /dev/null +++ b/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|>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; +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/fdct.c b/programs/media/ac97 mp3/trunk/mp3dec/fdct.c new file mode 100644 index 0000000000..6c0eafd721 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/fdct.c @@ -0,0 +1,290 @@ +#include + +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); +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/imdct.c b/programs/media/ac97 mp3/trunk/mp3dec/imdct.c new file mode 100644 index 0000000000..51de5c26c0 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/imdct.c @@ -0,0 +1,222 @@ +#include + +/*------ 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; + } +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l1dec.c b/programs/media/ac97 mp3/trunk/mp3dec/l1dec.c new file mode 100644 index 0000000000..139940fa48 --- /dev/null +++ b/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 */ +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l1init.c b/programs/media/ac97 mp3/trunk/mp3dec/l1init.c new file mode 100644 index 0000000000..002544a333 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l1init.c @@ -0,0 +1,87 @@ +#include "bstream.h" +#include "mp3dec.h" +#include + +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; +} + diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l2dec.c b/programs/media/ac97 mp3/trunk/mp3dec/l2dec.c new file mode 100644 index 0000000000..0b91e6bc38 --- /dev/null +++ b/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 */ +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l2init.c b/programs/media/ac97 mp3/trunk/mp3dec/l2init.c new file mode 100644 index 0000000000..4df071c09f --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l2init.c @@ -0,0 +1,205 @@ +#include "bstream.h" +#include "mp3dec.h" +#include + +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; +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3alias.c b/programs/media/ac97 mp3/trunk/mp3dec/l3alias.c new file mode 100644 index 0000000000..0dc28d5b5b --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l3alias.c @@ -0,0 +1,38 @@ +#include //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; + } + +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3dec.c b/programs/media/ac97 mp3/trunk/mp3dec/l3dec.c new file mode 100644 index 0000000000..70e0852a52 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l3dec.c @@ -0,0 +1,350 @@ +#include "layer3.h" +#include +#include + +#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); +} + diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3huff.c b/programs/media/ac97 mp3/trunk/mp3dec/l3huff.c new file mode 100644 index 0000000000..5bb344a2be --- /dev/null +++ b/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) */ + +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3huff.h b/programs/media/ac97 mp3/trunk/mp3dec/l3huff.h new file mode 100644 index 0000000000..eba3de4be6 --- /dev/null +++ b/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 */ diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3hybrid.c b/programs/media/ac97 mp3/trunk/mp3dec/l3hybrid.c new file mode 100644 index 0000000000..5d71d5945e --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l3hybrid.c @@ -0,0 +1,265 @@ +#include + +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]; + } + } +} +/*--------------------------------------------------------------------*/ diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3init.c b/programs/media/ac97 mp3/trunk/mp3dec/l3init.c new file mode 100644 index 0000000000..ad2071edb0 --- /dev/null +++ b/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; +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3msis.c b/programs/media/ac97 mp3/trunk/mp3dec/l3msis.c new file mode 100644 index 0000000000..7ad34b4185 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l3msis.c @@ -0,0 +1,332 @@ +#include "layer3.h" +#include +//#include + +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; +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3quant.c b/programs/media/ac97 mp3/trunk/mp3dec/l3quant.c new file mode 100644 index 0000000000..3e8f02519a --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/l3quant.c @@ -0,0 +1,217 @@ +#include "layer3.h" + +#include +#include //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 */ +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3sf.c b/programs/media/ac97 mp3/trunk/mp3dec/l3sf.c new file mode 100644 index 0000000000..bb2ce91540 --- /dev/null +++ b/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; +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/l3side.c b/programs/media/ac97 mp3/trunk/mp3dec/l3side.c new file mode 100644 index 0000000000..8af3a24a84 --- /dev/null +++ b/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; +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/layer3.h b/programs/media/ac97 mp3/trunk/mp3dec/layer3.h new file mode 100644 index 0000000000..2f89d9bd53 --- /dev/null +++ b/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; diff --git a/programs/media/ac97 mp3/trunk/mp3dec/math_private.h b/programs/media/ac97 mp3/trunk/mp3dec/math_private.h new file mode 100644 index 0000000000..81c3597060 --- /dev/null +++ b/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_ */ diff --git a/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.c b/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.c new file mode 100644 index 0000000000..80205cdb69 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.c @@ -0,0 +1,513 @@ +#include "mp3dec.h" +#include +#include + +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; + + /*///////////////////////////////// + //•W€VBR‘Ξ‰ž + if ( p[0] == mpeg[0] && p[1] == mpeg[1] ) { + info->skipSize = (int)(p - mpeg); + } else { + info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000; + switch (h->layer) { + case 1://layer1 + m_frame_size = (12 * info->bitRate / fr_tbl[h->version-1][h->fr_index]) * 4;//one slot is 4 bytes long + if (h->padding) m_frame_size += 4; + break; + case 2://layer2 + m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index]; + if (h->padding) m_frame_size ++; + break; + case 3://layer3 + m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index]; + if (h->version != 1) //MPEG-2, MPEG-2.5 + m_frame_size /= 2; + if (h->padding) m_frame_size; + break; + } + info->skipSize = (int)(m_frame_size); + } + info->bitRate = 0; + /////////////////////////////////*/ + + vbr = 1; + minBitRate = 0xffffffff; + maxBitRate = 0; + for (i = 1; i < 15; i ++) { + j = br_tbl[h->version-1][h->layer-1][i] * 1000; + if (j < minBitRate) minBitRate = j; + if (j > maxBitRate) maxBitRate = j; + } + } + else if (memcmp(p, "VBRI", 4) == 0) {//VBRI + p += 10; + info->dataSize = extractInt4(p); + p += 4; + info->frames = extractInt4(p); + p += 4; + vbr = 1; + minBitRate = 0xffffffff; + maxBitRate = 0; + for (i = 1; i < 15; i ++) { + j = br_tbl[h->version-1][h->layer-1][i] * 1000; + if (j < minBitRate) minBitRate = j; + if (j > maxBitRate) maxBitRate = j; + } + } + else {//not VBR + vbr = 0; + info->frames = 0; + //info->skipSize = 0; + info->dataSize = 0; + //info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000; + } + +// info->frequency = fr_tbl[h->version-1][h->fr_index]; +// info->msPerFrame = ms_p_f_table[h->layer-1][h->fr_index]; +// if (h->version == 3) info->msPerFrame *= 2; + switch (h->layer) { + case 1://layer1 + info->outputSize = 384 >> m_option.reduction; + //if (info->bitRate) { + if (!vbr) { + info->skipSize = 0; + info->minInputSize = (12 * info->bitRate / info->frequency) * 4;//one slot is 4 bytes long + info->maxInputSize = info->minInputSize + 4; + } + else { + info->skipSize = (12 * info->bitRate / info->frequency + h->padding) * 4; + info->minInputSize = (12 * minBitRate / info->frequency) * 4; + info->maxInputSize = (12 * maxBitRate / info->frequency) * 4 + 4; + } + break; + case 2://layer2 + info->outputSize = 1152 >> m_option.reduction; + //if (info->bitRate) { + if (!vbr) { + info->skipSize = 0; + info->minInputSize = 144 * info->bitRate / info->frequency; + info->maxInputSize = info->minInputSize + 1; + } + else { + info->skipSize = 144 * info->bitRate / info->frequency + h->padding; + info->minInputSize = 144 * minBitRate / info->frequency; + info->maxInputSize = 144 * maxBitRate / info->frequency + 1; + } + break; + case 3://layer3 + i = (h->version == 1) ? 1 : 2; + //info->outputSize = 1152 >> m_option.reduction; + info->outputSize = (1152 >> m_option.reduction) / i; + //if (info->bitRate) { + if (!vbr) { + info->skipSize = 0; + info->minInputSize = 144 * info->bitRate / info->frequency / i; + info->maxInputSize = info->minInputSize + 1; + } + else { + info->skipSize = 144 * info->bitRate / info->frequency / i + h->padding; + info->minInputSize = 144 * minBitRate / info->frequency / i; + info->maxInputSize = 144 * maxBitRate / info->frequency / i + 1; + } + break; + + /* + if (h->version != 1) { + //MPEG-2, MPEG-2.5 + info->outputSize /= 2; + info->minInputSize /= 2; + info->maxInputSize /= 2; + } + info->maxInputSize ++; + break; */ + + } + + if ((h->mode == 3) || (m_option.convert & 3)) + info->channels = 1; + else + info->channels = 2; + if (m_option.convert & 8) { + //not available + info->bitsPerSample = 8; + info->outputSize *= info->channels; + } + else { + info->bitsPerSample = 16; + info->outputSize *= info->channels * 2; + } + if ( decFlag == 1 ) { + m_frequency = info->frequency; + m_pcm_size = info->outputSize; + } + info->frequency >>= m_option.reduction; + if (vbr) info->bitRate = 0; + + return 1; +} + +void sbt_init(); + +int mp3DecodeStart(byte* mpeg, int size) +{ + MPEG_DECODE_INFO info; + MPEG_HEADER* h = &info.header; + + if (!mp3GetDecodeInfo(mpeg, size, &info, 1)) { + return 0; + } + sbt_init(); + switch (h->layer) { + case 1: + L1decode_start(h); + m_frame_proc = L1decode_frame; + break; + case 2: + L2decode_start(h); + m_frame_proc = L2decode_frame; + break; + case 3: + L3decode_start(h); + m_frame_proc = L3decode_frame; + break; + } + return 1; +} + +int mp3DecodeFrame(MPEG_DECODE_PARAM* param) +{ + MPEG_HEADER* h = ¶m->header; + + if (param->inputSize <= 4) { + m_last_error = MP3_ERROR_OUT_OF_BUFFER; + return 0; + } + if (!mp3GetHeader(param->inputBuf, h)) { + return 0; + } + + param->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000; + switch (h->layer) { + case 1://layer1 + m_frame_size = (12 * param->bitRate / m_frequency + h->padding) * 4; + break; + case 2://layer2 + m_frame_size = 144 * param->bitRate / m_frequency + h->padding; + break; + case 3://layer3 + if (h->version == 1) m_frame_size = 144 * param->bitRate / m_frequency + h->padding; + else m_frame_size = (144 * param->bitRate / m_frequency) / 2 + h->padding; + break; + } + if (param->inputSize < m_frame_size) { + m_last_error = MP3_ERROR_OUT_OF_BUFFER; + return 0; + } + + m_frame_proc(h, param->inputBuf, param->outputBuf); + param->inputSize = m_frame_size; + param->outputSize = m_pcm_size; + return 1; +} + +void null_frame_proc(MPEG_HEADER* h, byte* mpeg, byte* pcm) {} +void L3decode_reset(); + +void mp3MuteStart(MPEG_DECODE_PARAM* param) +{ + m_frame_proc = null_frame_proc; +} + +void mp3MuteEnd(MPEG_DECODE_PARAM* param) +{ + MPEG_HEADER* h = ¶m->header; + + switch (h->layer) { + case 1: + m_frame_proc = L1decode_frame; + break; + case 2: + m_frame_proc = L2decode_frame; + break; + case 3: + L3decode_reset(); + m_frame_proc = L3decode_frame; + break; + } +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.h b/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.h new file mode 100644 index 0000000000..07c1ef97e0 --- /dev/null +++ b/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; //ƒTƒ“ƒvƒŠƒ“ƒOƒŒ[ƒgiHzj + int bitRate; //ƒrƒbƒgƒŒ[ƒgibpsj + + int frames; //ƒtƒŒ[ƒ€”iVBR onlyj + int skipSize; //iVBR onlyj + int dataSize; //ƒf[ƒ^ƒTƒCƒYiVBR onlyj + + int minInputSize; //1ƒtƒŒ[ƒ€‚̍ŏ¬“ό—ΝƒTƒCƒY + int maxInputSize; //1ƒtƒŒ[ƒ€‚̍őε“ό—ΝƒTƒCƒY + int outputSize; //1ƒtƒŒ[ƒ€‚̏o—ΝƒTƒCƒY +} MPEG_DECODE_INFO; + +typedef struct { + MPEG_HEADER header; + int bitRate; //ƒrƒbƒgƒŒ[ƒgibpsj + + 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 diff --git a/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.vcproj b/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.vcproj new file mode 100644 index 0000000000..77979250aa --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/mp3dec.vcproj @@ -0,0 +1,280 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/programs/media/ac97 mp3/trunk/mp3dec/pow.asm b/programs/media/ac97 mp3/trunk/mp3dec/pow.asm new file mode 100644 index 0000000000..6a67721e86 --- /dev/null +++ b/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 , 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 ; + 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 ; + 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 ; + 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 + diff --git a/programs/media/ac97 mp3/trunk/mp3dec/sbt.c b/programs/media/ac97 mp3/trunk/mp3dec/sbt.c new file mode 100644 index 0000000000..e69ef5176b --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/sbt.c @@ -0,0 +1,394 @@ +#include + +/* "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; + } + } + + + +} + diff --git a/programs/media/ac97 mp3/trunk/mp3dec/sbtb.c b/programs/media/ac97 mp3/trunk/mp3dec/sbtb.c new file mode 100644 index 0000000000..86c0bd5b47 --- /dev/null +++ b/programs/media/ac97 mp3/trunk/mp3dec/sbtb.c @@ -0,0 +1,382 @@ +#include + +/* "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; + } + } +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/window.c b/programs/media/ac97 mp3/trunk/mp3dec/window.c new file mode 100644 index 0000000000..af7ee260cf --- /dev/null +++ b/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; + } +} diff --git a/programs/media/ac97 mp3/trunk/mp3dec/windowb.c b/programs/media/ac97 mp3/trunk/mp3dec/windowb.c new file mode 100644 index 0000000000..daf7bb5c6a --- /dev/null +++ b/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; + } +}