用于声音压缩的系统和方法

文档序号：2834644阅读：517来源：国知局
导航： X技术> 最新专利>乐器;声学设备的制造及制作,分析技术
专利名称：用于声音压缩的系统和方法
技术领域：
本发明的实施例一般地涉及音频数据压缩领域，更具体而言，涉及用于具有低处理功率的微处理器中的用于增大的音频数据压缩的方法和装置。
背景技术：
音频数据压缩的量越大，给定微控制器能够存储的声音的持续时间越长，因此，在过去的几十年间，已做出了许多尝试以改进用于具有有限处理功率和存储容量的微控制器中的音频数据压缩。但是，将失真降低到可接受级别的典型音频数据压缩方案需要的处理功率超过了许多低成本产品中可用的功率。
一种典型音频数据压缩技术，即自适应差分脉冲编码调制(ADPCM)，是从脉冲编码调制(PCM)得出的，其中以固定间隔对模拟信号(信号)幅度进行采样。ADPCM是PCM音频编码的比特率降低的变体。
利用PCM，采样率通常是信号的最高频率的若干倍。每个样本处的信号幅度被量化(即，舍入到若干个特定的预定级别中最近的那个)。级别由计数数目表示，因此PCM压缩方案的输出是构成数字信号的一系列二进制数字。
ADPCM压缩方案通过只对样本之间的差异(增量值)编码并且动态地调整编码比例以适应样本差异的幅值的变化，从而产生了具有比PCM更低的比特率的数字信号。ADPCM虽然实现起来并不困难，但是却引入了更高级别的噪声。典型情况下，ADPCM系统是频带压缩系统，其中对当前信号幅度的预测是基于先前的一个或多个样本的。这种预测方案的基础是对于音频数据的许多实例(例如语音信号)，邻近的样本是高度相关的。
ADPCM通过使用自适应预测和自适应量化来实现比特率降低。ADPCM采样一般是以8KHz执行的，其中3或4比特用于描述相邻样本之间的差异。典型ADPCM方案可以通过以合理的质量经由编码的4比特增量值表示8比特信号，来实现2∶1的压缩比率。
ADPCM使用依赖于信号幅度变化(变动)的可变增益。即，ADPCM是基于以下假设实现的信号将会具有小幅度的时段以及大幅度的时段；这对于语音和许多其他音频信号来说都是一般的。将增量编码为4比特值意味着不论这4比特是关于信号的高幅度部分的还是关于信号的低幅度部分的，都只有4比特被存储到存储器。利用4比特提供了十六个分辨率级别，这些级别可以被表示八个正级别和七个负级别(或者反之)，以及一个零级别。一种备选的表示方式可以是七个正级别和七个负级别以及两个零级别，其中之一可能不被使用。
当典型ADPCM方案被用于经由编码的3比特增量值对8比特信号编码时(即约2.6∶1的压缩比率)，则产生对原始信号的不可接受的失真量。3比特编码只提供八个分辨率级别，这些级别可以被表示四个正级别和三个负级别(或者反之)，以及一个零级别。同样，一种备选的表示方式可以是三个正级别和三个负级别以及两零级别，其中之一可能不被使用。虽然拥有四个分辨率级别对于许多应用都提供了可接受的质量级别，但是三个分辨率级别却不提供。这意味着3比特编码方案(2.6∶1压缩)对于许多应用都是不合需要的，从而限制了给定微控制器能够存储的声音的持续时间。
当然，在具有更大量的处理功率和存储器资源的情况下，可以采用为音频数据实现更大的压缩比率同时将失真限制到可接受级别的其他复杂的方法和系统(例如CELP)。这些系统对于许多采用具有有限处理能力的微处理器来说都是不实用的。


通过参考用于说明本发明的实施例的以下描述和附图，可以最好地理解本发明。附图中图1示出根据本发明的一个实施例用来以高分辨率增益对ADPCM增量进行编码的过程。
图2示出根据本发明的一个实施例用来实现非对称ADPCM编码方案的非对称性的过程；图2A示出根据本发明的一个实施例用来基于频率选择非对称性的过程；图3示出3比特编码系统的某些可能的非对称性；图4示出根据本发明的一个实施例用来选择ADPCM增益值的过程；图5示出根据本发明的一个实施例其中一个或多个增量值被用于确定ADPCM增益调整的拖延(holdoff)值的过程；图6示出根据本发明的一个实施例的一种方法，通过该过程，过零点被用于调整ADPCM增益参数；图7示出根据本发明的一个实施例的一个过程，通过该过程，未来信号特性被用于确定ADPCM编码；图8示出根据本发明的一个实施例的可用来检测和压缩公共基本曲线的过程；图9示出根据本发明的一个实施例的用于存储压缩后的音频数据的微控制器。
具体实施例方式
在以下描述中，阐述了许多具体细节。但是，要理解本发明的实施例可以在没有这些具体细节的情况下实现。在其他情况下，没有详细示出公知的电路、结构和技术以避免干扰对本描述的理解。
在本说明书中提到“一个实施例”或“实施例”是指联系该实施例所描述的特定的特征、结构或特性被包括在本发明的至少一个实施例中。从而，在本说明书的各处出现短语“在一个实施例中”或“在实施例中”不一定都是指同一实施例。此外，在一个或多个实施例中可以以任何适当的方式组合特定的特征、结构或特性。
此外，创造性的方面并不存在于所公开的单个实施例的所有特征中。从而，据此明确地将“具体实施方式
”之后的权利要求结合到此“具体实施方式
”中，其中每个权利要求书独立地作为本发明的一个单独的实施例。
本发明的实施例提供了采用了四个过程的改进型ADPCM编码方案，在各种实施例中，这四个过程可以被彼此分开地使用或彼此联合地使用。本发明的一个实施例包括在非对称ADPCM音频数据压缩方案的场境中使用3比特编码。
作为附录A被包括的是根据本发明的一个实施例用于对音频数据进行压缩和解压缩的示例性源代码。
非对称ADPCM根据本发明的一个实施例，非对称ADPCM被用于增大指定数目的编码比特的有效分辨率。即，对于3比特编码方案，分辨率级别可以被表示为四个正级别和三个负级别，以及一个零级别。如果可以使编码偏斜，以便大多数编码都用四个分辨率级别(即，而不是三个分辨率级别)来完成，则可以降低一般由于3比特编码所产生的失真。非对称性产生了高分辨率侧(例如正侧)和低分辨率侧(例如负侧)。通过精确地预测下一增量值的符号，可以确保编码更频繁地发生在高分辨率侧。通过跟踪信号的主导频率以及先前的增量值，可以相当精确地预测信号的特性。这允许了调整非对称性以使ADPCM系数偏斜，以便编码更可能以较高的分辨率发生。
图1示出了根据本发明的一个实施例用来以高分辨率增益对ADPCM增量进行编码的过程。图1所示的过程100开始于操作105，在该操作中使ADPCM系数偏斜，以便提供高分辨率增益编码和低分辨率增益编码。例如，对于3比特编码方案，可以使ADPCM系数偏斜以提供4个正级别、1个零级别和3个负级别。对于备选实施例，可以使系数进一步偏斜(例如5个正级别、1个零级别和2个负级别)。
在操作110处，预测紧接着的后一个ADPCM增量值(下一个增量值)的符号。可以基于各种指标以许多方式来完成预测。例如，由于输入信号曲线的导数通常是连续的，因此正的增量值之后通常跟随另一个正的增量值，而其后跟随零增量值的正增量值之后通常跟随有负增量。这些和其他这种指标可用于对典型信号的后续增量值的符号作出相当精确的预测。
在操作115处，确定是否将用高分辨率增益来对所预测的下一个增量值进行编码。如果是的话，则在操作120处用高分辨率编码来对下一个增量值进行编码。即，例如，如果下一个增量值的预测值是正的，并且ADPCM系数已经被偏斜以为正值提供高分辨率，则下一增量值被用高分辨率增益来编码。
在操作115处，如果所预测的下一个增量值将不会被用高分辨率增益来编码，则在操作116处ADPCM增益被反相。操作116根据下一增量的预测符号提供了高分辨率增益。即，例如，如果下一增量值的预测值是负的，并且ADPCM系数已经被偏斜以为正值提供高分辨率，则ADPCM系数被反相，从而被负值提供高分辨率。在ADPCM增益被反相之后，在操作120处下一增量值被用高分辨率增益来编码。
在操作121处，如果信号尚未结束，则该过程通过重复地预测下一增量而继续。在操作122处，一旦信号终止，则该过程终止。
偏斜越大，对下一增量值编码的分辨率就会越好，只要对下一增量值的预测是精确的。较小的偏斜为错误预测的下一增量提供了更大的分辨率。对于错误预测的下一增量值，还存在其他补偿。例如，正增量值后跟有负增量值再后跟有正增量值指示高频信号(接近奈奎斯特频率)，这同样是因为输入信号曲线通常是连续的。这类信号可能导致错误预测，其在正常语音中是罕见的，并且处于人耳一般对其不太敏感的音频频谱中。通过充分增大增益以覆盖信号，可以解决这种信号。
可变非对称性根据本发明的一个实施例，使ADPCM系数偏斜以便提供高分辨率增益和低分辨率增益编码，如上文中参考图1的操作105所述。根据经验，确定提供最精确的建模从而提供最精确和高效的编码的非对称性的程度，是依赖于要编码的信号的频率的。例如，高频信号(即具有相对于奈奎斯特频率的高频率)产生增量的突变。如果对于一个样本信号值增大，则很可能在下一样本它会减小。这对于用较大的非对称性获得的高频信号产生了更精确的结果。对于本发明的一个实施例，确定信号频率并且基于频率调整非对称性。
图2示出根据本发明的一个实施例用来实现非对称ADPCM编码方案的非对称性的过程。图2所示的过程200开始于操作205处，在该操作中确定与各种频率相对应的多个可能的非对称性。图3示出3比特编码系统的某些可能的非对称性。非对称性301是极端负非对称性的示例，非对称性302是中等负非对称性的示例，非对称性303和304是最小非对称性(分别是负的和正的)的示例，非对称性305是中等正非对称性的示例，非对称性306是极端正非对称性的示例。对于多个非对称性中的每一个，确定信号的频率范围内的相应的频率范围。例如，对于具有8kHz的采样频率的信号，3.5-4.0kHz的相对较高的频率范围可以对应于极端负非对称性(例如1个正分辨率级别，一个零分辨率级别以及6个负分辨率级别)。类似地，相对较低的频率(例如1-2kHz)可以对应于最小的非对称性(例如4个正分辨率级别，一个零分辨率级别以及3个负分辨率级别)。
在操作210处，预测信号的频率。可以以复杂度不同的多种方式来确定频率(例如利用主导频率和先前的增量值)。最简单的是确定频率，并且因为频率一般不会经常变化或急剧变化，因此利用所确定的频率作为预测的频率。
在操作215处，利用与包括预测频率在内的频率范围相对应的非对称性来对增量编码。
图2A示出根据本发明的一个实施例用来基于频率选择非对称性的过程。图2A所示的过程200A开始于操作205A处，在该操作中确定信号频率。对于一个实施例，可以通过对过零点计数并取平均来确定信号频率。例如，相对较小数目的过零点指示慢变动曲线(低频信号)，而相对较大数目的过零点指示高频信号。
在操作210A处，确定与指定的非对称性相对应的多个频率范围。例如，相对于信号的奈奎斯特频率的频率范围可以包括“非常低”、“低”、“中等”、“高”和“非常高”。
在操作215A处，基于所确定的频率处于哪个频率范围中来选择非对称性。例如，对于非常低的频率范围，使用极端正非对称性(例如非对称性306)，对于低频率范围，使用中等正非对称性(例如非对称性305)，对于中等频率范围，使用最小非对称性(正或负)(例如非对称性303和304)，对于高频率范围，使用中等负非对称性(例如非对称性302)，对于非常高的频率范围，使用极端负非对称性(例如非对称性301)。
计算简化可以大大简化ADPCM编码一般需要的计算，同时仍保持或提高质量。
ADPCM系数表根据本发明的一个实施例，与现有技术方案相比，实现简化的、预先计算的ADPCM系数的表可以大大减少对ADPCM增量进行编码所需的处理资源。对于一个实施例，该表包含有限数目的离散增益值。这种表消除了对复杂的数学转换(例如对数/反对数、舍入等等)的需要，而仍提供具有用更复杂的数学来逼近的特性的增益值。
根据本发明的一个实施例，增益值表可以具有有限数目的值，所有这些值都是mn形式的。例如，该表可以限于的倍数的增益值。这种限制大大减少了二进制计算，从而允许用更低的处理要求来实现系统。
根据本发明的一个实施例，在最低增益处，增益值表可以包括整数值。然后可以选择增益，而不会有由复杂计算的固有误差和舍入误差所导致的失真。这在最低增益处尤其重要，在这里即使一个数目的误差也会导致可听失真。对于一个实施例，基本数字(O、1、2、3和4)被包括在表中，并且是唯一的。这允许了对最小、变动最缓慢的信号精确地编码，而不会有由于遗漏的值而导致的重复浪费或失真，而这种重复浪费或失真是用现有技术计算的ADPCM系数的典型情况。
极限表作为补充或作为备选，可以实现极限表，其允许迅速和高效地确定对给定增量应用哪个增益值。极限表预先定义对于每个可能的增量将会应用哪个增益值(例如来自增益值表)。例如，对于一个实施例，两个连续的增益值的平均可以被确定，低于平均值的增量将会导致两个连续增益值中较低的那个被使用，而等于或高于平均值的值将会导致两个连续增益值中较高的那个被使用。
此外，通过对极限加权以帮助保持增益，可以进一步减小大信号上的量化失真。这种加权的结果是实现了单个值误差而不是一系列量化误差。例如，如果对最高增益值的极限加权以便最高增益值被选择的机率较小，则能获得较好的噪声比率。其原因是当增益迅速增大时，若干个未来的样本被用相应的减小的分辨率来编码。另一方面，如果在单个样本上接受某个误差，则可以更精确地对未来若干个未来的样本进行编码。就声音质量而言，单个样本上相对较大的误差比起多个样本上相对较小的误差来说是优选的。
图4示出根据本发明的一个实施例用来选择ADPCM增益值的过程。图4所示的过程400开始于操作405处，在该操作中创建增益值表。增益值表包括有限数目的离散增益值。如上所述，对于备选实施例，这种表可以包括被选择为降低计算复杂度的值(例如都采取mn形式的值)，或者被选择为降低小信号的失真的值(最低增益的基本数字)。
在操作41O处，创建极限表，其将每个增量值分配到增益值表的相应增益。如上所述，对于备选实施例，该表可以实现平均方案作为分配的基础，或者可以使用某个其他基础。
在操作415处，接收增量值，通过参考极限表确定相应的增益值，并且将其用于对增量编码。
这种极限表的使用允许了理想再现被扩展到中等大的信号中，并且比起一般为小系统实现的简单比较而言提供了更好的质量。此外，通过减小与实时计算相关联的任何截断误差，极限表的实现比起典型现有技术方案的更复杂的比较提供了更好的质量。
可变拖延增益控制拖延是用来在检测到大信号之后在某个时段中保持高增益的技术。这是为了防止增益比例迅速降低，这发生在在处于信号的高增益时段的同时应用小增益的情况下。这种比例降低(down-scaling)很可能导致较大的误差。典型情况下，增益控制拖延对于检测到大信号之后的指定数目的样本暂停增益调整。这种技术通常不产生最优结果，这是因为大信号的细节被用不必要粗糙的分辨率编码。
根据本发明的一个实施例，实现了可变增益控制拖延(可变拖延)方案以对不同条件改变增益拖延的量。可变拖延方案允许了信号曲线被更高效地遍历。与现有技术方案相比，可以更迅速地改变增益，以匹配叠加的信号的近期特征。对于一个实施例，确定一组拖延值(即样本数目)，其中每个拖延值对应于一个或多个信号特性或增量值。例如，如果先前的增益是正最大值，则拖延可以是五个样本，而如果先前的增益是负最大值，则拖延可以是四个样本。此外，拖延可以是不同的值，其中增益从任何值变到负最大值。可变拖延方案允许了对编码误差的精细调节和移动，这导致了更好的质量。
可变拖延提高了恒定频率的质量，或者变动相对较慢的信号的质量，但是在较高的频率下，尤其是迫近奈奎斯特频率时，低频率拖延规则可能不适当。在这种情况下，可以采用其他增益调整标准。例如，当连续接收到两个负最大值时，不仅减小增益的拖延更短，而且实际上在这些情况下增益被增大。此外，对于具有增大的幅度的高频信号，当增益被按较小的增加量增大多次时，它的轨迹更好。
图5示出根据本发明的一个实施例其中一个或多个增量值被用于确定ADPCM增益调整的拖延值的过程。图5所示的过程500开始于操作505处，在该操作中，确定一组拖延值。对于一个实施例，每个拖延值对应于一个或多个增量值。
在操作510处，估计接收到的增量值以确定一个或多个增量值对应于一个拖延值。
在操作515处，对于相应的拖延值，延迟ADPCM增益调整。
过零点如上所述，可以通过过零点的数目来确定信号典型的相对变动(即信号的主导频率)。低频信号具有较大的平坦区域，其中增量相对较小。对于这种区域，希望在一个周期内使增益比例下降，以捕捉这些点处信号的细微差别。然后，对于低频信号的具有相对较大的增量的较陡的部分，使增益比例提高。
相反，高频信号不具有这些具有小增量的大区域，因此，希望增益尽可能地保持恒定。根据本发明的一个实施例，对过零点进行计数和取平均，以确立信号的主导频率。这允许了调整ADPCM增益参数以捕捉完整的信号，而不会将分辨率浪费在信号的顶部和底部。即，迅速实现只覆盖较高频率处的信号的增益。
图6示出根据本发明的一个实施例的一个过程，通过该过程，过零点被用于调整ADPCM增益参数。图6所示的过程600开始于操作605，在该操作中，对过零点的数目进行计数和取平均以确立主导频率。
在操作610处，确定频率是低频还是高频。
如果确定频率为高频，则在操作611处保持ADPCM增益恒定。
如果确定频率为低频，则在操作612处，对于信号中具有相对较小的增量和相对较大的增量的部分迅速调整ADPCM增益。
对过零点取平均可以由积分器取代，从而降低了存储器要求。
不稳定系数典型现有技术ADPCM是以这样一种方式来设计的，在这种方式中，在选择预测值时增益保持稳定。现有技术系统对最接近的值编码，而没有被设计为以其他方式编码。根据经验确定，不稳定的系统比稳定的系统提供了更好的压缩比率。即，不稳定的增益能够更快的回转，因此响应度更高。这种高响应度提供了较高的压缩比率，但是增益可能变得太大，从而提供错误的编码。产生不稳定性是因为遵循最佳预测不仅驱动了理想的后续值，还驱动了偶发的非理想增益，以及偶发的非理想非对称性(对于根据本发明的实施例的采用非对称性ADPCM的系统)。在现有技术ADPCM中，保持增益响应度足够低以满足良好的稳定性。
根据本发明的一个实施例，实现了这样一个系统，其利用了不稳定的增益的非对称性的增大的响应度，但却也控制着不稳定性以避免过多的错误结果。对于本发明的一个实施例，允许增益对于所需要的信号部分迅速变化，但随后就通过不仅基于理想预测值还基于理想增益来选择未来的值，来限制增益。
对于一个实施例，未来信号特性指示被用于提供更精确的后续编码。这是通过估计一个或多个未来的值以确定未来信号特性并将这些特性的指标包括在当前样本的额外信息空间中，从而来实现的。这些未来信号特性可用于稳定不稳定的增益系数，从而提供对信号变化的更好的响应度。例如，如果增益由于不稳定性而变得太大，大到可能产生错误值的程度，则亚最优编码(即，而不是预测值)可以被用来支配增益。与后续值相关联的误差比由于增益不稳定性引起的误差小。即，可以选择次最佳拟合(less-than-best-fit)以便在未来获得更好的拟合。
此外，未来信号特性的使用允许了在对增益或频率的未来变化进行编码时的预见性。例如，对于当前编码使用亚最优值时的误差可以通过对若干后续编码使用更优化的增益来恢复。此外，由于对未来信号特性的估计而实现的早期增益抛弃的使用，允许了对曲线的当前错误预测进行某种程度的补偿。
图7示出根据本发明的一个实施例的一个过程，通过该过程，未来信号特性被用于确定ADPCM编码。图7所示的过程700开始于操作705处，在该操作中，多个未来样本被估计以确定未来信号特性。对于一个实施例，被估计的未来样本的数目是7。
在操作710处，确定未来信号特性是否指示由于不稳定性而引起的错误编码。
如果未来信号特性未指示由于不稳定性而引起的错误编码，则在操作711处，利用预测值对后续增量值进行编码。
如果未来信号特性指示由于不稳定性而引起的错误编码，则在操作712处，利用使信号特性稳定(即使系统返回稳定)的值来对一个或多个后续增量进行编码。
此外，误差项可以被人耳听到这些项的能力所加权，其中包括但不局限于减小紧跟大信号之后期间的误差的权重，以及减小噪声突发期间的误差的权重。
在某些也使用系数稳定性的情况下，允许值环绕(wrapping)(最大正值增大到最大负值)减化了计算并提高了质量。
模式识别在音频数据中有许多常见和重复的模式，对于人类语音来说尤其如此。这种常见模式在ADPCM增量中也很明显。通常，这些常见模式(例如信号的常见曲线)是小信号。根据本发明的一个实施例，通过识别这种常见模式并且以更高效的方式来对它们编码，来增大音频数据压缩。
对于本发明的一个实施例，以允许下一个最常见的信号更易被识别的方式来提取和压缩所识别的常见模式。
常见模式本发明的一个实施例包括识别可以被以备选方式编码以增大压缩的常见模式。存在许多这样的模式。例如，一串零值ADPCM增量是代表安静的常见事件。这是常见模式，因为语音通常是由其后跟随某段时间的安静或极低信号的信号突发所代表的。一串零的压缩一般与小阶跃相邻，小阶跃是另一个常见模式。小阶跃是其后跟随一串零(例如1000000)的小值(正的或负的)。小阶跃的压缩一般与基本曲线(常见曲线)相邻。本发明的实施例包括识别这种常见模式或基本曲线，并且预测可能的后续信号行为。许多这种基本典型都是可辨别的。作为附录A被包括进来的源代码包含由经验确定的最常见基本曲线中的64个，它们被编码为一个宏。
一旦识别了重复的零、后跟零的小阶跃或者其他常见曲线，就可以用ADPCM编码的备选方案来对其编码，以提供更大的压缩。例如，可以用游程长度编码或类似的数据压缩方案来对一串零编码。即，一旦确定所识别的模式，则在该模式的持续时间期间暂停ADPCM编码，并且用备选编码方案对构成该曲线的增量进行编码。例如，一系列连续的ADPCM零值增量被识别，并且被用典型的数据压缩方案(例如游程长度编码)编码构成模式的增量数目必须是最小阈值，以便备选编码提供增大的压缩。即，为了增大压缩，用于指示和描述模式的比特数目必须小于利用ADPCM对模式编码所需的比特数目。对于一个实施例，对于一串零和小阶跃，阈值是三个增量，对于基本曲线是5个增量。
图8示出根据本发明的一个实施例可用来确定常见模式并用备选编码方案对其进行编码的过程。图8所示的过程800开始于操作805处，在这里确定一个或多个常见模式。
在操作810处，估计多个增量值以尝试辨别常见模式。对于一个实施例，所估计的增量值的数目是5。
在操作815处，确定增量值是否构成特定常见模式。
如果增量值不构成常见模式，则在操作816处利用根据本发明的各种实施例的基于ADPCM的编码方案对增量值编码。
如果增量值确实构成常见模式，则在操作817处，利用适合于这种值并且比ADPCM编码提供更大的压缩的数据压缩方案来对增量值编码。例如，可以利用游程长度编码或类似的数据压缩技术来对增量值编码。在另一个示例中，可以利用宏表查找来对增量值进行编码。
模式后增益重置对于本发明的一个实施例，在常见模式被编码之后，增益被重置到指定的符号。例如，ADPCM的符号被特别地管理，以便在小阶跃之后，将看到具有相同符号的基本曲线。这么做是因为预期例如对于小阶跃增大，基本曲线也会增大。此外，在这种模式之后重置增益避免了由于多个零值增量而重复进行增益反相。可预测的符号允许了更有效地检测后续基本曲线。
模式指示对于本发明的一个实现3比特编码方案的实施例，每个16比特字包含五个被编码为3比特值的增量，从而使得可获得16比特字的最高有效比特。这个初始比特被用于标记所识别的模式。对于一个实施例，一个比特被用于指示模式的存在，并且一个或多个附加比特被用于在多个模式中标识该模式(例如标识与特定模式相对应的宏)。
系统图9示出根据本发明的一个实施例的用于存储压缩后的音频数据的微控制器。图9所示的微控制器900包括微处理器905，程序存储器910和数据存储器915与其相耦合。程序存储器910例如可以是ROM或EPROM，其存储音频数据压缩函数911，以及压缩后的音频数据912。本发明的实施例提供了更有效的音频数据压缩，因此，允许了持续时间更长的音轨被存储在特定大小的ROM上。数据存储器915例如可以是RAM或SRAM，其被用于与根据本发明的各种实施例的音频数据压缩相关联的计算。微处理器905还耦合到I/O设备920，以在外围设备912之间传输数据。微处理器905一般被实现在单个集成电路芯片上，但也可以结合同一芯片上的一个或多个其他元件。
一般事项已经在3比特ADPCM音频数据压缩方案的场境中描述了本发明的实施例。对于这种系统，本发明的实施例可以用于提供增大的可变压缩比率(例如约3∶1)，增大的固定压缩比率(例如约2.7∶1)，以及相等的压缩比率(例如2∶1)，但是与典型现有技术方案相比具有高得多的质量。其他实施例可以在各种其他场境中实现，包括除ADPCM外的音频和其他非音频数据压缩技术，以及使用更多或更少比特的编码。以下描述若干个示例性备选方法。
备选方法以下是本发明的某些备选实施例的列表。这个列表并不是无遗漏的。
对于本发明的一个实施例，可以对信号的实际值而不是ADPCM值进行模式编码。这么做的效率可能不那么高，这是因为在不同增益下的匹配给出了更多匹配机会。
对于本发明的一个实施例，缓慢变动信号可以被编码为拐点和相对最大值。这种编码可能会使噪声失真增大到超出可接受的极限。
对于本发明的一个实施例，对信号的二阶导数的编码是无损的，这是因为原始信号可以很容易地被重建，并且在二阶导数只变化四个数目左右时一般存在较大的跨度。对于这种实施例，可以不按有损方式来压缩二阶导数，这是因为每个单比特误差都将会被大大放大。
对于本发明的一个实施例，可以通过添加原始信号的一部分(一般是异相的)来略微减小二阶导数的幅度。
对于本发明的一个实施例，可以对原始信号进行预处理以将接近安静的部分抑制为零值。对于这种实施例，所实现的压缩较大，但是却可能损失重要信号。
对于本发明的一个实施例，可以对信号进行预处理以使其处理起来更高效(例如使平坦的部位更平)。
对于本发明的一个实施例，每一个可以被编码到两个比特中的若干个小值可以被编码到单个字中，其中某些标记比特。但是，可以看出这重复了基本曲线检测的努力。
对于本发明的一个实施例，阶跃曲线也可以被检测为一系列零增量后跟有单个阶跃。这种形式在一系列零之后不那么可能发生，并且解压缩起来效率较低。
对于本发明的一个实施例，也可以通过对属性而不是过零点进行计数来检测频率。这种属性包括但不局限于符号变化、斜率变化和进入曲线的平坦部分。
本发明的实施例包括各种操作。许多方法是以其最基本的形式被描述的，但是可以向任何方法添加操作或从中删除操作，而不会脱离本发明的基本范围。
对于本领域的技术人员将会很清楚的是，本发明的操作可以由硬件组件来执行，或者可以体现在机器可执行指令中，所述指令可以用来致使被用指令编程的通用或专用处理器或逻辑电路执行这些操作。或者，这些步骤可以由硬件和软件的组合来执行。本发明的各种实施例可以作为计算机程序产品被提供，所述计算机程序产品可以包括其上存储了指令的机器可读介质，所述指令可以用于对计算机(或其他电子设备)编程以执行根据本发明的各种备选实施例的过程。机器可读介质可以包括但不局限于软盘、光盘、CD-ROM和磁光盘、ROM、RAM、EPROM、EEPROM、磁卡或光卡、闪存或其他类型的适合于存储电子指令的媒体/机器可读介质。此外，本发明的实施例也可以作为计算机程序产品被下载，其中程序可以经由通信单元(例如调制解调器或网络连接)通过体现在载波或其他传播介质中的数据信号的方式从远程计算机被传送到请求方计算机。
虽然已经就若干个实施例描述了本发明，但是本领域的技术人员将会意识到，本发明并不局限于所描述的实施例，而是可以在在所附权利要求的精神和范围内进行修改和改变的情况下实现。因此描述应当被视为说明性的而不是限制性的。
附录/*****************************************************************************FileName:wavtosd3.c*Description :App to convert a wav file into sd3 format*Author :Jerry Wong*Date:23 January 2003*History :23Jan03-Initial revision**Copyright (c) 2003--JW Associates****************************************************************************/#include"stdio.h"#include"string.h"//strcmp#inc1ude"fstream.h"//fstream#include'"#stdlib.h"//st rtol#include"math.h"//sin#define XY(s,m)(&((s*)0)->m)#define DEFAULT_CHARS_PER_LINE 16#define PI 3.14159#define STOPBYTE 0xbf#define FIFO_LENGTH 8#define MAX_CUES 256#define MAX_LABLS 256/*Compile options */#define A34_HEADER//#define PCM_ONLY#define ALGORITHM_3#define INSERT_STOPBYTE#define SPESII#ifdef SPESII#define NO_MACROS#define FLIP_CODE#define LIMIT_ZC#define SPEECH_WRAP#endif/* SPESII*///#define NO_TRACE//#define NO_RLE/*Either NO_SPEECH_EVE NTS or NO_MACROS must beenabled,or both *///#define NO_SPEECH_EVENTS#define CONSIDER_ONLY_8_BITS#define TRUE 1#define FALSE 0#define SUCCESS 0#define FAILURE -1#ifdef NO_MACROSint nummacros=0x00;int macro[]={0xffff,};#else /* NO_MACROS */int nummacros=0xff;int macro[]={0x0007,0x0008,
0x0009,0x000a,0x0038,0x0039,0x003f,0x0040,0x0041,0x0047,0x0048,0x0049,0x004a,0x0051,0x0052,0x01c0,0x01c1,0x01c7,0x01ff,0x0207,0x0240,0x0248,0x0249,0x024a,0x0252,//0x0253,//0x0279,//0x0281,//0x0292,//0x02b9,0x0e07,//0x0e09,0x0e38,0x1007,0x1009,//0x1052,0x1053,0x1209,//0x120a,//0x1240,0x1241,0x1249,0x124a,//0x1292,//0x13c9,//0x1492,//0x1e54,0x2009,//0x2053,//0x2212,0x2241,//0x240a,0x2492,//0x2493,0x36db,//0x3924,0x491b,0x4924,0x6db6,0x7007,0x7009,//0x700a,//0x7012,// 0x7038,// 0x7040,// 0x71c0,// 0x71c1,0x71c7,// 0x7e38,0x7fff,0xffff,};#endif /* NO_MACROS */typedef struct Header {int fileDataLength;
int fmtChunkSize;
int formatTag;
int channels;
int samplesPerSecond;
int avgBytesPerSecond;
int blockAlign;
int bitsPerSample;
int wavDataLength;} Header_t;cypedef struct CuePoint {int id;
int position;
int dataChunkId;
int chunkStart;
int blockStart;
int sampleOffset;} CuePoint_t;typedef struct Label {int lablChunkSize;
int cuePointId;
int text;} Label_t;typede fstruct Cue{int cueChunkSize;
int numCuePoints;
CuePoint_t cuePoint [MAX_CUES];
int numLabels;
Label_t label [MAX_CUES];}Cue-t;typedef struct State {int last;
int ch;
int gain;
int gainHoldoff;
int isPositiveGain;
int code;
int error;
int zeroCrossingCount;
int zeroCrossing;} State_t;
FILE *infile;
FILE *outfile;
FILE *testfile;
FILE *tracefile;
int i,j,k,m,n,p,r,s,t,ch,chars;
char buffer[512];
int CharsPerLine=DEFAULT_CHARS_PER_LINE;
int fifo[FIFO_LENGTH];
int fifoChars;/* valid chars in fifo */Header_t headers[1];
Cue_t cues[1];
int oldBits=16;//int oldBits=8;
int newBits=8;//int newBits=16;
State_t states[6];
int last[4];
int sampfifo[8];
int dataLength;/*int est=0x80;
int delta=0;
int gain=0x0000;
int gainHoldoff=0;
int isPositiveGain=TRUE;*/int code=0;
int total=0;
int isTrailingZero=TRUE;
int wasTrailingZero=TRUE;
int spy0=0x00;
int spy1=0x00;
int sample[10]={0,0,0,0,0,0,0,0,0,0};
int plot[10]={0,0,0,0,0,0,0,0,0,0};
int error[10]={0,0,0,0,0,0,0,0,0,0};
int codes[8];
int count=0;
int zxd
[8];
int zx0=0x13;
int zx1=0x18;
int zx2=0x2f ;
int zx3=0x78;
int inbuf[8];
int incount=0;
int bestError;
int bestCodes[8];
int ergain;
int histogram
;
int pch=0x000;
int plast;
int pdelta;
int pgain;
int pcode;
int traceMin=0;
int traceMax=0;
int dumpMin=0;
int dumpMax=0;
int isShowCodes=PALSE;
int isShowHistogram=TRUE;
int isShowCoeffs=PALSE; /* calculate gain coefficients */int isShowZxd=FALSE;
int isCalcRemainderHistogram=TRUE;
int isTrace=TRUE;
int isTracefile=TRUE;
int isPlot=TRUE;
short isEnd;int zeroCrossingCount=O;int zeroCrossing=64;int zeroCrossingLimit=92;#define COEFFNUM6#ifdef COEFFNUM2#define COEFFNUM 2double coeff0=0.000;double coeff1=0.000;double coeff2=0.000;double coeff3=0.000;double coeff4=0.400;#endif /* COEFFNUM2 */#ifdef COEFFNUM3#define COEFFNUM 3double coeff0=0.000;double coeff1=0.000;double coeff2=0.000;double coeff3=0.250;double coeff4=0.575;#endif /* COEFFNUM3 */#ifdef COEFFNUM4#define COEFFNUM 4double coeff0=0.000;double coeff1=0.000;double coeff2=0.190;double coeff3=0.400;double coeff4=0.645;#endif /* COEFFNUM4 */#ifdef COEFFNUM5#define COEFFNUM 5dcuble coeff0=0.000;double coeff1=0.167;double coeff2=0.333;double coeff3=0.500;double coeff4=0.708;#endif /* COEFFNUMS */#ifdef COEFFNUM6#define COEFFNUM 6double coeff0=0.143;double coeff1=0.286;double coeff2=0.429;double coeff3=0.571;double coeff4=0.750;#endif /* COEFFNUM6 */#ifdef SPESIIint gains2[33][2]={// coeffs=0.000,0.000,0.000,0.000,0.400{0x03,0x08},//6{0x04,0x09},//7{0x04,0x0a},//8{0x05,0x0b},//9{0x05,0x0d},//10{0x06,0x0e},//11{0x06,0x10},//12{0x07,0x12},//13{0x08,0x14},//14{0x09,0x17},//15{0x0a,0x19},//16{0x0b,0x1d},//17{0x0d,0x20},//18{0x0e,0x24},//19{0x10,0x28},//20{0x12,0x2d},//21{0x14,0x33},//22{0x17,0x39},//23{0x1a,0x40},//24{0x1d,0x48},//25{0x20,0x51},//26{0x24,0x5b},//27{0x29,0x66},//28{0x2e,0x72},//29{0x33,0x80},//30{0x39,0x90},//31{0x41,0xa1},//32{0x48,0xb5},//33{0x51,0xcb},//34{0x5b,0xe4},//35{0x66,0xff},//36{0x73,0xff},//37{0x81,0xff},//38};int limits2[33][2]={{0x02,0x06},//6{0x02,0x07},//7{0x02,0x07},//8{0x03,0x08},//9{0x03,0x09},//10{0x03,0x0a},//11{0x03,0x0b},//12{0x04,0x0d},//13{0x04,0x0e},//14{0x05,0x10},//15{0x05,0x12},//16{0x06,0x14},//17{0x07,0x17},//18{0x07,0x19},//19{0x08,0x1c},//20{0x09,0x20},//21{0x0a,0x24},//22{0x0c,0x28},//23{0x0d,0x2d},//24{0x0f,0x33},//25{0x10,0x39},//26
{0x12,0x40},//27{0x15,0x48},//28{0x17,0x50},//29{0x1a,0x5a},//30{0x1d,0x65},//31{0x21,0x71},//32{0x24,0x7f},//33{0x29,0x8e},//34{0x2e,0xa0},//35{0x33,0xb3},//36{0x3a,0xb9},//37{0x41,0xc0},//38};int gains3[33][3]={// coeffs=0.000,0.000,0.000,0.250,0.575{0x02,0x05,0x08},//6{0x02,0x05,0x09},//7{0x03,0x06,0x0a},//8{0x03,0x07,0x0b},//9{0x03,0x07,0x0d},//10{0x04,0x08,0x0e},//11{0x04,0x09,0x10},//12{0x04,0x0a,0x12},//13{0x05,0x0c,0x14},//14{0x06,0x0d,0x17},//15{0x06,0x0f,0x19},//16{0x07,0x10,0x1d},//17{0x08,0x12,0x20},//18{0x09,0x15,0x24},//19{0x0a,0x17,0x28},//20{0x0b,0x1a,0x2d},//21{0x0d,0x1d,0x33},//22{0x0e,0x21,0x39},//23{0x10,0x25,0x40},//24{0x12,0x29,0x48},//25{0x14,0x2e,0x51},//26{0x17,0x34,0x5b},//27{0x19,0x3a,0x66},//28{0x1d,0x42,0x72},//29{0x20,0x4a,0x80},//30{0x24,0x53,0x90},//31{0x28,0x5d,0xa1},//32{0x2d,0x68,0xb5},//33{0x33,0x75,0xcb},//34{0x39,0x83,0xe4},//35{0x40,0x93,0xff},//36{0x48,0xa5,0xff},//37{0x51,0xb9,0xff},//38};int limits3[33][3]={{0x01,0x04,0x07},//6{0x01,0x04,0x07},//7{0x02,0x05,0x08},//8{0x02,0x05,0x09},//9{0x02,0x05,0x0a},//10{0x02,0x06,0x0b},//11{0x02,0x07,0x0d},//12{0x02,0x07,0x0e},//13{0x03,0x09,0x10},//14
{0x03,0x0a,0x12},//15{0x03,0x0b,0x14},//16{0x04,0x0c,0x17},//17{0x04,0x0d,0x19},//18{0x05,0x0f,0x1d},//19{0x05,0x11,0x20},//20{0x06,0x13,0x24},//21{0x07,0x15,0x28},//22{0x07,0x18,0x2d},//23{0x08,0x1b,0x33},//24{0x09,0x1e,0x39},//25{0x0a,0x21,0x40},//26{0x0c,0x26,0x48},//27{0x0d,0x2a,0x50},//28{0x0f,0x30,0x5a},//29{0x10,0x35,0x65},//30{0x12,0x3c,0x72},//31{0x14,0x43,0x7f},//32{0x17,0x4b,0x8f},//33{0x1a,0x54,0xa0},//34{0x1d,0x5e,0xb4},//35{0x20,0x6a,0xc9},//36{0x24,0x77,0xd2},//37{0x29,0x85,0xdc},//38};int gains4[33][4]={// coeffs=0.000,0.000,0.190,0.400,0.645{0x02,0x03,0x05,0x08},//6{0x02,0x04,0x06,0x09},//7{0x02,0x04,0x07,0x0a},//8{0x02,0x05,0x07,0x0b},//9{0x02,0x05,0x08,0x0d},//10{0x03,0x06,0x09,0x0e},//11{0x03,0x06,0x0a,0x10},//12{0x03,0x07,0x0c,0x12},//13{0x04,0x08,0x0d,0x14},//14{0x04,0x09,0x0f,0x17},//15{0x05,0x0a,0x10,0x19},//16{0x05,0x0b,0x12,0x1d},//17{0x06,0x0d,0x15,0x20},//18{0x07,0x0e,0x17,0x24},//19{0x08,0x10,0x1a,0x28},//20{0x09,0x12,0x1d,0x2d},//21{0x0a,0x14,0x21,0x33},//22{0x0b,0x17,0x25,0x39},//23{0x0c,0x1a,0x29,0x40},//24{0x0e,0x1d,0x2e,0x48},//25{0x0f,0x20,0x34,0x51},//26{0x11,0x24,0x3a,0x5b},//27{0x13,0x29,0x42,0x66},//28{0x16,0x2e,0x4a,0x72},//29{0x18,0x33,0x53,0x80},//30{0x1b,0x39,0x5d,0x90},//31{0x1f,0x41,0x68,0xa1},//32{0x22,0x48,0x75,0xb5},//33{0x27,0x51,0x83,0xcb},//34{0x2b,0x5b,0x93,0xe4},//35{0x31,0x66,0xa5,0xff},//36{0x37,0x73,0xb9,0xff},//37{0x3d,0x81,0xd0,0xff},//38};int limits4[33][4]={{0x01,0x03,0x04,0x07},//6{0x01,0x03,0x05,0x08},//7{0x01,0x03,0x06,0x09},//8{0x01,0x04,0x06,0x09},//9{0x01,0x04,0x07,0x0b},//10{0x02,0x05,0x08,0x0c},//11{0x02,0x05,0x08,0x0d},//12{0x02,0x05,0x0a,0x0f},//13{0x02,0x06,0x0b,0x11},//14{0x02,0x07,0x0c,0x13},//15{0x03,0x08,0x0d,0x15},//16{0x03,0x08,0x0f,0x18},//17{0x03,0x0a,0x11,0x1b},//18{0x04,0x0b,0x13,0x1e},//19{0x04,0x0c,0x15,0x21},//20{0x05,0x0e,0x18,0x25},//21{0x05,0x0f,0x1b,0x2a},//22{0x06,0x11,0x1e,0x2f},//23{0x06,0x13,0x22,0x35},//24{0x07,0x16,0x26,0x3b},//25{0x08,0x18,0x2a,0x43},//26{0x09,0x1b,0x2f,0x4b},//27{0x0a,0x1e,0x36,0x54},//28{0x0b,0x22,0x3c,0x5e},//29{0x0c,0x26,0x43,0x6a},//30{0x0e,0x2a,0x4b,0x77},//31{0x10,0x30,0x55,0x85},//32{0x11,0x35,0x5f,0x95},//33{0x14,0x3c,0x6a,0xa7},//34{0x16,0x43,0x77,0xbc},//35{0x19,0x4c,0x86,0xd2},//36{0x1c,0x55,0x96,0xdc},//37{0x1f,0x5f,0xa9,0xe8},//38};int gains5[33][5]={// coeffs=0.000,0.167,0.333,0.500,0.708{0x01,0x03,0x04,0x06,0x08},//6{0x01,0x03,0x04,0x06,0x09},//7{0x02,0x03,0x05,0x07,0x0a},//8{0x02,0x04,0x06,0x08,0x0b},//9{0x02,0x04,0x06,0x09,0x0d},//10{0x02,0x05,0x07,0x0a,0x0e},//11{0x03,0x05,0x08,0x0b,0x10},//12{0x03,0x06,0x09,0x0d,0x12},//13{0x03,0x07,0x0a,0x0e,0x14},//14{0x04,0x08,0x0b,0x10,0x17},//15{0x04,0x08,0x0d,0x12,0x19},//16{0x05,0x09,0x0e,0x14,0x1d},//17{0x05,0x0b,0x10,0x17,0x20},//18{0x06,0x0c,0x12,0x19,0x24},//19{0x07,0x0d,0x14,0x1d,0x28},//20{0x08,0x0f,0x17,0x20,0x2d},//21{0x08,0x11,0x19,0x24,0x33},//22{0x0a,0x13,0x1d,0x28,0x39},//23{0x0b,0x15,0x20,0x2d,0x40},//24{0x0c,0x18,0x24,0x33,0x48},//25{0x0d,0x1b,0x28,0x39,0x51},//26
{0x0f,0x1e,0x2d,0x40,0x5b},//27{0x11,0x22,0x33,0x48,0x66},//28{0x13,0x26,0x39,0x51,0x72},//29{0x15,0x2b,0x40,0x5b,0x80},//30{0x18,0x30,0x48,0x66,0x90},//31{0x1b,0x36,0x51,0x72,0xa1},//32{0x1e,0x3c,0x5b,0x80,0xb5},//33{0x22,0x44,0x66,0x90,0xcb},//34{0x25,0x4c,0x72,0xa1,0xe4},//35{0x20,0x55,0x80,0xb5,0xff},//36{0x30,0x60,0x90,0xcb,0xff},//37{0x36,0x6b,0xa1,0xe4,0xff},//38};int limits5[33][5]={{0x01,0x02,0x04,0x05,0x07},//6{0x01,0x02,0x04,0x05,0x08},//7{0x01,0x03,0x04,0x06,0x09},//8{0x01,0x03,0x05,0x07,0x0a},//9{0x01,0x03,0x05,0x08,0x0b},//10{0x01,0x04,0x06,0x09,0x0c},//11{0x02,0x04,0x07,0x0a,0x0e},//12{0x02,0x05,0x08,0x0b,0x10},//13{0x02,0x05,0x09,0x0c,0x11},//14{0x02,0x06,0x0a,0x0e,0x14},//15{0x02,0x06,0x0b,0x10,0x16},//16{0x03,0x07,0x0c,0x11,0x19},//17{0x03,0x08,0x0e,0x14,0x1c},//18{0x03,0x09,0x0f,0x16,0x1f},//19{0x04,0x0a,0x11,0x19,0x23},//20{0x04,0x0c,0x13,0x1c,0x27},//21{0x04,0x0d,0x15,0x1f,0x2c},//22{0x05,0x0f,0x18,0x23,0x31},//23{0x06,0x10,0x1b,0x27,0x37},//24{0x06,0x12,0x1e,0x2c,0x3e},//25{0x07,0x14,0x22,0x31,0x45},//26{0x08,0x17,0x26,0x37,0x4e},//27{0x09,0x1a,0x2b,0x3e,0x57},//28{0x0a,0x1d,0x30,0x45,0x62},//29{0x0b,0x20,0x36,0x4e,0x6e},//30{0x0c,0x24,0x3c,0x57,0x7b},//31{0x0e,0x29,0x44,0x62,0x8a},//32{0x0f,0x2d,0x4c,0x6e,0x9b},//33{0x11,0x33,0x55,0x7b,0xae},//34{0x13,0x39,0x5f,0x8a,0xc3},//35{0x16,0x40,0x6b,0x9b,0xda},//36{0x18,0x48,0x78,0xae,0xe5},//37{0x1b,0x51,0x86,0xc3,0xf2},//38}；int gains6[33][6]={//coeffs=0.143.0.286,0.429,0.571,0.750{0x01,0x02,0x03,0x05,0x06,0x08},//6{0x01,0x03,0x04,0x05,0x07,0x09},//7{0x01,0x03,0x04,0x06,0x08,0x0a},//8{0x02,0x03,0x05,0x06,0x08,0x0b},//9{0x02,0x04,0x05,0x07,0x0a,0x0d},//10{0x02,0x04,0x06,0x08,0x0b,0x0e},//11{0x02,0x05,0x07,0x09,0x0c,0x10},//12{0x03,0x05,0x08,0x0a,0x0d,0x12},//13{0x03,0x06,0x09,0x0c,0x0f,0x14},//14
{0x03,0x06,0x0a,0x0d,0x11,0x17},//15{0x04,0x07,0x0b,0x0f,0x13,0x19},//16{0x04,0x08,0x0c,0x10,0x15,0x1d},//17{0x05,0x09,0x0e,0x12,0x18,0x20},//18{0x05,0x0a,0x0f,0x15,0x1b,0x24},//19{0x06,0x0c,0x11,0x17,0x1e,0x28},//20{0x06,0x0d,0x13,0x1a,0x22,0x2d},//21{0x07,0x0f,0x16,0x1d,0x26,0x33},//22{0x08,0x10,0x18,0x21,0x2b,0x39},//23{0x09,0x12,0x1b,0x25,0x30,0x40},//24{0x0a,0x15,0x1f,0x29,0x36,0x48},//25{0x0c,0x17,0x23,0x2e,0x3c,0x51},//26{0x0d,0x1a,0x27,0x34,0x44,0x5b},//27{0x0f,0x1d,0x2c,0x3a,0x4c,0x66},//28{0x10,0x21,0x31,0x41,0x56,0x72},//29{0x12,0x25,0x37,0x49,0x60,0x80},//30{0x15,0x29,0x3e,0x52,0x6c,0x90},//31{0x17,0x2e,0x45,0x5c,0x79,0xa1},//32{0x1a,0x34,0x4e,0x67,0x88,0xb5},//33{0x1d,0x3a,0x57,0x74,0x98,0xcb},//34{0x21,0x41,0x62,0x82,0xab,0xe4},//35{0x25,0x49,0x6e,0x92,0xc0,0xff},//36{0x29,0x52,0x7b,0xa4,0xd8,0xff},//37{0x2e,0x5c,0x8a,0xb8,0xf2,0xff},//38};int limits6[33][6]={{0x01,0x02,0x03,0x04,0x06,0x07},//6{0x01,0x02,0x04,0x05,0x06,0x08},//7{0x01,0x02,0x04,0x05,0x07,0x09},//8{0x01,0x03,0x04,0x06,0x07,0x0a},//9{0x01,0x03,0x05,0x06,0x09,0x0c},//10{0x01,0x03,0x05,0x07,0x0a,0x0d},//11{0x01,0x04,0x06,0x08,0x0b,0x0e},//12{0x02,0x04,0x07,0x09,0x0c,0x10},//13{0x02,0x05,0x08,0x0b,0x0e,0x12},//14{0x02,0x05,0x08,0x0c,0x0f,0x14},//15{0x02,0x06,0x09,0x0d,0x11,0x16},//16{0x02,0x06,0x0a,0x0e,0x13,0x19},//17{0x03,0x07,0x0c,0x10,0x15,0x1c},//18{0x03,0x08,0x0d,0x12,0x18,0x20},//19{0x03,0x09,0x0f,0x14,0x1b,0x23},//20{0x03,0x0a,0x10,0x17,0x1e,0x28},//21{0x04,0x0b,0x13,0x1a,0x22,0x2d},//22{0x04,0x0c,0x14,0x1d,0x26,0x32},//23{0x05,0x0e,0x17,0x20,0x2b,0x38},//24{0x05,0x10,0x1a,0x24,0x30,0x3f},//25{0x06,0x12,0x1d,0x29,0x35,0x47},//26{0x07,0x14,0x21,0x2e,0x3c,0x50},//27{0x08,0x16,0x25,0x33,0x43,0x59},//28{0x08,0x19,0x29,0x39,0x4c,0x64},//29{0x09,0x1c,0x2e,0x40,0x55,0x70},//30{0x0b,0x1f,0x34,0x48,0x5f,0x7e},//31{0x0c,0x23,0x3a,0x51,0x6b,0x8d},//32{0x0d,0x27,0x41,0x5b,0x7s,0x9f},//33{0x0f,0x2c,0x49,0x66,0x86,0xb2},//34{0x11,0x31,0x52,0x72,0x97,0xc8},//35{0x13,0x37,0x5c,0x80,0xa9,0xe0},//36{0x15,0x3e,0x67,0x90,0xbe,0xec},//37{0x17,0x45,0x73,0xa1,0xd5,0xf9},//38};#else/ * SPESII * /int gains2[39][2]={// coeffs=0.000,0.000,0.000,0.000,0.400{0x02,0x04},//0{0x02,0x04},//1{0x02,0x05},//2{0x02,0x06},//3{0x03,0x06},//4{0x03,0x07},//5{0x03,0x08},//6{0x04,0x09},//7{0x04,0x0a},//8{0x05,0x0b},//9{0x05,0x0d},//10{0x06,0x0e},//11{0x06,0x10},//12{0x07,0x12},//13{0x08,0x14},//14{0x09,0x17},//15{0x0a,0x19},//16{0x0b,0x1d},//17{0x0d,0x20},//18{0x0e,0x24},//19{0x10,0x28},//20{0x12,0x2d},//21{0x14,0x33},//22{0x17,0x39},//23{0x1a,0x40},//24{0x1d,0x48},//25{0x20,0x51},//26{0x24,0x5b},//27{0x29,0x66},//28{0x2e,0x72},//29{0x33,0x80},//30{0x39,0x90},//31{0x41,0xa1},//32{0x48,0xb5},//33{0x51,0xcb},//34{0x5b,0xe4},//35{0x66,0xff},//36{0x73,0xff},//37{0x81,0xff},//38};int limits2[39][2]={{0x01,0x03},//0{0x01,0x03},//1{0x01,0x04},//2{0x01,0x04},//3{0x02,0x05},//4{0x02,0x05},//5{0x02,0x06},//6{0x02,0x07},//7{0x02,0x07},//8{0x03,0x08},//9{0x03,0x09},//10{0x03,0x0a},//11{0x03,0x0b},//12{0x04,0x0d},//13{0x04,0x0e},//14{0x05,0x10},//15
{0x05,0x12},//16{0x06,0x14},//17{0x07,0x17},//18{0x07,0x19},//19{0x08,0x1c},//20{0x09,0x20},//21{0x0a,0x24},//22{0x0c,0x28},//23{0x0d,0x2d},//24{0x0f,0x33},//25{0x10,0x39},//26{0x12,0x40},//27{0x15,0x48},//28{0x17,0x50},//29{0x1a,0x5a},//30{0x1d,0x65},//31{0x21,0x71},//32{0x24,0x7f},//33{0x29,0x8e},//34{0x2e,0xa0},//35{0x33,0xb3},//36{0x3a,0xb9},//37{0x41,0xt0},//38};int gains3[39][3]={// coeffs=0.000,0.000,0.000,0.250,0.575{0x01,0x02,0x04},//0{0x01,0x03,0x04},//1{0x01,0x03,0x05},//2{0x01,0x03,0x06},//3{0x02,0x04,0x06},//4{0x02,0x04,0x07},//5{0x02,0x05,0x08},//6{0x02,0x05,0x09},//7{0x03,0x06,0x0a},//8{0x03,0x07,0x0b},//9{0x03,0x07,0x0d},//10{0x04,0x08,0x0e},//11{0x04,0x09,0x10},//12{0x04,0x0a,0x12},//13{0x05,0x0c,0x14},//14{0x06,0x0d,0x17},//15{0x06,0x0f,0x19},//16{0x07,0x10,0x1d},//17{0x08,0x12,0x20},//18{0x09,0x15,0x24},//19{0x0a,0x17,0x28},//20{0x0b,0x1a,0x2d},//21{0x0d,0x1d,0x33},//22{0x0e,0x21,0x39},//23{0x10,0x25,0x40},//24{0x12,0x29,0x48},//25{0x14,0x2e,0x51},//26{0x17,0x34,0x5b},//27{0x19,0x3a,0x66},//28{0x1d,0x42,0x72},//29{0x20,0x4a,0x80},//30{0x24,0x53,0x90},//31{0x28,0x5d,0xa1},//32{0x2d,0x68,0xb5},//33
{0x33,0x75,0xcb},//34{0x39,0x83,0xe4},//35{0x40,0x93,0xff},//36{0x48,0xa5,0xff},//37{0x51,0xb9,0xff},//38};int limits3{39][3]={{0x01,0x02,0x03},//0{0x01,0x02,0x04},//1{0x01,0x02,0x04},//2{0x01,0x02,0x05},//3{0x01,0x03,0x05},//4{0x01,0x03,0x06},//5{0x01,0x04,0x07},//6{0x01,0x04,0x07},//7{0x02,0x05,0x08},//8{0x02,0x05,0x09},//9{0x02,0x05,0x0a},//10{0x02,0x06,0x0b},//11{0x02,0x07,0x0d},//12{0x02,0x07,0x0e},//13{0x03,0x09,0x10},//14{0x03,0x0a,0x12},//15{0x03,0x0b,0x14},//16{0x04,0x0c,0x17},//17{0x04,0x0d,0x19},//18{0x05,0x0f,0x1d},//19{0x05,0x11,0x20},//20{0x06,0x13,0x24},//21{0x07,0x15,0x28},//22{0x07,0x18,0x2d},//23{0x08,0x1b,0x33},//24{0x09,0x1e,0x39},//25{0x0a,0x21,0x40},//26{0x0c,0x26,0x48},//27{0x0d,0x2a,0x50},//28{0x0f,0x30,0x5a},//29{0x10,0x35,0x65},//30{0x12,0x3c,0x72},//31{0x14,0x43,0x7f},//32{0x17,0x4b,0x8f},//33{0x1a,0x54,0xa0},//34{0x1d,0x5e,0xb4},//35{0x20,0x6a,0xc9},//36{0x24,0x77,0xd2},//37{0x29,0x85,0xdc},//38};int gains4[39][4]={// coeffs=0.000,0.000,0.190,0.400,0.645{0x01,0x02,0x03,0x04},//0{0x01,0x02,0x03,0x04},//1{0x01,0x02,0x03,0x05},//2{0x01,0x02,0x04,0x06},//3{0x01,0x03,0x04,0x06},//4{0x01,0x03,0x05,0x07},//5{0x02,0x03,0x05,0x08},//6{0x02,0x04,0x06,0x09},//7{0x02,0x04,0x07,0x0a},//8{0x02,0x05,0x07,0x0b},//9
{0x02,0x05,0x08,0x0d},//10{0x03,0x06,0x09,0x0e},//11{0x03,0x06,0x0a,0x10},//12{0x03,0x07,0x0c,0x12},//13{0x04,0x08,0x0d,0x14},//14{0x04,0x09,0x0f,0x17},//15{0x05,0x0a,0x10,0x19},//16{0x05,0x0o,0x12,0x1d},//17{0x06,0x0d,0x15,0x20},//18{0x07,0x0e,0x17,0x24},//19{0x08,0x10,0x1a,0x28},//20{0x09,0x12,0x1d,0x2d},//21{0x0a,0x14,0x21,0x33},//22{0x0b,0x17,0x25,0x39},//23{0x0c,0x1a,0x29,0x40},//24{0x0e,0x1d,0x2e,0x48},//25{0x0f,0x20,0x34,0x51},//26{0x11,0x24,0x3a,0x5b},//27{0x13,0x29,0x42,0x66},//28{0x16,0x2e,0x4a,0x72},//29{0x18,0x33,0x53,0x80},//30{0x1b,0x39,0x5d,0x90},//31{0x1f,0x41,0x68,0xa1},//32{0x22,0x48,0x75,0xb5},//33{0x27,0x51,0x83,0xcb},//34{0x2b,0x5b,0x93,0xe4},//35{0x31,0x66,0xa5,0xff},//36{0x37,0x73,0xb9,0xff},//37{0x3d,0x81,0xd0,0xff},//38};int limits4[39][4]={{0x01,0x02,0x03,0x04},//0{0x01,0x02,0x03,0x04},//1{0x01,0x02,0x03,0x04},//2{0x01,0x02,0x03,0x05},//3{0x01,0x02,0x04,0x05},//4{0x01,0x02,0x04,0x06},//5{0x01,0x03,0x04,0x07},//6{0x01,0x03,0x05,0x08},//7{0x01,0x03,0x06,0x09},//8{0x01,0x04,0x06,0x09},//9{0x01,0x04,0x07,0x0b},//10{0x02,0x05,0x08,0x0c},//11{0x02,0x05,0x08,0x0d},//12{0x02,0x05,0x0a,0x0f},//13{0x02,0x06,0x0b,0x11},//14{0x02,0x07,0x0c,0x13},//15{0x03,0x08,0x0d,0x15},//16{0x03,0x08,0x0f,0x18},//17{0x03,0x0a,0x11,0x1b},//18{0x04,0x0b,0x13,0x1e},//19{0x04,0x0c,0x15,0x21},//20{0x05,0x0e,0x18,0x25},//21{0x05,0x0f,0x1b,0x2a},//22{0x06,0x11,0x1e,0x2f},//23{0x06,0x13,0x22,0x35},//24{0x07,0x16,0x26,0x3b},//25{0x08,0x18,0x2a,0x43},//26{0x09,0x1b,0x2f,0x4b},//27{0x0a,0x1e,0x36,0x54},//28
{0x0b,0x22,0x3c,0x5e},//29{0x0c,0x26,0x43,0x6a},//30{0x0e,0x2a,0x4b,0x77},//31{0x10,0x30,0x55,0x85},//32{0x11,0x35,0x5f,0x95},//33{0x14,0x3c,0x6a,0xa7},//34{0x16,0x43,0x77,0xbc},//35{0x19,0x4c,0x86,0xd2},//36{0x1c,0x55,0x96,0xdc},//37{0x1f,0x5f,0xa9,0xe8},//38};int gains5[39][5]={//coeffs=0.000，0.167，0.333，0.500,0.708{0x01,0x01,0x02,0x03,0x04},//0{0x01,0x01,0x02,0x03,0x04},//1{0x01,0x02,0x03,0x04,0x05},//2{0x01,0x02,0x03,0x04,0x06},//3{0x01,0x02,0x03,0x04,0x06},//4{0x01,0x02,0x04,0x05,0x07},//5{0x01,0x03,0x04,0x06,0x08},//6{0x01,0x03,0x04,0x06,0x09},//7{0x02,0x03,0x05,0x07,0x0a},//8{0x02,0x04,0x06,0x08,0x0b},//9{0x02,0x04,0x06,0x09,0x0d},//10{0x02,0x05,0x07,0x0a,0x0e},//11{0x03,0x05,0x08,0x0b,0x10},//12{0x03,0x06,0x09,0x0d,0x12},//13{0x03,0x07,0x0a,0x0e,0x14},//14{0x04,0x08,0x0b,0x10,0x17},//15{0x04,0x08,0x0d,0x12,0x19},//16{0x05,0x09,0x0e,0x14,0x1d},//17{0x05,0x0b,0x10,0x17,0x20},//18{0x06,0x0c,0x12,0x19,0x24},//19{0x07,0x0d,0x14,0x1d,0x28},//20{0x08,0x0f,0x17,0x20,0x2d},//21{0x08,0x11,0x19,0x24,0x33},//22{0x0a,0x13,0x1d,0x28,0x39},//23{0x0b,0x15,0x20,0x2d,0x40},//24{0x0c,0x18,0x24,0x33,0x48},//25{0x0d,0x1b,0x28,0x39,0x51},//26{0x0f,0x1e,0x2d,0x40,0x5b},//27{0x11,0x22,0x33,0x48,0x66},//28{0x13,0x26,0x39,0x51,0x72},//29{0x15,0x2b,0x40,0x5b,0x80},//30{0x18,0x30,0x48,0x66,0x90},//31{0x1b,0x36,0x51,0x72,0xa1},//32{0x1e,0x3c,0x5b,0x80,0xb5},//33{0x22,0x44,0x66,0x90,0xcb},//34{0x26,0x4c,0x72,0xa1,0xa4},//35{0x2b,0x55,0x80,0xb5,0xff},//36{0x30,0x60,0x90,0xcb,0xff},//37{0x36,0x6b,0xa1,0xe4,0xff},//38};int limits5[39][5]={{0x01,0x01,0x02,0x03,0x04},//0{0x01,0x01,0x02,0x03,0x04},//1{0x01,0x02,0x03,0x04,0x05},//2{0x01,0x02,0x03,0x04,0x05},//3{0x01,0x02,0x03,0x04,0x05},//4
{0x01,0x02,0x03,0x05,0x06},//5{0x01,0x02,0x04,0x05,0x07},//6{0x01,0x02,0x04,0x05,0x08},//7{0x01,0x03,0x04,0x06,0x09},//8{0x01,0x03,0x05,0x07,0x0a},//9{0x01,0x03,0x05,0x08,0x0b},//10{0x01,0x04,0x06,0x09,0x0c},//11{0x02,0x04,0x07,0x0a,0x0e},//12{0x02,0x05,0x08,0x0b,0x10},//13{0x02,0x05,0x09,0x0c,0x11},//14{0x02,0x06,0x0a,0x0e,0x14},//15{0x02,0x06,0x0b,0x10,0x16},//16{0x03,0x07,0x0c,0x11,0x19},//17{0x03,0x08,0x0e,0x14,0x1c},//18{0x03,0x09,0x0f,0x16,0x1f},//19{0x04,0x0a,0x11,0x19,0x23},//20{0x04,0x0c,0x13,0x1c,0x27},//21{0x04,0x0d,0x15,0x1f,0x2c},//22{0x05,0x0f,0x18,0x23,0x31},//23{0x06,0x10,0x1b,0x27,0x37},//24{0x06,0x12,0x1e,0x2c,0x3e},//25{0x07,0x14,0x22,0x31,0x45},//26{0x08,0x17,0x26,0x37,0x4e},//27{0x09,0x1a,0x2b,0x3e,0x57},//28{0x0a,0x1d,0x30,0x45,0x62},//29{0x0b,0x20,0x36,0x4e,0x6e},//30{0x0c,0x24,0x3c,0x57,0x7b},//31{0x0e,0x29,0x44,0x62,0x8a},//32{0x0f,0x2d,0x4c,0x6e,0x9b},//33{0x11,0x33,0x55,0x7b,0xae},//34{0x13,0x39,0x5f,0x8a,0xc3},//35{0x16,0x40,0x6b,0x9b,0xda},//36{0x18,0x48,0x78,0xae,0xe5},//37{0x1b,0x51,0x86,0xc3,0xf2},//38};int gains6[39][6]={// coeffs=0.143,0.286,0.429,0.571,0.750{0x01,0x01,0x02,0x02,0x03,0x04},//0{0x01,0x01,0x02,0x03,0x03,0x04},//1{0x01,0x01,0x02,0x03,0x04,0x05},//2{0x01,0x02,0x02,0x03,0x04,0x06},//3{0x01,0x02,0x03,0x04,0x05,0x06},//4{0x01,0x02,0x03,0x04,0x05,0x07},//5{0x01,0x02,0x03,0x05,0x06,0x08},//6{0x01,0x03,0x04,0x05,0x07,0x09},//7{0x01,0x03,0x04,0x06,0x08,0x0a},//8{0x02,0x03,0x05,0x06,0x08,0x0b},//9{0x02,0x04,0x05,0x07,0x0a,0x0d},//10{0x02,0x04,0x06,0x08,0x0b,0x0e},//11{0x02,0x05,0x07,0x09,0x0c,0x10},//12{0x03,0x05,0x08,0x0a,0x0d,0x12},//13{0x03,0x06,0x09,0x0c,0x0f,0x14},//14{0x03,0x06,0x0a,0x0d,0x11,0x17},//15{0x04,0x07,0x0b,0x0f,0x13,0x19},//16{0x04,0x08,0x0c,0x10,0x15,0x1d},//17{0x05,0x09,0x0e,0x12,0x18,0x20},//18{0x05,0x0a,0x0f,0x15,0x1b,0x24},//19{0x06,0x0c,0x11,0x17,0x1e,0x28},//20{0x06,0x0d,0x13,0x1a,0x22,0x2d},//21{0x07,0x0f,0x16,0x1d,0x26,0x33},//22
{0x08,0x10,0x18,0x21,0x2b,0x39},//23{0x09,0x12,0x1b,0x25,0x30,0x40},//24{0x0a,0x15,0x1f,0x29,0x36,0x48},//25{0x0c,0x17,0x23,0x2e,0x3c,0x51},//26{0x0d,0x1a,0x27,0x34,0x44,0x5b},//27{0x0f,0x1d,0x2c,0x3a,0x4c,0x66},//28{0x10,0x21,0x31,0x41,0x56,0x72},//29{0x12,0x25,0x37,0x49,0x60,0x80},//30{0x15,0x29,0x3e,0x52,0x6c,0x90},//31{0x17,0x2e,0x45,0x5c,0x79,0xa1},//32{0x1a,0x34,0x4e,0x67,0x88,0xb5},//33{0x1d,0x3a,0x57,0x74,0x98,0xcb},//34{0x21,0x41,0x62,0x82,0xab,0xe4},//35{0x25,0x49,0x6e,0x92,0xc0,0xff},//36{0x29,0x52,0x7b,0xa4,0xd8,0xff},//37{0x2e,0x5c,0x8a,0xb8,0xf2,0xff},//38};int limits6[39][6]={{0x01,0x01,0x02,0x02,0x03,0x04},//0{0x01,0x01,0x02,0x03,0x03,0x04},//1{0x01,0x01,0x02,0x03,0x04,0x05},//2{0x01,0x02,0x02,0x03,0x04,0x05},//3{0x01,0x02,0x03,0x04,0x05,0x06},//4{0x01,0x02,0x03,0x04,0x05,0x06},//5{0x01,0x02,0x03,0x04,0x06,0x07},//6{0x01,0x02,0x04,0x05,0x06,0x08},//7{0x01,0x02,0x04,0x05,0x07,0x09},//8{0x01,0x03,0x04,0x06,0x07,0x0a},//9{0x01,0x03,0x05,0x06,0x09,0x0c},//10{0x01,0x03,0x05,0x07,0x0a,0x0d},//11{0x01,0x04,0x06,0x08,0x0b,0x0e},//12{0x02,0x04,0x07,0x09,0x0c,0x10},//13{0x02,0x05,0x08,0x0b,0x0e,0x12},//14{0x02,0x05,0x08,0x0c,0x0f,0x14},//15{0x02,0x06,0x09,0x0d,0x11,0x16},//16{0x02,0x06,0x0a,0x0e,0x13,0x19},//17{0x03,0x07,0x0c,0x10,0x15,0x1c},//18{0x03,0x08,0x0d,0x12,0x18,0x20},//19{0x03,0x09,0x0f,0x14,0x1b,0x23},//20{0x03,0x0a,0x10,0x17,0x1e,0x28},//21{0x04,0x0b,0x13,0x1a,0x22,0x2d},//22{0x04,0x0c,0x14,0x1d,0x26,0x32},//23{0x05,0x0e,0x17,0x20,0x2b,0x38},//24{0x05,0x10,0x1a,0x24,0x30,0x3f},//25{0x06,0x12,0x1d,0x29,0x35,0x47},//26{0x07,0x14,0x21,0x2e,0x3c,0x50},//27{0x08,0x16,0x25,0x33,0x43,0x59},//28{0x08,0x19,0x29,0x39,0x4c,0x64},//29{0x09,0x1c,0x2e,0x40,0x55,0x70},//30{0x0b,0x1f,0x34,0x48,0x5f,0x7e},//31{0x0c,0x23,0x3a,0x51,0x6b,0x8d},//32{0x0d,0x27,0x41,0x5b,0x78,0x9f},//33{0x0f,0x2c,0x49,0x66,0x86,0xb2},//34{0x11,0x31,0x52,0x72,0x97,0xc8},//35{0x13,0x37,0x5c,0x80,0xa9,0xa0},//36{0x15,0x3e,0x67,0x90,0xbe,0xec},//37{0x17,0x45,0x73,0xa1,0xd5,0xf9},//38};#endif/* SPESII */int code1=1;int code2=2;int code3=4;int code4=1;int code5=2;int code6=4;int code7=6;int code76=3;int gainHoldoff0z=0x00;/* no holdoff if zc greater than */int gainHoldoff3z=0x00;/* no holdoff if zc greater than *///int gainHoldoff6z=0x0a;/*no holdoff if zc greater than */int gainHoldoff6z=0x00;/* no holdoff if zc greater than *///int gainHoldoff7z=0x0a;/*no holdoff if zc greater than */int gainHoldoff7z=0x00;/* no holdoff if zc greater than */int gainHoldoff0=2;/* I think these are obsolete now */int gainHoldoff3=3;int gainHoldoff6=5;int gainHoldoff7=5;int gain0=-1;int gain1=0;int gain2=0;int gain3=0;/* 1 is a must for very high frequency */int gain4=0;int gain5=0;int gain6=0;int gain7=1;/* 1 has better HF noise,2 has better attack */int dGain0z=0x00;/* allow additional reduction if zc less than */int dGainlz=0x00;/* allow additional reduction if zc less than *///int dGain2z=0x10;/* allow additional increase if zc less than */int dGain2z=0x00;/* allow additional increase if zc less than *///int dGain3z=0x0e;/* allow additional increase if zc less than */int dGain3z=0x0a;/* allow additional increase if zc le ss than */int dGain4z=0x00;/* allow additional reduction if zc less than */int dGain5z=0x00;/* allow additional reduction if zc less than *///int dGain6z=0x14;/* allow additional increase if zc less than */int dGain6z=0x00;/* allow addi tional increase if zc less than */int dGain7z=0x1c;/* allow additional increase if zc greater than */#ifdef SPESIIint gainMax=31;#else /* SPESII */int gainMax=38;#endif/* SPESII */int signalPower=0;int signalPowerMid=0;int signalPowerHi=0;int signalPowerOld=0;int aignalPowerOldMid=0;int signalPowerOldHi=0;int noise=0;int noiseMid=0;int noisePeak=0;int noiseMark=20*0x100;double dub0,dub1;/* Prototype */int minGains(State_t *state);void initHeader(Header_t *header){header->fileDataLength=0x00000000;
header->fmtChunkSize=0x0010;
header->formatTag=0x0001;
header->channels=0x0001;
header->samplesPerSecond=0x00005622;
header->avgBytesPerSecond=0x00005622;
header->blockAlign=0x0001;
header->bitsPerSample=0x0008;
header->wavDataLength=0x00000000;}void initIoVars(void){int i;
isEnd=FALSE;//falsefor(i=0;i<FIFO_LENGTH;i++){fifo[i]=0;
}fifoChars=0;
initHeader(&headers
);}int fillFifo(FILE *infile,int n).{int i;
fifoChars=fifoChars - n;
if(fifoChars<0) {fifoChars=0;
}while(n>0){for(i=0;i<FIFO_LENGTH-1;i++){fifo[i]=fifo[i+1];
}isEnd=((ch=fgetc(infile))==-1);
if(lisEnd){fifo[FIFO_LENGTH-1]=ch;
fifoChars++;
}else{fifo[FIFO_LENGTH-1]=0;
}n--;
}return(SUCCESS);}int readHeader(Header_t *header,FILE *infile){int i;
fillFifo(infile,4);/*Discard RIFF*/header->fileDataLength=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard data length */fillFifo(infile,4);/* Discard WAVE */fillFifo(infile,4);/* Discard fmt */header->fmtChunkSize=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard fmt chunk size */
header->formatTag*fifo
+fifo[1]*0x100;
fillFifo(infile,2);/* Discard fmt tag*/header->channels=fifo
+fifo[1]*0x100;
fillFifo(infile,2);/* Discard channels */header->samplesPerSecond=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/*Discard samples per second*/header->avgBytesPerSecond=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard avg byts per second */header->blockAlign=fifo
+fifo[1]*0x100;
fillFifo(infile,2);/* Discard block align */.
header->bitsPerSample=fifo
+fifo[1]*0x100;
oldBits=header->bitsPerSample;
fillFifo(infile,2);/* Discard bits per sample */header->wavDataLength=0;
for(i=0;i<50;i++){/* Search up to 50 char s for"data" */if((fifo
==′d′)&
(fifo[1]==′a′)&
(fifo[2]==′t′)&
(fifo[3]==′a′)){fillFifo(infile,4);/* Discard"data" */header->wavDataLength =fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard wav data length *///printf("data length found 0x%08x\r\n",//header->wavDataLength);
break;
}fillFifo(infile,1);/*Discard a char */}return(SUCCESS);};int writeWord(int n,FILE *outfile){fputc(n & 0xff,outfile);
n=n/0x100;
fputc(n & 0xff,outfile);
n=n/0x100;
return(SUCCESS);};int writeLong(int n,FILE *outfile){
fputc(n & 0xff,outfile);
n=n/0x100;
fputc(n & 0xff,outfile);
n=n/0x100;
fputc(n & 0xff,outfile);
n=n/0x100;
fputc(n & 0xff,outfile);
n=n/0x100;
return(SUCCESS);};int writeHeader(Header_t *header,FILE *outfile){fputs("RIFF",outfile);
writeLong(header->wavDataLength+0x32,outfile);
fputs("WAVE",outfile);
fputs("fmt",outfile);
writeLong(0x12,outfile);
writeWord(header->formatTag,outfile);
writeWord(header->channels,outfile);
writeLong(header->samplesPerSecond,outfile);
writeLong(header->avgBytesPerSecond,outfile);
writeWord(header->blockAlign,outfile);
writeWord(header->bitsPerSample,outfile);
writeWord(0,outfile);
fputs("fact",outfile);
writeLong(4,outfile);
writeLong(((long)header->wavDataLength)*8/header->bitsPerSample,outfile);
fputs("data",outfile);
writeLong(header->wavDataLength,outfile);
return(SUCCESS);};int convertHeader(Header_t *header){header->avgBytesPerSecond=header->samplesPerSecond * newBits/8;
header->blockAlign=newBits/8;
header->bitsPerSample=newBits;
header->wavDataLength=header->wavDataLength * newBits/oldBits;
return(SUCCESS);};int sample8To12(int n){return(n * 0x10);}int sample12To8(int n){return(n/0x10);}int sample12To16(int n){return((n * 0x800) * 0x10);}int sample16To12(int n){return(((n/0x10) * 0x800) & 0xfff);}int sample8To16(int n){return((n * 0x80) * 0x100);}int sample16To8(int n){
return(((n/0x100) * 0x80) & 0xff);}int readSample(FILE * infile){if(oldBits==8){n=fifo
;// n=(n * 0x80) * 0x100;
n=sample8To16(n);
fillFifo(infile,1);/*Discard sample word */}else if(oldBits==16){n=fifo
+fifo[1] * 0x100;
fillFifo(infile,2);/* Discard sample word */}else{n=0;
}return(n);};int writeSample(int n,FILE *outfile){if(newBits==8){// fputc(((n/0x100) * 0x80) & 0xff,outfile);
fputc(sample16To8(n),outfile);
}else if(newBits==16){writeWord(n,outfile);
}else{}return(SUCCESS);}int skipData(Header_t *header,FILE * infile){int i;
for(i=0;i<((long)header->wavDataLength)*8/headers
.bitsPerSample;i++){readSample(infile);
if(fifoChars==0){return(FAILURE);
}}return(SUCCESS);}void initCue(Cue_t * cue){cue->cueChunkSize=0x0000;
cue->numCuePoints=0x0000;}int readCue(Cue_t*cue,FILE * infile){int i,j;
for(i=0;i<50;i++){/ * Se arch up to 50 chars for"cue" */if((fifo
==′c′)&
(fifo[1]==′u′)&
(fifo[2]==′e′)&
(fifo[3]==′ ′)) {fillFifo(infile,4);/* Discard"cue" */break;
}fillFifo(infile,1);/* Discard a char */}if(i>=50){return(FAILURE );/* "cue" not found */}cue->cueChunkSize =fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;fillFifo(infile,4);/* Discard cue chunk size */cue->numCuePoints=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;fillFifo(infile,4);/*Discard num cue points */for(i=0;i<cue->numCuePoints;i++){/* Read in the cue points */cue->cuePoint[i].id =fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard id */cue->cuePoint[i].position=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard position */cue->cuePoint[i].dataChunkId =fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard data chunk id */cue->cuePoint[i].chunkStart =fifo
*fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard chunk start */cue->cuePoint[i].blockStart =fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/*Discard block start */cue->cuePoint[i].sampleOffset =fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard sample offset */}cue->numLabels = 0;
for(j=0;j<256;j++){/*Read in the labels */for(i=0;i<1000;i++){/* Search up to 1000 chars for "labl" */if((fifo
==′1′)&
(fifo[1]==′a′)&
(fifo[2]==′b′)&
(fifo[3]==′l′)){fillFifo(infile,4);/* Discard "labl" */break;
}fillFifo(infile,1);/* Discard a char */if(fifoChars==0){i=1000;
break;
}}if(i>=1000){return(SUCCESS);/*"labl"not found */}cue->label[j].lablChunkSize=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo[infile,4);/* Discard label chunk size */cue->label[j].cuePointId=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard cue point id */cue->label[j].text=fifo
+fifo[1]*0x100+fifo[2]*0x10000+fifo[3]*0x1000000;
fillFifo(infile,4);/* Discard text */cue->numLabels=j+1;
}return(SUCCESS);};int labelToEvent(int n){int r,retval;
if((n&oxfffoffff)==0x00305f65){retval=(n&0xf0000)/0x10000;
if(retval<=9){return(retval);
}else{return(FAILURE);
}}else if((n&0xfofoffff)==0x3030sf6s){retval=(n&0xf0000)/0x10000;
r=(n&0xf000000)/0x1000000;
if((retval<=9)&&(r<=9)){return(retval*10+r);
}else{return(FAILURE);
}}else{return(FAILURE);
}};int dumpCue(Cue_t * cue){printf("cue chunk size found 0x%08x \r\n",cue->cueChunkSize);
printf("num cue points found 0x%08x \r\n",cue->numCuePoints);
printf("idpositiondata id databl ockoffset\r\n"):
for(i=0;i<cue->numCuePoints;i++){printf("0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x \r\n".
cue->cuePoint[i].id,cue->cuePoint[i].position,cue->cuePoint[i].dataChunkId,cue->cuePoint[i].chunkSta rt,cue->cuePoint[i].blockStart,cue->cuePoint[i].sampleOffset);
}printf("num labels found 0x%08x \r\n*,cue->numLabels);
printf(*size point textevent \r\n");
for(i=0;i<cue->numLabels;i++){printf("0x%08x 0x%08x 0x%08x %d\r\n",cue->label[i].lablChunkSize,cue->label[i].cuePointId,cue->label[i].text,labelToEvent(cue->label[i].text))；}return(5UCCESS);};void showCoeffs(void){if(isShowCoeffs==TRUE){sprintf(buffer,"\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}sprintf(buffer,"int gains%d[39][%d]={ \r\n",COEFFNUM,COEFFNUM);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}sprintf(buffer,"//coeffe=%02.3f,%02.3f,%02.3f,%02.3f,%02.3f \r\n",coeff0,coeff1,coeff2,coeff3,coeff4);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}for(j=0;j<39;j++){double f[6];
f[5]=exp((float)j*log(2.0)/6.0)*4.0;
f
=f[5]*(coeff0);
f[1]=f[5]*(coeff1);
f[2]=f[5]*(coeff2);
f[3]=f[5]*(coeff3);
f[4]=f[5]*(coeff4);
f[5]=(double)((int)(f[5]+0.5));
f[4]=(double)((int)(f[4]+0.5));
f[3]=(double)((int)(f[3]+0.5));
f[2]=(double)((int)(f[2]+0.5));
f[1]=(double)((int)(f[1]+0.5));
f
=(double)((int)(f
+0.5));
if(f[5]>255.0){
f[5]=255.0;
}sprintf(buffer," {");
if(isTracefile==TRUE) {fputs(buffer,tracefile);
}for(i=0;i<COEFFNUM;i++){if(i!=0){sprintf(buffer,",");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"0x%02x",(int)(f[6-COEFFNUM+i]+0.55));
if(isTrscefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,*},// %d\r\n",j);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"};\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}sprintf(buffer,"\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}sprintf(buffer,"int limits%d[39][%d]={ \r\n",COEFFNUM,COEFFNUM);
if(isTracefile==TRUE){fputs(buffer,tr acefile);
}for(j=0;j<39;j++){double f[6];
f[5]=exp((float)j*log(2.0)/6.0)*4.0;
f
=f[5] * (coeff0);
f[1]=f[5] * (coeff1);
f[2]=f[5] * (coeff2);
f[3]=f[5] * (coeff3);
f[4]=f[5] * (coeff4);
f[5]=(double)((int)(f[5]+0.5));
f[4]=(double)((int)(f[4]+0.5));
f[3]=(double)((int)(f[3]+0.5));
f[2]=(double)((int)(f[2]+0.5));
f[1]=(double)((int)(f[1]+0.5));
f
=(double)((int)(f
+0.5));
if(f[5]>255.0){f[5]=255.0;
}f[5]=(f[5]+f[4])/2.0;
f[4]=(f[4]+f[3])/2.0;
f[3]=(f[3]+f[2])/2.0;
f[2]=(f[2]+f[1])/2.0;
f[1]=(f[1]+f
)/2.0;
f
=(f
)/2.0;
sprintf(buffer," {");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}for(i=0;i<COEFFNUM;i++){if(i!=0){sprintf(buffer,*,",");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"0x%02x",(int)(f(6-COEFFNUM+i]+0.55));
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"},// %d\r\n",j);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"};\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}sprintf(buffer,"\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}}void initState(State t *state){state->last=0x80;
state->ch=sample8To12(0x00);
state->gain=0x00;
state->gainHoldoff=0x00;
state->isPositiveGain=TRUE;
state->code=0x00;
state->error=0x00;
state->zeroCrossingCount=0x00;
state->reroCrossing=64;
if(state->gain<minGains(state)){state->gain=minGains(state);
}}void copyState(State_t *state0,State_t *state1){state1->last=state0->last;
state1->ch=state0->ch;
state1->gain=state0->gain;
state1->gainHoldoff=state0->gainHoldoff;
state1->ispositiVeGain=state0->ispositiveGain;
state1->code=state0->code;
state1->error=state0->error;
state1->zeroCrossingCount=state0->zeroCrossingCount;
state1->zeroCrossing=state0->zeroCrossing;}void initVars(void){last
=0x80;
last[1]=0x80;
last[2]=0x80;
last[3]=0x80;/*delta=0;
gain=0x0000;
gainHoldoff=0;
isPositiveGain=TRUE;
zeroCrossingCount=0;
zeroCrossing=64;
code=0;*/total=0;
isTrailingZero=TRUE;
initIoVars();
initState(&states
);
isEnd=0;//falsei=0;
chars=0;
count=0;}/** 0b-13 5 2 34567012* 14-18 4 345670123* 19-2f 3 4 56701234* 30-78 2 5 67012345* 79+ 1 6 70123456*/void limitZeroCrossing(State_t *state){if(state->zeroCrossing<0x0){state->zeroCrossing=0x0;
}if(state->zeroCrossing>0xff){state->zeroCrossing=0xff;
}}/** 0b-13 5 2 34567012* 14-18 4 345670123* 19-2f 3 4 56701234* 30-78 2 5 67012345* 79+ 1 6 70123456*/int signs(int i,State_t *state){if(i==0){return 0;
}if(i==7){return-1;
}if(state->zeroCrossing<=zx0){
if(i==3){return-1;
}}if(state->zeroCrossing<=zx1){if(i==4){return-1;
}}if(state->zeroCrossing<=zx2){if(i==5){return-1;
}}if(state->zeroCrossing<=zx3){if(i==6){return-1;
}}return 1;}int indices(int i.State_t *state){if(i==0){return 0;
}if(i==7){return 0;
}if(state->zeroCrossing<=zx0){if(i==3){return 4;
}}if(state->zeroCrossing<=zx1){if(i==4){return 3;
}}if(state->zeroCrossing<=zx2){if(i==5){return 2;
}}if(state->zeroCrossing<=zx3){if(i==6){return 1;
}}return i-1;}/** 0b-13 5234567012* 14-18 43 45670123* 19-2f 34 56701234* 30-78 25 67012345* 79+ 1670123456*//*These are the desired changes in gain */int dgains(int i,State_t *state){
if(state->zeroCrossing<=zx0){if(i==0){return-2;
}if(i==2){return 1;
}if(i==3){return 2;
}}else if(state->zeroCrossing<=zx1){if(i==3){return 1;
}if(i==4){return 2;
}}else if(state->zeroCrossing<=zx2){if(i==0){return-2;
}if(i==4){return 2;
}if(i==5){return 3;
}}else if(state->zeroCrossing<=zx3){if(i==0){return-2;
}if(i==5){return 5;
}if(i==6){return 1;
}}else{if(i==6){return 7;
}}if(i==0){return-1;
}return 0;}#ifdef SPESIIint minGains(State_t *state){if(stace->zeroCrossing<=zx0){return 0;
}else if(state->zeroCrossing<=zx1){return 0;
}else if(state->zeroCrossing<=zx2){return 0;
}else if(state->zeroCrossing<=zx3){return 0;
}else{return 0;
};#else /*SPESII*/int minGains(State_t *stat e){if(state->zeroCrossing<=zx0){return 0;
}else if(state->zeroCrossing<=zx1){return 0;
}else if(state->zeroCrossing<=zx2){return 1;
}else if(state->zeroCrossing<=zx3){return 2;
}else{return 4;
}}#endif/*SPESII*//**0b-13 52 34567012*14-18 43 45670123*19-2f 3456701234*30-78 25 67012345*79* 16 70123456*/int gains(int i,State_t *state){if(i==0){return 0;
}if(state->zeroCrossing<=zx0){if(signs(i,state)>0){return(gains4[state->gain][indices(i,state)]};
}else{return(gains5[state->gain][indices(i,state)]);
}}else if(state->zeroCrossing<=zx1){if(signs(i,state)>0){return(gains3[state->gain][indices(i,state)]);
}else{return(gains4[state->gain][indices(i,state)]};
}}else if(state->zeroCrossing<=zx2){if(signs(i,state)>0){return(gains4[state->gsin][indices(i,state)]);
}else{return(gains4[state->gain][indices(i,state)]);
}}else if(state->zeroCrossing<=zx3){if(signs(i,state)>0){return(gains5[state->gain][indices(i,state)]);
}else{return(gains3[state->gain][indices(i,state)]);
}}else{if(signs(i,state)>0){ret urn(gains6[state->gain][indices(i,state)]);
}else{return(gains2[state->gain][indices(i,state)]);
}}}int limits(int i,State_t *state){if(i==0){return 0;
}if(state->zeroCrossing<=zx0){if(signs(i,state)>0){return(limits4[state->gain](indices(i,state)]);
}else{return(limits5[state->gain](indices(i,state)]);
}}else if(state->zeroCrossing<=2x1){if(signs(i,state)>0){return(limits3[state->gain][indices(i,state)]);
}else{return(limits4[state->gain][indices(i,state)]);
}}else if(state->zeroCrossing<=zx2){if(signs(i,state)>0){return(limits4[state->gain][indices(i,state)]);
}else{return(limits4(state->gain][indices(i,state)]);
}}else if(state->zeroCrossing<=zx3){if(signs(i,state)>0){return(limits5[state->gain][indicss(i,state)]);
}eise{return(limits3[state->gain][indices(i,state)]);
}}else{if(signs(i,state)>0){retur(limits6]state->gain][indices(i,state)]);
}else{return (limits2[state->gain][indices(i,state)]);
}}}void linearToSd3(State_t *state,int code){int delta;
if(code!=-1>{state->code=code;
return;
}delta=sample12To8(state->ch)-atate->last;
if(state->isPositiveGain==FALSE){delta=-delta;
}/**0b-135234567012*14-1843 45670123*19-2f34 56701234*30-7825 67012345*79+ 1670123456*/{if((signs(6,state)>0)&&(delta>=limits(6,state))){55
state->code=0x06;
}else if((signs(S,state)>0)&&(delta>=limits(5,state))){state->code=0x05;
}else if((signs(4,state)>0)&&(delta>=limits(4,state))){state->code=0x04;
}else if((signs(3,state)>0)&&(delta>=limits(3,state))){state->code=0x03;
}else if((signs(2,state)>0)&&(delta>=limits(2,state))){state->code=0x02;
}else if((si gns(1,state)>0)&&(delta>=limits(1,state))){state->code=0x01;
}else if((signs(3,state)<0)&&(-delta>=limits(3,state))){state->code=0x03;
}else if((signs(4,state)<0)&&(-delta>=limits(4,state))){state->code=0x04;
}else if((signs (5,state)<0)&&(-delta>=limits(S,state))){state->code=0x05;
}else if((signs(6,state)<0)&&(-delta>=limits(6,state))){state->code=0x06;
}else if((signs(7,state)<0)&&(-delta>=limits(7,state))){state->code=0x07;
}else{state->code=0x00;
}}void sd3ToLinear(State_t *state,int code,int errWeight){int delta;
state->code=code;
delta=gains(code,state);
if(signs(code,state)==0){if(signs(4,state)>0){//Avoids flipping if asymmetric negativestate->isPositiveGain=TRUE+FALSE-state->isPositiveGain;
}}if(signs(code,state)<0){state->isPositiveGain=TRUE+FALSE-state->isPositiveGain;
}if(dgains(code,state)<0){if(state->gainHoldoff==0){state->gain=state->gain+dgains(code,state);
state->gainHoldoff=0;
if(state->gain<0){state->gain=0;
}}else{state->gainHoldoff=state->gainHoldoff-4;
if(state->gainHoldoff<0){state->gainHoldoff=0;
}}}else if(dgains(code,state)>0){state->gain=state->gain+dgains(code,state);
state->gainHoldoff=0;
if(state->gain>gainMax){state->gain=gainMax;
}}
if(state->isPositiveGain){state->last*state->last+delta;
}else{state->last=state->last-delta;
}#ifdef SPEECH_WRAPif(state->last<0){state->last=state->last+0x100;
}if(state->last>0xff){state->last=state->last-0x100;
}#else/*SPEECH_WRAP*/if(state->last<0){state->last=0;
}if(state->last>0xff){state->last=0xff;
}#endif /* SPEECH_WRAP*/if(state->last==0x80){if(state->zeroCrossingCount>0){state->zeroCrossing=state->zeroCrossing-((state->zeroCrossing+4)/8);#ifdef LIMIT_ZCif(state->zeroCrossing>zeroCrossingLimit){state->zeroCrossing=zeroCrossingLimit;
}#endifstate->zeroCrossing=state->zeroCrossing+state->zeroCrossingCo unt;
state->zeroCrossingCount=0;
}else if(state->zeroCrossingCount<0){state->zeroCrossing=state->zeroCrossing-((state->zeroCrossing+4)/8);#ifdef LIMIT_ZCif(state->zeroCrossing>zeroCrossingLimit){state->zeroCrossing=zeroCrossingLimit;
}#endifstate->zeroCrossing=state->zeroCrossing-state->zeroCrossingCount;
state->zeroCrossingCount=0;
}}else if(state->last>0x80){if(state->zeroCrossingCount>=0){if(state->zeroCrossingCount<16){state->zeroCrossingCount++;
}}else if(state->zeroCrosaingCount<0){state->zeroCrossing=state->zeroCrossing-((state->zeroCrossing+4)/8);#ifdef LIMIT_ZCif(state->zeroCrossing>zeroCrosaingLimit){state->zeroCrossing=zeroCrossingLimit;
}#endifstate->zeroCrossing=state->zeroCrossing-state->zeroCrossingCount;
state->zeroCrossingCount=1;
}}else if(state->last<0x80){if(state->zeroCrossingCount<=0){if(state->zeroCrossingCount>-16){state->zeroCrossingCount--;
}}else if(state->zeroCrossingCount>0){state->zeroCrossing=state->zeroCrossing-((state->zeroCrossing+4)/8);#ifdef LIMIT_ZCif(state->zeroCrossing>zeroCrossingLimit){state->zeroCrossing=zeroCrossingLimit;
}#endifstate->zeroCrossing=state->zeroCrossing+state->zeroCrossingCount;
state->zeroCrossingCount=-1;
}}if(state->gain<minGains(state)){state->gain=minGains(state);
}#ifdef CONSIDER_ONLY_8_BITSstate->error=state->error+((state->last-sample12To8(state->ch))*(state->last-sample12To8(state->ch))*errWeight/10);#else/*CONSIDER_ONLY_8_BITS*/state->error=state->error+((sample8To12(state->last)-state->ch)*(sample8To12(state->last)-atate->ch)*errWeight/10);#endif/*CONSIDER_ONLY_8_BITS*/}/*SUNPLUS Speech file format:
uint mark; //4 always 0x00FF00FFchar name[16]; //16"SUNPLUS SPEECH"word type; //2 data type of this fileword bits; //2 bit numbersword ifS; //2 index sample rate see Classword ifC; //2 index SCF-BANDEDGE see Classword inp_vol; //2 index for recording vol see Classuint checksum; //4 checksum<noused now>
byte Claas;//1 Coding cardselect 0/1:RP20/RP14byte iA; //1 7-14 paramet er for RP14 usedbyte TB; //1 parameter for RP14 useduint Frereq; //4 Sample frequency in binaryuint bps; //4 Bits per secondbyte reserve[3]; //3 reversedSUNPLUS Speech file format Type definition<offset 20,21,two bytes>:
0x0X:PCM*0x00:PCM-normal*0x01:PCM +end-code ;-e*0x02:PCM +runlength ;-r*0x08:LOG-PCM#1 <imply end-code>;bit information included0x1X:ADPCM-4bit*0x10: Adpcm-normal;
*0x11: Adpcm-normal+e nd-code ;-e*0x12; Adpcm-enhance ;
*0x13:Adpcm-enhance +end-code ;-e*0x14:Adpcm-normal+runlength;-r(auto-e)*0x15:Adpcm-enhance +runlength;-r(auto-e)*0x18:AdpcmNewTable-normal ;
*0x19:AdpcmNewTable-noraml+end-code ;-e*0x1A:AdpcmNewTable-enhance ;
*0x1B:AdpcmNewTable-enhance +end-code ;-e*0x1C:AdpcmNewTable-normal+runlength;-r(auto-e)*0x1D:AdpcmNewTable-enhance +runlength;-r(auto-e)0x2X:Enhanced ADPCM algorithm*0x20:E-Adpcm-5bit*0x21:E-Adpcm-4bit*0x22:E-Adpcm-3bit0x3X:CELP0x30:CELP0x4X:LPC0x40:T.B.D0x5X:SubBand0x50:SubBand0x6X:Reversed0x7X:Reversed0x8X:Reversed0x9X:Reversed0xAX:Reversed0xBX:Reversed0xCX:Reversed0xDX:Reversed0xEX:Reversed0xFX:Reversed*/#ifdef SPESIIint A34[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x60,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x23,0x6D,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_6[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x60,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x2F,0x67,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_7[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x60,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x0B,0x21,0x45,0x1B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_8[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x60,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x23,0x6D,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_10[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x60,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x0B,0x17,0x21,0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};#else/* SPESII */int A34[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x64,0x00,0x08,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x23,0x6D,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_6[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x64,0x00,0x08,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x2F,0x67,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_7[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x64,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x0B,0x21,0x45,0x1B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_8[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x64,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x23,0x6D,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};int A34_10[]={0x00,0xFF,0x00,0xFF,0x53,0x55,0x4E,0x50,0x4C,0x55,0x53,0x20,0x53,0x50,0x45,0x45,0x43,0x48,0x00,0x00,0x64,0x00,0x08,0x00,0x0F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x0B,0x17,0x21,0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,};#endif /* SPESII */void doA34Header(char *argv){#ifdef A34_HEADER/**Create .a34 header for output file*/if(strcmp(argv,"6")==0){for(i=0;i<48;i++]{fputc(A34_6[i],outfile);
}}else if(strcmp(argv,"7")==0){for(i=0;i<48;i++){fputc(A34_7[i],outfile);
}}else if(strcmp(argv,"8")==0){for(i=0;i<48;i++){fputc(A34_8[i],outfile);
}}else if(strcmp(argv,"10")==0){for(i=0;i<48;i++){fputc(A34_10[i],outfile);
}}else{for(i=0;i<48;i++){fputc(A34[i],outfile);
}}#endif/* A34_HEADER */}void doBestFit(void){ergain=10;
for(j=0;j<7;j++){copyState(&states[j],&states[j+1]);
states[j+1].ch=inbuf[j];
linearToSd3(&states[j+1],-1);
sd3ToLinear(&states[j+1],states[j+1].code,ergain);
ergain=10;
bestCodes[j+1]=states[j+1].code;
}bestError=states[7].error;
for(j=0;j<8;j++){copyState(&state s
,&states[1]);
states[1].ch=inbuf
;
linearToSd3(&states[1],j )ergain=10;
sd3ToLinear[&states[1],states[1].code,ergain);
if(states[1].error>=bestError){
continue;
}ergain=10;
for(k=0;k<8;k++){copyState(&states[1].&states[2]);
states[2].ch=inbuf[1];
linearToSd3(&stat es[2],k);
sd3ToLinear(&states[2],states[2].code,ergain);
if(states[2].error>=bestError){continue;
}for(m=0;m<8;m++){copyState(&states[2],&states[3]);
states[3].ch=inbuf[2];
linearToSd3(&states[3],m);
sd3ToLinear(&8tates[3],states[3].code,ergain);
if(states[3].error>=bestError){continue;
}for(n=0;n<8;n++){copyState(&states[3],&states[4]);
states[4].ch=inbuf[3];
linearToSd3(&states[4],n);
sd3ToLinear(&states[4],states[4].code,ergain);
if(states[4].error>=bestError){continue;
}for(p=0;p<8;p++){copyState(&states[4],&states[5]);
states[5].ch=inbuf[4];
linearToSd3(&atates[5],p);
sd3ToLinear(&atates[5],states[5].code,ergain);
if(states[5].error>=bestError){continue;
}for(r=0;r<8;r++){copyState(&states[5],&states[6]);
states[6].ch=inbuf[5];
linearToSd3(&states[6],r);
sd3ToLinear(&states[6],state8[6].code,ergain；if(states[6],error>=bestError){continue;
}for(s=0;s<8;s++]{copyState(&states[6],&states[7]);
states[7].ch=inbuf[6];
linearToSd3(&states[7],s);
sd3ToLinear(&atates[7],states[7].code,ergain);
if(states[7].error<bestError){for(t=0;t<7;t++){best Codes[t+1]=states[t+1].code;
}bestError=states[7].error;
}}}}}}
}}copyState(&states
,&states[1]);
states[1].ch=inbuf
;
linearToSd3(&states [1],bestCod es[1]);
copyState(&states[1],&states
);}int speechEventToSd3Code(int se){return(0x80+0x10*(se-1));}int getSpeechEvent(Cue_t *cue,int first,int last){#ifndef NO_SPEECH_EVENTSint i0,j0,k0;
for(i0=0;i0<cue->numCuePoints;i0++){if((cue->cuePoint[i0].position>=first)&&
(cue->cuePoint[i0].position<=last)){for(j0=0;j0<cue->numLabels;j0++){if(cue->label[j0].cuePointId==cue->cuePoint[i0].id){k0=labelToEvent(cue->label[j0].text);
if((k0>=0)&&(k0<=99)){return(k0);
}else{return(FAILURE);
}}}}}#endif /* NO_SPEECH_EVENTS */return(FAILURE);}void insertSpeechEvent(Cue_t *cue){#ifndef NO_SPEECH_EVENTSint i0,j0;
i0=getSpeechEvent(cue,i-count+1,i);
if((i0>=0)&&(i0<=99)){j0=speechEventToSd3Code(i0);
sprintf(buffer,"%02x",j0);
fputc(j0,outfi1e);
return;
}#endif /* NO_SPEECH_EVENTS */sprintf(buffer," ");}void packSd3(void){/** Pack the sd3 codes** 0xxxxxxx xxxxxxxx Normal packed ad3 codes* 1xxxxxxx Any special codes* 110xxxxx All zeroes(32 codes)* 1110xxxx 1(code 4)and zeroes(16 codes)* 1111xxxx -1(code 1)and zeroes(16 codes)* 10xxxxxx Macros(64 codes)*/sprintf(buffer," ");
wasTrailingZero=isTrailingZero;
if(count==0) {#ifdef_NO_RLEisTrailingZero=FALSE;#else /*NO_RLE */wasTrailingZero=FALSE;
if(code==0){isTrailingZero=TRUE;
}else if(code==1){isTrailingZero=TRUE;
}else if(code==4){isTrailingZero=TRUE;
}else{isTrailingZero=FALSE;
}#endif /* NO_RLE */}else if(codel=0) {isTrailingZero=FALSE;
}if(count<8) {codes[count]=code;
}count++;
if((count>3)&&(wasTrailingZero==TRUE)&&(isTrailingZero==FAL SE)&&
(getSpeechEvent(&cues
,i-count+1,i)==FAILURE)){/** Got a nonzero,need to code it now*/if(codes
==0){ch=count-1+0xc0;
}else if(codes
==4){ch=count-1+0xe0;
}else if(codea
==1){ch=count-1+0xf0;
}fputc(ch,outfile);
sprintf(&buffer[strlen(buffer)],*%02x*,ch);
count=0;
codes[count]=code;
if(code==0){isTrailingZero=TRUE;
}elae if(code==1){isTrailingZero=TRUE;
}else if(code==4){isTrailingZero=TRUE;
}else{isTrailingZero=FALSE;
}count++;
}else if(((count==5)&&(isTrailingZero==FAL,SE))||((count<=5)&&(incoun t==1))||((count==5)&&(getSpeechEvent(&cues
,i-count+1,i)!=FAILURE))){insertSpeechEvent(&cues
;#else/* FLIP_CODE */
ch=ch+codes[4-j];#endif/*FLIP_CODE */}}if (isCalcRemainderHistogram==FALSE){histogram[ch]++;
}for (j=0;j<0xff;j++){if(ch==macro[j]){fputc(0x80+j,outfile);
sprintf(&buffer[strlen(buffer)],"%02x0x80+j);
break;
}if(0xffff==macro[j]){nummacros=j;
break;
}}if(0xffff==macro[j]){if(isCalcRemainderHistogram==TRUE){histogram[ch]++;
}fputc((ch/0x100)&0xff,outfile);
fputc(ch&0xff,outfile);
sprintf(&buffer[strlen(buffer)],"%02x %02x",(ch/0x100)&0xff,ch&0xff);
}coumt=0;
isTrailingZero=TRUE;
}else if(((count==31)&&(codes
==0))||((codes
==0)&&(incount==1)))||((count>=5)&&(getSpeechEvent(&cues
,i+1,i+1)!=FAILURE))){/** Got too many zeroes,need to code it now*/ch=count+0xc0;
fputc(ch,outfile);
sprintf(&buffer[strlen(buffer)],″%02x *,ch);
count=0;
}else if(((count==15)&&(codes
==4))||((codes
==4)&&(incount==1))||((count>=5)&&(getSpeechEvent(&cues
,i+1,i+1)!=FAILURE))){/* 1 *//** Got too many zeroes,need to code it now*/ch=count+0xe0;
fputc(ch,outfile);
sprintf(&buffer[strlen(buffer)],″%02x ″,ch);
count=0;
}else if(((count==l5)&&(codes
==l))||((codes
==1)&&(incou nt==1))||((count>=5)&&(getSpeechEvent(&cues
,i+1,i+1)!=FAILURE))){/* -1 *//** Got too many zeroes,need to code it now*/ch=count+0xf0;
fputc(ch,outf ile);
sprintf(&buffer[strlen(buffer)],"%02x",ch);
count=0;
}else{sprintf(&buffer[strlen(buffer)]," ");
}if((count==0)&&(i>=traceMin)&&(i<traceMax)){if(isShowCodes){printf(*%04x\r\n",ch );
}}if(isTracefile==TRUE){fputs(buffer,tracefi1e);
}}void incNoise(void){signalPower=signalPower+(pch-0x800)*(pch-0x800);
if(signalPower>=1000000000){signalPower=signalPower-1000000000;
signalPowerMid=signalPowerMid+1;
}if(signalPowerMid>=1000000000){signalPowerid=signalPowerMid-1000000000;
signalPowerHi=signalPowerHi+1;
}signalPowerOld=signalPowerOld+(pch)*(pch);
if(signalPowerOld>=1000000000){signalPowerOld=signalPowerol d-1000000000;
signalPowerOldMid=signalPowerOldMid+1；}if(signalPowerOldMid>=1000000000){signalPowerOldMid=signalPowerOldMid-1000000000;
signalPowerOldMi=signalPoweroldHi +1;
}j=sample8To12(last
)-pch;
if(j<0){j=-j;
}noise=noise+j*j;
if(noise>=1000000000){noise=noise-1000000000;
noiseMid=noieeMid+1;
}if[j>noisePeak){noisePeak=j;
}}void doPlot(void){if(j>noiseMark){sprintf(buffer,"***");
}else{sprintf(buffer," ");
}if(isTracefile==TRUE){fput8(buffer,tracefile);
}
//5 counts at aaaasample[4]=sample[3};
sample[3]=sample[2];
sample[2]=sample[1];
sample[1]=sample
;//sample
=pch;
sample
=last
;
plot
=4*sample[1]-6*sample[2]+4*sample[3]-sample[4]-sample12To8(pch)+0x80;
plot[1]=1*sample[1]-sample[2]+0x80;
plot[2]=2*sample[1]-3*sample[2]+sample[3]+0x80;
error
=error
+(sample12To8(pch)-plot
)*(sample12To8(pch)plot
);
error[1]=error[1]+(sample12To8(pch)-plot[1])*(sample12To8(pch)plot[1];
error[2]=error[2]+(sample12To8(pc h)-plot[2])*(sample12To8(pch)-plot[2]);
for(j=0;j＜256;j++){sprintf(buffer," ");
if(j==0x80){sprintf(buffer,"|");
}if(j==plot
){// sprintf(buf fer,"0");
}if(j==plot[1]){// sprintf(buffer,"1");
}if(j==plot[2]){// sprintf(buffer,"2");
}if(j==last
){sprintf(buffer,"+");
}if(j==sample12To8(pch)0{sprintf(buffer,"*");
}if((isTracefile==TRUE)&&(isPlot==TRUE)){fputs(buffer,tracefile);
}}sprintf(buffer,"\r\n");
if((isTracefile==TRUE)&&(isPlot==TRUE)){fputs(buffer,tracefile);
}}void reportHistogram(void){/**Report histogram*/for(i=0;i＜20;i++){ch=0;
count=-1;
for(j=0;j＜0x8000;j++){if(histogram[j]＞Count){count=histogram[j];
ch=j;
}}if(isShowHistogram){print("%04x %d\r\n",ch,count);
}histogram[ch]=0;
}}void reporcZxd(void){/** Report zxd*/if(isShowZxd){sprintf(buffer,"\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}sprintf(buffer,"Zxd\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}for(i=0;i＜0x80;i++){for(j=0;j＜0x8;j++++){sprintf(burfer,"%04x",zxd[i][j]);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"02x\r\n",i);
if(isTraceflle==TRUE){fputs(buffer,tracefile);
}}sprintf(buffer,"\r\n");
if(isTrac efile==TRUE){fputs(buffer,tracefile);
}}}void reportNoise(void){/**Report noise*/sprintf(buffer,"\r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}while(signalPowerHi){signalPower=signalPower/10+(signalPowerMid-10*(signalPowerMid/10])*100000000;
signalPowerMid=signalPowerMid/10+(signalPowerHi -10*(signalPowerHi/10))*100000000;
signalPowerHi=signalPowerHi/10;
noise=noise/20+(noiseMid-10*(noiseMid/10))*100 000000;
noiseMid=noiseMid/10;
}printf\"SNR %02,2f\r\n",10.0*log(((double)signal Power+(double)signalPowerMid*1000000000.0)/((double)noise+(double)noiseMid*1000000000.0))/log(10.0));
sprintf(buffer,"SNR %02.2f\r\n",10.0*log(((double)signal Power+(double)signalPowerMid*1000000000.0)/((double)noise+(double)noiseMid*1000000000.0))/log(10.0));
if(isTracefile==TRUE){fputs(buffer.tracefile);
}while(signalPowerOldHi){signalPowerOld=signalPowerOld/10*(signalPowerOldMid -10*(signalPowerOldMid/10))*100000000;
signalPowerOldMid=signalPowerOldMid/10*(signalPowerOldHi10*(signalPowerOldHi/10))*100000000;
signaipowerOldHi=signalPowerOldHi/10;
noise=noise/10+(noiseMid-10*(noiseMid/10))=100000000;
noiseMid=noiseMid/10;
}printf("SNR Old%02.2f\r\n",10.0*log(((double)signalPowerOld+(double)aignalPowerOldMid*1000000000.0)/((double)noise+(double)noiseMid*1000000000.0))/log(10.0));
sprintf(buffer,"SNR Old %02.2f\r\n",10.0*log(((double)signaPowerOld+(double)signalPowerOldMid*1000000000.0)/((double)noise+(double)noiseMid*1000000000.0))/log(10.0));
if(isTracefile==TRUE){fputs(buffer,tracefile);
}Printf("Signal %d &09d %09d\r\n",signalPowerHi,signalPowerMid,signalPower);
sprintf(buffer,"Signal %d %09d %09d\r\n",signalPowerHi,signalPowerMid,signalPower);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}printf("Noise、%ld %09d\r\n",noiseMid,noise);
sprintf(buffer,"Noise %ld %09d\r\n",noiseMid,noise);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}printf("Noise peak %ld\r\n",noisePeak);
sprintf(buffer,"Noise peak %ld\r\n",noisePeak);
if(isTracefile==TRUE){fputs(buffer,tracefile)}}void wavDataToSd3(void){i=0;
last
=0x80;
last[1]=0x80;
last[2]=0x80;
last[3]=0x80/** Clear histogram*/for(j=0;j<0x8000;j++){histogram[j]=0;
}/** Clear zxd*/for(j=0;j<0x80;j++]{
zxd[j]
=0;
zxd[j][1]=0;
zxd[j][2]=0;
zxd[j][3]=0;
zxd[j][4]=0;
zxd[j][5]=0;
zxd[j][6]=0;
zxd[j][7]=0;
}sprintf(buffer,"id ch de g gh+zc zx cd de la se x 0 xl spy\r\n*,code);
if(isTracefile==TRUE){fputs(buffer,tracefile)}sprintf(buffer,"--- --- -- -- -- - -- -- -- -- -- -- -- -- -----\r\n".code);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}while(!isEnd){while(incount<8){if(i<dataLength-7){inbuf[incount]=sample16To12(readSample(infile));
}else{inbuf[incount]=-1;
sprintf(buffer,**** dataLength reached *** \r\n");
if(isTracefile==TRUE){fputs(buffer,tracefile);
}}if(inbuf[incount]==-1){/*No more data available*/for(j=incount;j<8;j++){inbuf[j]=sample8To12(0x80);
}break;
}else{incount++;
}}iaEnd=(incount==0);
ch=inbuf
;
if(!isEnd){#ifdef ALGORITHM 3/ * Sign Value Comments ValueGain Use* 1 11Maximum Excursion1+1 bRising envelope* 1 10Medium Excursion1/2 1 bTracking at high speed* 1 01Medium Excursion1/4 1Approximation at low speed* 1 00Medium Excursion1/8 1Falling envelope* 0 00Minimum Excursion0-1 b(Unless was just medium+,chen flip)* 0 01Medium Excursion1/8 1 a* 0 10Medium Excursion1/4 1 a* 0 11Maximum Excursion1/2 +1 ab* (a)Flips isPositiveGain* (b)Resets gainHold to 16* Gain maximum is 7,minimum is 0
*//** Calculate the closest sd3 segment*/limitZeroCrossing(&scates
);//est=last
;//est=4*lasc
-6*last[1]+4*last[2]-lasc[3];//delta=ch-est;
staces
.ch-ch;
pch=states
.ch;
pdelta=sample12To8(states
.ch)-scates
.last;
pgain=states
.ga in;
sprintf(buffer,"%03x %03x %02x %02x %02x %1x %02x %02x",i,pch,pdelta&0xff,pgain,states
.gainHoldoff,states
.isPositiveGain,states
.zeroCrossingCount&0xff,states
.zeroCroaaing);
if(isTracefile==TR UE){fputs(buffer,tracefile);
}doBestFit();
spy0=sample8To12(states
.last)-states
.chspy1=(states
.lsst - sample12To8(states
.ch))*(states
.last - sample12To8(states
.ch));
code=states
.code;
zxd[zeroCrossing][code]++;
pcode=toda;
plast=states
.last/** Reconstruct the signal and update the gain*/sd3ToLinear(&atattes
,states
.code,10);
lagt[3]=last[2];
last[2]=last[1];
last[1]=last
;
last
=states
.laat;
sprintf(buffer,"%02x、02x、02x",states
.code,(states
.last-plast)&0xff,states
.last);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}code=states
.code;
ch=code;
sprintf(buffer,"",code);
if((i>=traceMin)&&(i<traceMax)){if(isShowCodes==FALSE){if(i==tracceMin){printf("\r\nEncoding\r\n");
}else if((i%64)==0){printf("%d \r\n",i);
}}
printf("%lx",code);
}#endif /* ALGORITHM_3 */packSd3();
sprintf(buffer,"%02x %02x",spy0&0xff,spy1&0xff);
if(isTracefile==TRUE){fputs(buffer,tracefile);
}incNoise();
doPlot();
}if(states
.gainHoldoff!=0){states
.gainHoldoff--;
}i++;
for(j=0;j<7;j++){inbuf[j]=inbuf[j+l];
}inbuf[7]=sample8To12(0x80);
incount--;
}if(count!=0){ch=0;
for(j=0;j<count;j++){ch=ch*0x08;
ch=ch+codes[4-i]；}fputc((ch/0x100)&0xff,outfile);
fputc(ch&0xff,outfile);
}}void sd3ToWavData(void){initVars();
i=0;
while(!isEnd){if(isShowCodes==FALSE){if(i==traceMin){printf("\r\nDecoding\r\n")；}}while(count==0){isEnd=((ch=fgetc(outfile))==-1);
codea
=ch;
if((i>=traceMin)&&(i<traceMax)){if(isShowCodes)[printf("\r\n%02x".codes
);
}}/** Unpack the ad3 codea*/if(codes
==STOPBYTE){
isEnd=(!0);
}else if((codes
&0xe0)=0xc0){//if((codes
&0xe0)==0xc0){count=codes
&0x1f;
codes
=0;
}else if((codes
&0xf0)==0xe0){count=codes
&0x0f;#ifdef FLIP_CODEcodes
=4*0x1000;#else /* FLIP_CODE */codes
=4;#endif /* FLIP_CODE */}else if((codes
&0xf0)==0xf0){count=codes
&0x0f;#ifdef FLIP_CODEcodes
=1*0x1000;#elss /* FLIP_CODE */codes
=1;#endif /* FLIP_CODE */}else if((codes
&0xc0)==0x80){#ifndef NO MACROScount=5；if((codes
&0x3f)<nummacros){codes
=macro[codes
&0x3f];
}else{printf("Unrecognized macro %02x in sample %d \r\n",codes
,i);
}#endif/* NO_MACROS */}else{isEnd=((ch=fgetc(outfile))==-1);
codes
=codes
*0x100+ch;
count=5;
}if((i>=traceMin)&&(i<traceMax)){if(isShowCodes){printf("%04x %04x",codes
,count);
}}}// isEnd=((ch=fgetc(outfile))==-1);// code=ch;
if(!isEnd){//#ifdef bugbug#ifdef ALGORITHM_3/*Sign ValueComments ValueGain Use*1 00 Minimum Excursion14Rising envelope*1 01 Medium Excursion1/4 1Tracking at high speed*1 10 Medium Excursion1/16 1Approximation at low speed*1 11 Maximum Excursi0n01/2 Falling envelope*0 00 Minimum Excursiion*0 01 Medium Excursion*0 10 Medium Excursion*0 11 Maximum Excursion**/
plast=states
.last;
pgain=states
.gain;#ifdef FLIP_CODEcode=(codes
/0x1000)&0x07;
codes
=(codes
&0x0fff)*0x08;#else /* FLIP_CODE*/code=codes
&0x07;
codes
=codes
/0x06;#endif /* FLIP_CODE */count--;
if((i>=traceMin)&&(i<traceMax)){if(isShowCodes==FALSE){if(i==traceMin){}else if((i%64)==0){printf("%d\r\n",i);
}}printf("%1x",code);
}//est=states
.las t;//est=4*last
-6*last [1]+4*last[2]-last[3];
/** Reconstruct the signal and update the gain*/limitZeroCrossing(&states
);
sd3ToLinear(&states
,code,10);
ch * states
.last;
if((i>=dumpMin)&&(i<dumpMax)){printf("%03x xx xx %02x、%02x %1x %02x %02x xx %02x、%02x \r\n",i,pgain,states
.gainHoldoff,states
.isPositiveGain,states
.zeroCross ingCount&0xff,states
.zeroCrossing,code,states
.last);
}#endif /* ALGORITHM_3 *///ch=(int)((float)12.8*sin((float)i*0.001*exp((float)i/10000.0))+128.0);/*sweep10 *///ch=(int)((float)32.0*sin((float)i*0.001*exp((float)i/10000.0))+128.0);//ch=(int)((float)32.0*sin((float)i*2.0*3.14159265*100.0/8000.0)+128.0);/*100Hz*///ch=(int)((float)32.0*sin((float)土*2.0*3.14159265*440.0/8000.0)+128.0);/*440Hz*///ch=(int)((float)32.0=sin((float)i*2.0*3.14159265*1000.0/8000.0)+128.0);/*1000Hz *///ch=(int)((f1oat)32.0*sin((float)i*2.0*3.14159265*2000.0/8000.0)+128.0);/*2000Hz */if(i<0x7000){//ch=(int)((float)(i)/256.0*sin((fl oat)i*2.0*3.14159265*100.0/8000.0)+128.0);/*100Hz wow *///ch=(int)((float)(i)/256.0*sin((float)i*2.0*3.14159265*440.0/8000.0)+128.0);/*440Hz wow*///ch=(int)((float)(i)/256.0*sin((float)i*2.0*3.14159265*1000.0/8000.0)+128.0);/*1000Hz wow*///ch=(int)((float)(i)/256.0*sin((float)i*2.0*3.14159265*2000.0/8000.0)+128.0);/*2000Hz wow*/}else{// ch=(int)((f1oat)(0xe000-i)/256.0*sin((float)i*2.0*3.14159265*100.0/8000.0)+128.0);/*100Hz wow*/// ch=(int)((float)(0xe000-i)/256.0*sin((float)i*2.0*3.14159265*440.0/8000.0)+128.0);/*440Hz wow*/// ch=(int)((float)(0xe000-i)/256.0*sin((float)i=2.0*3.14159265*1000.0/8000.0)+128.0);/*1000Hz w ow*/// ch=(int)((float)(0xe000-i)/256.0*sin((float)i*2.0*3.14159265*2000.0/8000.0)+128.0);/*2000Hz wow*/}fputc(ch,testfile);
}if(states
.gainHoldoff!=0){states
.gainHoldoff--;
}i++;
}}int main(int argc,char*argv()){initVars();
isEnd=0;//falsei=0;
chars=0;
/** argc==4 No trace file* argc==5 Normal operation* argc==6 Specify KHz*/#ifdef NO_TRACEif((argc<4)||(argc>4))#else /*NO_TRACE*/if((argc<4)||(argc>6))#endif /*No_TRACE*/{printf("\r\n");
printf("\r\n");
printf("\r\n");
printf("WAVTOSD3\r\n");
printf("Converts a wav file into sd3 format. \r\n");
printf("\r\n");
printf("Copyright(c)2003 JW Associates \r\n");
printf("\r\n");
printf("\r\n");
printf("\r\n");
printf("Convert a binary file:\r\n");
printf("\r\n");#ifdef NO_TOACE#else /*NO_TRACE */
printf("wavtosd3<source file><destination file><test f ile><tracefile><speed>\r\n");
printf("\r\n");
printf("wavtosd3 abc.wav abc.sd3 abcsd3.wav abctrace.txt 8 \r\n");
printf("\r\n");
printf("\r\n");
printf("wavtosd3<sourcefile><destination file><test file><tracefile>\r\n");
printf("\r\n");
printf("wavtosd3 abc.wav abc.sd3 abcsd3.wav abctrace.txt \r\n");
printf("\r\n");
printf("\r\n");
printf("wavtosd3<source file"><destination file><test file> \r\n");
printf("\r\n");#endif /* NO_TRACE */printf("wavtosd3 abc.wav ab c.sd3 abcsd3.wav\r\n〃);
printf("\r\n");
printf("\r\n");
printf("Print thess instructions:\r\n");
printf("\r\n");
printf("wavto"d3 /h\r\n");
printf("\r\n");
printf("\r\n");
return 0;
}if(argc==4){isTracefile=FALSE;
}/**Create compressed file*/infile=fopen(argv[1],"rb");//read binaryoutfile=fopen(argv[2],"wb");//write binarytestfile=fopen(argv[3],"wb");//write binaryif(isTracefile==TRUE){tracefile=fopen(argv[4],"wb");//w rite binary}fillFifo(infile,8);
readHeader(&headers
,infile);
printf("wavDataLength="%d\r\n",headers
.wavDataLength);
printf("bitsPerSample="%d\r\n",headers
.bitsPerSaple);
printf("numSamples="%d\r\n",((long)headers
.wavDataLength)*8/headers
.bitsperSample);
dataLength=((long)headers
.wavDataLength)"8/headera
.bitaperSample;
oldBits=headers
.bitsPerSample;
skipData(&headers
,infile);
initCue(&cues
);
readCue(&cues
,infile);
dumpCue(&cues
);
fclose(infile);
infile=fopen(argv[1],"rb");//read binaryfillFifo(infile,8);
readHeader(&headera
,infile);
convertHeader(&headers
);
writeHeader(&header8
,testfile);//for(i=0;i<16;i++){// printf("&03x",sample15T o12(readSample(infile)));//}//printf("\r\n");
doA34Header(argv[5]);
showCoeffs();
wavDataToSd3();#ifdef INSERT_STOPBYTE/** End data with a stop code*/fputc(STOPBYTE,outfile);#endif /* INSERT_STOPCODE */reportHistogram();
reportZxd();
reportNoise();
fclose(outfile);/**************************************************************************//** Check compressed file*/outfile=fopen(argv[2],"rb");//read binary#ifdef A34_HEADER/** Skip .a34 header for output file*/for(i=0;i<48;i++){fgetc(outfile);
}#endif /* A34_HEADER */sd3ToWavData();
/** Copy the rest of the test file up to 8000 bytes*/for(i=0;i<8000;i++){isEnd=((ch=fgetc(infile))==-1);
if(!isEnd){fputc(ch,testfile);
}else{sprintf(buffer,"*** 0x%0x more bytes copied ***\r\n",i);
if(isTracefile==TRUE){fouts(buffer.tracefile);
}break;
}}
fclose(infile);
fclose(outfile);
fclose(testfile);
if(isTracefile==TRUE){fclose(tracefile);
}#ifdef PCM_ONLYEND:#endif /* PCM_ONLY*/return 0;}
权利要求
1.一种方法，包括预测信号的自适应差分脉冲编码调制(ADPCM)增量值的符号；以及基于所预测的符号使ADPCM编码方案偏斜。
2.如权利要求1所述的方法，还包括利用经偏斜的ADPCM编码方案对所述ADPCM增量值进行编码。
3.如权利要求2所述的方法，其中所述ADPCM编码方案是被偏斜以提供四个正分辨率级别、一个零分辨率级别和三个负分辨率级别的三比特编码方案，并且其中所述编码是利用所述四个正分辨率级别来实现的。
4.如权利要求2所述的方法，其中所述ADPCM编码方案是被偏斜以提供五个正分辨率级别、一个零分辨率级别和两个负分辨率级别的三比特编码方案，并且其中所述编码是利用所述五个正分辨率级别来实现的。
5.如权利要求1所述的方法，其中是基于一个或多个先前的增量值的符号来预测所述ADPCM增量值的符号的。
6.如权利要求1所述的方法，其中是以基于所述信号的预测频率的非对称性来使所述ADPCM编码方案偏斜的。
7.如权利要求6所述的方法，其中是通过估计所述信号的一个或多个特性来确定所述信号的预测频率的。
8.如权利要求7所述的方法，其中所估计的所述信号的一个或多个特性是从以下群组中选择出来的，该群组包括信号过零点、信号符号变化、信号斜率变化、信号值及其组合。
9.一种机器可读介质，其中存储了一组指令，所述指令在被执行时致使系统执行包括以下步骤的方法预测信号的自适应差分脉冲编码调制(ADPCM)增量值的符号；以及基于所预测的符号使ADPCM编码方案偏斜。
10.如权利要求9所述的机器可读介质，还包括利用经偏斜的ADPCM编码方案对所述ADPCM增量值进行编码。
11.如权利要求10所述的机器可读介质，其中所述ADPCM编码方案是被偏斜以提供四个正分辨率级别、一个零分辨率级别和三个负分辨率级别的三比特编码方案，并且其中所述编码是利用所述四个正分辨率级别来实现的。
12.如权利要求10所述的机器可读介质，其中所述ADPCM编码方案是被偏斜以提供五个正分辨率级别、一个零分辨率级别和两个负分辨率级别的三比特编码方案，并且其中所述编码是利用所述五个正分辨率级别来实现的。
13.如权利要求9所述的机器可读介质，其中是基于一个或多个先前的增量值的符号来预测所述ADPCM增量值的符号的。
14.如权利要求9所述的机器可读介质，其中是以基于所述信号的预测频率的非对称性来使所述ADPCM编码方案偏斜的。
15.如权利要求14所述的机器可读介质，其中是基于一个或多个信号特性来确定所述信号的预测频率的。
16.如权利要求15所述的机器可读介质，其中所估计的所述信号的一个或多个特性是从以下群组中选择出来的，该群组包括信号过零点、信号符号变化、信号斜率变化、信号值及其组合。
17.一种系统，包括处理器；以及耦合到所述处理器的存储器，所述存储器上存储了一个或多个要执行指令，所述指令在被所述处理器执行时致使所述处理器执行包括以下步骤的方法预测信号的自适应差分脉冲编码调制(ADPCM)增量值的符号；以及基于所预测的符号使ADPCM编码方案偏斜。
18.如权利要求17所述的系统，其中所述方法还包括利用经偏斜的ADPCM编码方案对所述ADPCM增量值进行编码。
19.如权利要求18所述的系统，其中所述ADPCM编码方案是被偏斜以提供四个正分辨率级别、一个零分辨率级别和三个负分辨率级别的三比特编码方案，并且其中所述编码是利用所述四个正分辨率级别来实现的。
20.如权利要求18所述的系统，其中所述ADPCM编码方案是被偏斜以提供五个正分辨率级别、一个零分辨率级别和两个负分辨率级别的三比特编码方案，并且其中所述编码是利用所述五个正分辨率级别来实现的。
21.如权利要求17所述的系统，其中是基于一个或多个先前的增量值的符号来预测所述ADPCM增量值的符号的。
22.如权利要求17所述的系统，其中是以基于所述信号的预测频率的非对称性来使所述ADPCM编码方案偏斜的。
23.如权利要求22所述的系统，其中是基于一个或多个信号特性来确定所述信号的预测频率的。
24.如权利要求23所述的系统，其中所估计的所述信号的一个或多个特性是从以下群组中选择出来的，该群组包括信号过零点、信号符号变化、信号斜率变化、信号值及其组合。
全文摘要
本发明的实施例利用适度的处理功率和资源实现了与现有技术ADPCM压缩方案相比更大的音频数据压缩。对于一个实施例，实现了非对称ADPCM编码方案以增大指定数目的编码比特的表观编码分辨率。作为补充或作为备选，采用了诸如模式识别和编码以及计算简化之类的技术来增大音频数据的数据压缩。
文档编号G10L19/00GK1867968SQ200480029700
公开日2006年11月22日 申请日期2004年10月8日 优先权日2003年10月8日
发明者杰罗姆·D·翁 申请人:J.W.联合公司
完整全部详细技术资料下载
  • 该技术已申请专利。仅供学习研究，如用于商业用途，请联系技术所有人。
  • 技术研发人员：杰罗姆.Ｄ.翁
  • 技术所有人：Ｊ．Ｗ．联合公司
  • 我是此专利的发明人
相关技术
网友询问留言 已有0条留言
  • 还没有人留言评论。精彩留言会获得点赞！
1
精彩留言，会给你点赞！

使用协议| 关于我们| 联系X技术

© 2008-2024 【X技术】 版权所有，并保留所有权利。津ICP备16005673号-2