amr 的作用 编解码

2011-11-28 21:56:00 weixin_30617695 阅读数 27
关于android中的语音压缩编码,今天算是好好的研究了一下,有了小小的心得:

首先关于采集到得声音源的格式是PCM-16bit的格式,什么是PCM格式,大家看下面的这篇文章:

http://blog.csdn.net/tkboy/archive/2009/12/19/5038947.aspx

PCM就是无压缩的声音源,PCM信号是由[1]、[0]等符号构成的数字信号,android设备采取的声音源也就是这种格式,我们也正是对这种格式进行的压缩编码。

编码库不是我自己写的,是用bambuser中提取出来的,测试发现,这个库还真是他妈的强大,强大到无以复加的地步,每次编码的时候是这样的:

read= mAudioRecorder.read(arrayOfByte1,0,320);
encodeLength = mAmrEncoder.encode(arrayOfByte1,0,read,arrayOfByte2,AmrEncoder.MR475);

为什么是320呢?

请教了一位做SIP的朋友,是这样说的:

每320个字节或他的倍数的字节打包一次

可能这个就是原因吧,但是其实我对这个还是不是很理解,然后我们技术总监是这样说的:

传统是MS的,语音帧的最小单位是20m,每20ms对应的数据就是320字节,当然这是对应16bit,8Khz.

怎么计算出来的,有高手的指点下.

好,给大家说下编码后的情况,加深大家对这方面的了解:

这320字节的PCM-16语音经过编码后,编程的长度就是13个字节,也就是amr nb的语音格式,如果我们要通过AudioTrack来播放的话,就得用AmrDecoder来进行解码,将这13个字节还原成为320字节的PCM来进行播放。

AMR目前来说效率是比较高的,压缩比为:320:13 ,320字节压缩成为13字节

GSM也可以考虑: 320:33,320字节给你压缩成33字节



/**
* @author 张兴业
* 邮箱:xy-zhang#163.com
* android开发进阶群:278401545
*
*/

转载于:https://www.cnblogs.com/xyzlmn/archive/2011/11/28/3168142.html

2013-06-06 22:09:00 weixin_33769207 阅读数 14

linux下的ffmpeg默认情况下是不支持amr格式解码的,因此考虑手动编译ffmpeg源代码增加解码器以便支持amr文件格式的解码。


见我的博客:http://blog.csdn.net/tylz04/article/details/9041739

转载于:https://my.oschina.net/czg/blog/136120

2015-12-30 16:11:58 szfhy 阅读数 6593

CONTENT:

        *  AMR简介

         * AMR 话音质量评定

          * AMR 文件结构解析

           * AMR 帧结构解析

            * AMR 帧读取算法

             * AMR 解码原理及流程

              * AMR 模式选择自适应机制          

    一、AMR 简介

      基于新的网络和新的要求,无论是从节省传输频带资源,还是保持线路通信的高效率等方面来看,研究采用各种可变速率语音编码技术的系统都有重要意义。目前为了适应此需要提出了AMR(Adaptive Multi-rate) 的概念,即自适应多速率语音编码器,主要用于移动设备的音频,压缩比比较大,但相对其他的压缩格式质量比较差,由于多用于人声通话。AMR又分为两种,一种是AMR-NB(AMR-NarrowBind),语音带宽范围:300-3700Hz,8KHz采样频率;另外一种是AMR-WB(AMR WideBand),语音带宽范围50-7000Hz,16KHz采样频率。但考虑语音的短时相关性,每帧长度均为20ms。这两种编码器根据带宽的要求虽然选用了不同的速率,但有异曲同工之处.

     (1)AMR-NB

        AMR的采样频率为8KHz,每20ms编码一帧,每个帧中包含160个语音样点。

        AMR采用的是基于代数码激励线性预测(ACELP)的编码模式,编码端提取ACELP模型参数(线性预测系数,自适应码本和固定码本索引及增益),解码端接收到数据然后根据这些参数从新合成语音。

TD-SCDMA中AMR-NB的实现。此编码器运用了代数码本线性预测(ACELP)混合编码方式,也就是数字语音信号中既包括若干语音特征参数又包括部分波形编码信息,再运用这些特征信息重新合成语音信号的过程。控制这些参数的提取数目,根据速率要求对信息进行取舍而得到了以下8种速率,混合组成如表一所示的自适应语音编码器。如模式AMR_12.20就提取出244比特的参数信息,而模式AMR_4.70却只提取了95比特信息。根据这些比特所含的信息量可以将其分为3类比特class 0,1和2。在信道编码时class 0和1都将会使用循环冗余校验码进行差错检验,对于class 2则根据上一帧进行恢复。

                   表一 :  AMR 编码器的编码速率

      

编码模型

编码器的比特速率

编码模型

编码器的比特速率

AMR_12.2

12,20kbit/s(GSM_EFR)

AMR_5.90

 5,90 kbit/s

 

AMR AMR   

10,20 kbit/s

AMR_5.15

 5,15 kbit/s

AMR_7.95

7,95 kbit/s

AMR_4.75

 4,75 kbit/s

AMR_7.40

7,40kbit/s (IS-641)

AMR_SID

 1,80 kbit/s (无语音信息传输)

AMR_6.70

6,70kbit/s (PDC-EFR)

 

 

包括低速率的背景噪声编码模式(DTX)1.80kb/s

 

(  2)AMR-WB

      AMR-WB”全称为“Adaptive Multi-rate – Wideband”,即“自适应多速率宽带编码”,采样频率为

   16kHz,是一种同时被国际标准化组织ITU-T和3GPP采用的宽带语音编码标准,也称为G722.2标准。

       AMR-WB  支持9种不同的编码方式:6.6kb/s  8.85kb/s  12.65kb/s  14.25kb/s  15.85kb/s

  18.25kb/s 19.85kb/s  ,23.05kb/s,23.85kb/s,提供的语音带宽范围达到50~7000Hz,人声感觉比以前

   更加自然、舒适和易于分辨 。

 

   二、话音质量评定

      语音编码或语音压缩编码研究的基本问题,就是在给定编码速率的条件下,如何能得到尽量好的

   重建语音质量。主观评定方法符合人类听话时对语音质量的感觉得到了广泛应用。常用的方法有平均

   得分意见(Mean Opinion Score, 简称MOS)判定法,下表说明了AMR话音编码器各模式的话音质量。

 

             表二 :  AMR话音编码器各模式的MOS值

 

 编码方式

AMR122

AMR102

AMR795

AMR74

AMR67

AMR59

AMR515

AMR475

MOS

4.01

4.06

3.91

3.83

3.77

3.72

3.50

3.50

 

    三、AMR文件结构解析

       AMR文件由文件头和数据帧组成,文件头标识占6个字节,后面紧跟着就是音频帧;

         格式如下所示:

 

文件头(占 6 字节)

语音帧1

语音帧2

         文件头

        单声道和多声道情况下文件的头部是不一致的,单声道情况下的文件头只包括一个Magic number,

    而多声道情况下文件头既包含Magic number,在其之后还包含一个32位的Chanel description field。

    多声道情况下的32位通道描述字符,前28位都是保留字符,必须设置成0,最后4位说明使用的声道

个数。

 

     语音数据

        文件头之后就是时间上连续的语音帧块了,每个帧块包含若干个8位组对齐的语音帧,相对于若干个

      声道,从第一个声道开始依次排列。每一个语音帧都是从一个8位的帧头开始:

     其中P为填充位必须设为0,每个帧都是8位组对齐的。

      对于不同的编码模式,它的音频帧的大小是不同的,比特率也是不同的;如下图所示:

 

规格

比特率(kbps)

音频帧大小(字节)

帧头(字节)

FT

0

AMR 4.75

  4.75

13

04  00000100

0000

1

AMR 5.15

  5.15

14

0C 00001100

0001

2

AMR 5.9

   5.90

16

14 00010100

0010

3

AMR 6.7

   6.70

18

1C 00011100

0011

4

AMR 7.4

   7.40

20

24 00100100

0100

5

AMR 7.95

   7.95

21

2C  00101100

0101

6

AMR 10.2

  10.20

27

34 00110100

0110

7

AMR 12.2

  12.20

32

3C  00111100

0111

 

     音频数据帧大小的计算:

     AMR 一帧对应20ms,那么一秒有50帧的音频数据。由于比特率不同,每帧的数据大小也不同。

     如果比特率是12.2kbs,那么每秒采样的音频数据位数为:

    12200 / 50 = 244bit = 30.5byte,取整为31字节。

      再加上一个字节的帧头,这样数据帧的大小为32字节。

 

四、帧格式解析

     AMR语音帧格式由帧头和语音数据组成;并且分为两种类型的帧格式:AMR IF1 和 AMR IF2

如下图所示:

帧头

语音数据

  

1个字节帧头

(AMR Header)

(1)AMR IF1的帧格式如下图:

 

 

 

 

  a .   AMR  Header占1个字节,如下图所示:

0

1

2

3

4

5

6

7

P

FT

Q

P

P

0

 

 

 

 

0

0

0

 

      P = 0;

      FT:Frame Type,对应不同编码模式;占4 bit;

      Q:帧质量指示器,0:表示为坏帧; 占 1 bit。

      后面的2个P补0

b.   帧头后面就是辅助信息。

         此辅助信息针对自适应模式及差错检测。

c.       辅助信息后面就是语音数据。每一帧的数据有分为三个部分:Class A ,Class B ,Class C;

        Class A:是一帧中最敏感、最重要的数据。这部分数据如有损坏,整个帧将无法解码。所以,一般在无线传输的时候要使用各种冗余的方式对这部分数据加以保护。

         Class B:相对而言,比Class A不重要的数据。

        Class C:比Class B还不重要的数据。

 

(2)AMR IF2的帧格式如下图所示:

 

        

 

 

相对于IF1格式, IF2 省去了Frame Quality Indicator, Mode Indication, Mode Request 和CRC 校验。但是增加了bit 填充。因为AMR帧中数据的长度并不是字节(8bit)的整数倍,所以在有些帧的末尾需要增加bit填充,以使整个帧的长度达到字节的整数倍。

 

  五、AMR帧读取算法

    

    因为可能存在异常帧,所以不一定所有的语音帧大小一致,对于跟正常帧大小不一致的,或者帧头跟正常帧头不一致的,就不交给解码器,直接抛弃该坏帧。

    读取帧的算法:

 

 六、 AMR解码流程

 

     AMR Payload Decode原理分析如图中Payload Parse模块-----解码出编码语音数据;

     AMR Speech Decode原理分析如图中Speech Decode模块----解码语音帧;

     AMR DTX decode原理分析如图中DTX Decode模块-----解码噪音帧;

     AMR Post-Processing原理分析如图中的Post-Processing模块-----语音后处理;

 

 

     

 

 

    七.AMR模式选择的自适应机制

       自适应的基本概念是以更加智能的方式解决信源和信道编码的速率分配问题,使得无线资源的配置

   和利用更加灵活和高效。实际的语音编码速率取决于信道的条件,它是信道质量的函数。而这部分的工

   作是解码器根据噪声等测量参数协助基站来完成,选择模式,决定速率快慢。原则上在信道很差的时候

   采用速率比较低的编码器,这样就能分配给信道编码更多的比特数来实现纠错,实现更可靠的差错控制,

   从而有效地抑制错误发生,提高话音质量。

  

 

 

        

                                 自适应过程实现框图

原文地址:

http://blog.csdn.net/wlsfling/article/details/5875928


自己压缩出来的数据却无法正常播放,我输入的pcm s16LE, 输入pcm格式有要求吗?

You'll need Skype CreditFree via Skype
2009-01-06 15:43:00 jinlking 阅读数 3919
http://blog.csdn.net/dinggo/archive/2007/12/29/2002298.aspx

AMR音频编解码
 
目录
1.    概述
3.    AMR解码
4.    AMR帧读取算法
5.    参考资料
 
现在很多智能手机都支持多媒体功能,特别是音频和视频播放功能,而AMR文件格式是手机端普遍支持的音频文件格式。
 
AMR,全称是:Adaptive Multi-Rate,自适应多速率,是一种音频编码文件格式,专用于有效地压缩语音频率。
 
AMR音频主要用于移动设备的音频压缩,压缩比非常高,但是音质比较差,主要用于语音类的音频压缩,不适合对音质要求较高的音乐类音频的压缩。
 
AMR的编解码是基于“3GPP AMR Floating-point Speech Codec”来做的,3GPP还专门开放了基于ANSI-C实现的编解码代码,便于我们在各种平台上进行移植。
 
#ifndef amrFileCodec_h
#define amrFileCodec_h
 
#define AMR_MAGIC_NUMBER "#!AMR/n"
 
#define PCM_FRAME_SIZE 160 // 8khz 8000*0.02=160
#define MAX_AMR_FRAME_SIZE 32
#define AMR_FRAME_COUNT_PER_SECOND 50
//int amrEncodeMode[] = {4750, 5150, 5900, 6700, 7400, 7950, 10200, 12200}; // amr 编码方式
 
typedef struct
{
         char chChunkID[4];
         int nChunkSize;
}XCHUNKHEADER;
 
typedef struct
{
         short nFormatTag;
         short nChannels;
         int nSamplesPerSec;
         int nAvgBytesPerSec;
         short nBlockAlign;
         short nBitsPerSample;
}WAVEFORMAT;
 
typedef struct
{
         short nFormatTag;
         short nChannels;
         int nSamplesPerSec;
         int nAvgBytesPerSec;
         short nBlockAlign;
         short nBitsPerSample;
         short nExSize;
}WAVEFORMATX;
 
typedef struct
{
         char chRiffID[4];
         int nRiffSize;
         char chRiffFormat[4];
}RIFFHEADER;
 
typedef struct
{
         char chFmtID[4];
         int nFmtSize;
         WAVEFORMAT wf;
}FMTBLOCK;
 
// WAVE音频采样频率是8khz
// 音频样本单元数 = 8000*0.02 = 160 (由采样频率决定)
// 声道数 1 : 160
//        2 : 160*2 = 320
// bps决定样本(sample)大小
// bps = 8 --> 8 unsigned char
//       16 --> 16 unsigned short
int EncodeWAVEFileToAMRFile(const char* pchWAVEFilename, const char* pchAMRFileName, int nChannels, int nBitsPerSample);
 
// AMR文件解码成WAVE文件
int DecodeAMRFileToWAVEFile(const char* pchAMRFileName, const char* pchWAVEFilename);
 
#endif
 

3GPP提供了编码代码,并提供了一个encoder.c程序,该程序示范了如何对一个16位的单声道PCM数据进行压缩的。(采样频率必须是8khz
 
我对该程序进行一定的拓展,数据位支持8位和16位,可以是单声道和双声道。
 
l         对于8PCM只需要将每个采样的sample数据位扩展成16位,并左移7位。
l         对于双声道,可以只对左声道数据进行处理,也可以只对右声道数据进行处理,或者将左右声道数据求平均值就可。
 
这样两个小处理,就可以将PCM规范成3PGG的编码器需要的数据格式。
 
代码在 amrFileEncoder.c 中。
 
#include "amrFileCodec.h"
 
// WAVE文件中跳过WAVE文件头,直接到PCM音频数据
void SkipToPCMAudioData(FILE* fpwave)
{
         RIFFHEADER riff;
         FMTBLOCK fmt;
         XCHUNKHEADER chunk;
         WAVEFORMATX wfx;
         int bDataBlock = 0;
 
         // 1. RIFF
         fread(&riff, 1, sizeof(RIFFHEADER), fpwave);
 
         // 2. FMT - 如果 fmt.nFmtSize>16 说明需要还有一个附属大小没有读
         fread(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
         if ( chunk.nChunkSize>16 )
         {
                   fread(&wfx, 1, sizeof(WAVEFORMATX), fpwave);
         }
         else
         {
                   memcpy(fmt.chFmtID, chunk.chChunkID, 4);
                   fmt.nFmtSize = chunk.nChunkSize;
                   fread(&fmt.wf, 1, sizeof(WAVEFORMAT), fpwave);
         }
 
         // 3.转到data - 有些还有fact块等。
         while(!bDataBlock)
         {
                   fread(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
                   if ( !memcmp(chunk.chChunkID, "data", 4) )
                   {
                            bDataBlock = 1;
                            break;
                   }
                   // 因为这个不是data,就跳过块数据
                   fseek(fpwave, chunk.nChunkSize, SEEK_CUR);
         }
}
 
// WAVE文件读一个完整的PCM音频帧
// 返回值: 0-错误 >0: 完整帧大小
int ReadPCMFrame(short speech[], FILE* fpwave, int nChannels, int nBitsPerSample)
{
         int nRead = 0;
         int x = 0, y=0;
         unsigned short ush1=0, ush2=0, ush=0;
 
         // 原始PCM音频帧数据
         unsigned char pcmFrame_8b1[PCM_FRAME_SIZE];
         unsigned char pcmFrame_8b2[PCM_FRAME_SIZE<<1];
         unsigned short pcmFrame_16b1[PCM_FRAME_SIZE];
         unsigned short pcmFrame_16b2[PCM_FRAME_SIZE<<1];
 
         if (nBitsPerSample==8 && nChannels==1)
         {
                   nRead = fread(pcmFrame_8b1, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for(x=0; x<PCM_FRAME_SIZE; x++)
                   {
                            speech[x] =(short)((short)pcmFrame_8b1[x] << 7);
                   }
         }
         else
         if (nBitsPerSample==8 && nChannels==2)
         {
                   nRead = fread(pcmFrame_8b2, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for( x=0, y=0; y<PCM_FRAME_SIZE; y++,x+=2 )
                   {
                            // 1 - 取两个声道之左声道
                            speech[y] =(short)((short)pcmFrame_8b2[x+0] << 7);
                            // 2 - 取两个声道之右声道
                            //speech[y] =(short)((short)pcmFrame_8b2[x+1] << 7);
                            // 3 - 取两个声道的平均值
                            //ush1 = (short)pcmFrame_8b2[x+0];
                            //ush2 = (short)pcmFrame_8b2[x+1];
                            //ush = (ush1 + ush2) >> 1;
                            //speech[y] = (short)((short)ush << 7);
                   }
         }
         else
         if (nBitsPerSample==16 && nChannels==1)
         {
                   nRead = fread(pcmFrame_16b1, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for(x=0; x<PCM_FRAME_SIZE; x++)
                   {
                            speech[x] = (short)pcmFrame_16b1[x+0];
                   }
         }
         else
         if (nBitsPerSample==16 && nChannels==2)
         {
                   nRead = fread(pcmFrame_16b2, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for( x=0, y=0; y<PCM_FRAME_SIZE; y++,x+=2 )
                   {
                            //speech[y] = (short)pcmFrame_16b2[x+0];
                            speech[y] = (short)((int)((int)pcmFrame_16b2[x+0] + (int)pcmFrame_16b2[x+1])) >> 1;
                   }
         }
 
         // 如果读到的数据不是一个完整的PCM, 就返回0
         if (nRead<PCM_FRAME_SIZE*nChannels) return 0;
 
         return nRead;
}
 
// WAVE音频采样频率是8khz
// 音频样本单元数 = 8000*0.02 = 160 (由采样频率决定)
// 声道数 1 : 160
//        2 : 160*2 = 320
// bps决定样本(sample)大小
// bps = 8 --> 8 unsigned char
//       16 --> 16 unsigned short
int EncodeWAVEFileToAMRFile(const char* pchWAVEFilename, const char* pchAMRFileName, int nChannels, int nBitsPerSample)
{
         FILE* fpwave;
         FILE* fpamr;
 
         /* input speech vector */
         short speech[160];
 
         /* counters */
         int byte_counter, frames = 0, bytes = 0;
 
         /* pointer to encoder state structure */
         int *enstate;
        
         /* requested mode */
         enum Mode req_mode = MR122;
         int dtx = 0;
 
         /* bitstream filetype */
         unsigned char amrFrame[MAX_AMR_FRAME_SIZE];
 
         fpwave = fopen(pchWAVEFilename, "rb");
         if (fpwave == NULL)
         {
                   return 0;
         }
 
         // 创建并初始化amr文件
         fpamr = fopen(pchAMRFileName, "wb");
         if (fpamr == NULL)
         {
                   fclose(fpwave);
                   return 0;
         }
         /* write magic number to indicate single channel AMR file storage format */
         bytes = fwrite(AMR_MAGIC_NUMBER, sizeof(char), strlen(AMR_MAGIC_NUMBER), fpamr);
 
         /* skip to pcm audio data*/
         SkipToPCMAudioData(fpwave);
 
         enstate = Encoder_Interface_init(dtx);
 
         while(1)
         {
                   // read one pcm frame
                   if (!ReadPCMFrame(speech, fpwave, nChannels, nBitsPerSample)) break;
 
                   frames++;
 
                   /* call encoder */
                   byte_counter = Encoder_Interface_Encode(enstate, req_mode, speech, amrFrame, 0);
 
                   bytes += byte_counter;
                   fwrite(amrFrame, sizeof (unsigned char), byte_counter, fpamr );
         }
 
         Encoder_Interface_exit(enstate);
 
         fclose(fpamr);
         fclose(fpwave);
 
         return frames;
}

3GPP提供了解码代码,并提供了一个decoder.c程序,该程序示范了如何对amr音频进行解码。解码成一个wave文件(8khz 16位单声道)。
 
解码是需要注意AMR坏帧的处理。在AMR读帧算法中有说明。
 
文件解码器代码在 amrFileDecoder.c 中。
 
#include "amrFileCodec.h"
 
void WriteWAVEFileHeader(FILE* fpwave, int nFrame)
{
         char tag[10] = "";
 
         // 1. RIFF
         strcpy(tag, "RIFF");
         memcpy(riff.chRiffID, tag, 4);
         riff.nRiffSize = 4                                     // WAVE
                   + sizeof(XCHUNKHEADER)               // fmt
                   + sizeof(WAVEFORMATX)           // WAVEFORMATX
                   + sizeof(XCHUNKHEADER)               // DATA
                   + nFrame*160*sizeof(short);    //
         strcpy(tag, "WAVE");
         memcpy(riff.chRiffFormat, tag, 4);
         fwrite(&riff, 1, sizeof(RIFFHEADER), fpwave);
 
         // 2. FMT
         strcpy(tag, "fmt ");
         memcpy(chunk.chChunkID, tag, 4);
         chunk.nChunkSize = sizeof(WAVEFORMATX);
         fwrite(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
         memset(&wfx, 0, sizeof(WAVEFORMATX));
         wfx.nFormatTag = 1;
         wfx.nChannels = 1; // 单声道
         wfx.nSamplesPerSec = 8000; // 8khz
         wfx.nAvgBytesPerSec = 16000;
         wfx.nBlockAlign = 2;
         wfx.nBitsPerSample = 16; // 16
         fwrite(&wfx, 1, sizeof(WAVEFORMATX), fpwave);
 
         // 3. data块头
         strcpy(tag, "data");
         memcpy(chunk.chChunkID, tag, 4);
         chunk.nChunkSize = nFrame*160*sizeof(short);
         fwrite(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
}
 
const int round(const double x)
{
         return((int)(x+0.5));
}
 
// 根据帧头计算当前帧大小
int caclAMRFrameSize(unsigned char frameHeader)
{
         int mode;
         int temp1 = 0;
         int temp2 = 0;
         int frameSize;
 
         temp1 = frameHeader;
 
         // 编码方式编号 = 帧头的3-6
         temp1 &= 0x78; // 0111-1000
         temp1 >>= 3;
 
         mode = amrEncodeMode[temp1];
 
         // 计算amr音频数据帧大小
         // 原理: amr 一帧对应20ms,那么一秒有50帧的音频数据
         temp2 = round((double)(((double)mode / (double)AMR_FRAME_COUNT_PER_SECOND) / (double)8));
 
         frameSize = round((double)temp2 + 0.5);
         return frameSize;
}
 
// 读第一个帧 - (参考帧)
// 返回值: 0-出错; 1-正确
int ReadAMRFrameFirst(FILE* fpamr, unsigned char frameBuffer[], int* stdFrameSize, unsigned char* stdFrameHeader)
{
         memset(frameBuffer, 0, sizeof(frameBuffer));
 
         // 先读帧头
         fread(stdFrameHeader, 1, sizeof(unsigned char), fpamr);
         if (feof(fpamr)) return 0;
 
         // 根据帧头计算帧大小
         *stdFrameSize = caclAMRFrameSize(*stdFrameHeader);
 
         // 读首帧
         frameBuffer[0] = *stdFrameHeader;
         fread(&(frameBuffer[1]), 1, (*stdFrameSize-1)*sizeof(unsigned char), fpamr);
         if (feof(fpamr)) return 0;
 
         return 1;
}
 
// 返回值: 0-出错; 1-正确
int ReadAMRFrame(FILE* fpamr, unsigned char frameBuffer[], int stdFrameSize, unsigned char stdFrameHeader)
{
         int bytes = 0;
         unsigned char frameHeader; // 帧头
 
         memset(frameBuffer, 0, sizeof(frameBuffer));
 
         // 读帧头
         // 如果是坏帧(不是标准帧头),则继续读下一个字节,直到读到标准帧头
         while(1)
         {
                   bytes = fread(&frameHeader, 1, sizeof(unsigned char), fpamr);
                   if (feof(fpamr)) return 0;
                   if (frameHeader == stdFrameHeader) break;
         }
 
         // 读该帧的语音数据(帧头已经读过)
         frameBuffer[0] = frameHeader;
         bytes = fread(&(frameBuffer[1]), 1, (stdFrameSize-1)*sizeof(unsigned char), fpamr);
         if (feof(fpamr)) return 0;
 
         return 1;
}
 
// AMR文件解码成WAVE文件
int DecodeAMRFileToWAVEFile(const char* pchAMRFileName, const char* pchWAVEFilename)
{
         FILE* fpamr = NULL;
         FILE* fpwave = NULL;
         char magic[8];
         int * destate;
         int nFrameCount = 0;
         int stdFrameSize;
         unsigned char stdFrameHeader;
 
         unsigned char amrFrame[MAX_AMR_FRAME_SIZE];
         short pcmFrame[PCM_FRAME_SIZE];
 
         fpamr = fopen(pchAMRFileName, "rb");
         if ( fpamr==NULL ) return 0;
 
         // 检查amr文件头
         fread(magic, sizeof(char), strlen(AMR_MAGIC_NUMBER), fpamr);
         if (strncmp(magic, AMR_MAGIC_NUMBER, strlen(AMR_MAGIC_NUMBER)))
         {
                   fclose(fpamr);
                   return 0;
         }
 
         // 创建并初始化WAVE文件
         fpwave = fopen(pchWAVEFilename, "wb");
         WriteWAVEFileHeader(fpwave, nFrameCount);
 
         /* init decoder */
         destate = Decoder_Interface_init();
 
         // 读第一帧 - 作为参考帧
         memset(amrFrame, 0, sizeof(amrFrame));
         memset(pcmFrame, 0, sizeof(pcmFrame));
         ReadAMRFrameFirst(fpamr, amrFrame, &stdFrameSize, &stdFrameHeader);
 
         // 解码一个AMR音频帧成PCM数据
         Decoder_Interface_Decode(destate, amrFrame, pcmFrame, 0);
         nFrameCount++;
         fwrite(pcmFrame, sizeof(short), PCM_FRAME_SIZE, fpwave);
 
         // 逐帧解码AMR并写到WAVE文件里
         while(1)
         {
                   memset(amrFrame, 0, sizeof(amrFrame));
                   memset(pcmFrame, 0, sizeof(pcmFrame));
                   if (!ReadAMRFrame(fpamr, amrFrame, stdFrameSize, stdFrameHeader)) break;
 
                   // 解码一个AMR音频帧成PCM数据 (8k-16b-单声道)
                   Decoder_Interface_Decode(destate, amrFrame, pcmFrame, 0);
                   nFrameCount++;
                   fwrite(pcmFrame, sizeof(short), PCM_FRAME_SIZE, fpwave);
         }
 
         Decoder_Interface_exit(destate);
 
         fclose(fpwave);
 
         // 重写WAVE文件头
         fpwave = fopen(pchWAVEFilename, "r+");
         WriteWAVEFileHeader(fpwave, nFrameCount);
         fclose(fpwave);
 
         return nFrameCount;
}
 

4.      AMR帧读取算法
因为可能存在异常帧,所以不一定所有的语音帧大小一致,对于跟正常帧大小不一致的,或者帧头跟正常帧头不一致的,就不交给解码器,直接抛弃该坏帧。
 
读取帧的算法,用C语言来编写,readAMRFrame.cJAVA可以用类似的方法。
下面是算法描述流程图。

读首帧(标准帧)
ReadFirstAMRFrame
根据帧头计算标准帧的大小
caclAMRFrameSize
AMR音频文件流
读帧头(字节)
frameHeader
判断是否为坏帧?
Y
N
读本帧音频数据
帧头 + 音频数据 = 当前帧数据
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


l         rfc3267
http://www.rfc-editor.org/rfc/rfc3267.txt
http://ietfreport.isoc.org/rfc/PDF/rfc3267.pdf
l         3GPP TS 26.104 V 6.1.0 (2004-03)
http://www.3gpp.org/ftp/Specs/html-info/26104-CRs.htm
l         3GPP AMR Floating-point Speech Codec
http://www.3gpp.org/ftp/Specs/html-info/26104.htm
l         amr编程汇总”
http://blog.csdn.net/windcao/archive/2006/01/04/570348.aspx
l         关于AMR文件格式的解释
http://www.mcublog.com/blog/user1/11409/archives/2006/16832.html
l         

2009-06-19 18:04:00 weixin_34061042 阅读数 86

目录
1.    概述
2.    AMR编码
3.    AMR解码
4.    AMR帧读取算法
5.    参考资料
 
1.      概述
现在很多智能手机都支持多媒体功能,特别是音频和视频播放功能,而AMR文件格式是手机端普遍支持的音频文件格式。
 
AMR,全称是:Adaptive Multi-Rate,自适应多速率,是一种音频编码文件格式,专用于有效地压缩语音频率。
 
AMR音频主要用于移动设备的音频压缩,压缩比非常高,但是音质比较差,主要用于语音类的音频压缩,不适合对音质要求较高的音乐类音频的压缩。
 
AMR的编解码是基于“3GPP AMR Floating-point Speech Codec”来做的,3GPP还专门开放了基于ANSI-C实现的编解码代码,便于我们在各种平台上进行移植。
 
#ifndef amrFileCodec_h
#define amrFileCodec_h
 
#define AMR_MAGIC_NUMBER "#!AMR\n"
 
#define PCM_FRAME_SIZE 160 // 8khz 8000*0.02=160
#define MAX_AMR_FRAME_SIZE 32
#define AMR_FRAME_COUNT_PER_SECOND 50
//int amrEncodeMode[] = {4750, 5150, 5900, 6700, 7400, 7950, 10200, 12200}; // amr 编码方式
 
typedef struct
{
         char chChunkID[4];
         int nChunkSize;
}XCHUNKHEADER;
 
typedef struct
{
         short nFormatTag;
         short nChannels;
         int nSamplesPerSec;
         int nAvgBytesPerSec;
         short nBlockAlign;
         short nBitsPerSample;
}WAVEFORMAT;
 
typedef struct
{
         short nFormatTag;
         short nChannels;
         int nSamplesPerSec;
         int nAvgBytesPerSec;
         short nBlockAlign;
         short nBitsPerSample;
         short nExSize;
}WAVEFORMATX;
 
typedef struct
{
         char chRiffID[4];
         int nRiffSize;
         char chRiffFormat[4];
}RIFFHEADER;
 
typedef struct
{
         char chFmtID[4];
         int nFmtSize;
         WAVEFORMAT wf;
}FMTBLOCK;
 
// WAVE音频采样频率是8khz
// 音频样本单元数 = 8000*0.02 = 160 (由采样频率决定)
// 声道数 1 : 160
//        2 : 160*2 = 320
// bps决定样本(sample)大小
// bps = 8 --> 8位 unsigned char
//       16 --> 16位 unsigned short
int EncodeWAVEFileToAMRFile(const char* pchWAVEFilename, const char* pchAMRFileName, int nChannels, int nBitsPerSample);
 
// 将AMR文件解码成WAVE文件
int DecodeAMRFileToWAVEFile(const char* pchAMRFileName, const char* pchWAVEFilename);
 
#endif
 


2.        AMR编码
3GPP提供了编码代码,并提供了一个encoder.c程序,该程序示范了如何对一个16位的单声道PCM数据进行压缩的。(采样频率必须是8khz)
 
我对该程序进行一定的拓展,数据位支持8位和16位,可以是单声道和双声道。
 
l         对于8位PCM只需要将每个采样的sample数据位扩展成16位,并左移7位。
l         对于双声道,可以只对左声道数据进行处理,也可以只对右声道数据进行处理,或者将左右声道数据求平均值就可。
 
这样两个小处理,就可以将PCM规范成3PGG的编码器需要的数据格式。
 
代码在 amrFileEncoder.c 中。
 
#include "amrFileCodec.h"
 
// 从WAVE文件中跳过WAVE文件头,直接到PCM音频数据
void SkipToPCMAudioData(FILE* fpwave)
{
         RIFFHEADER riff;
         FMTBLOCK fmt;
         XCHUNKHEADER chunk;
         WAVEFORMATX wfx;
         int bDataBlock = 0;
 
         // 1. 读RIFF头
         fread(&riff, 1, sizeof(RIFFHEADER), fpwave);
 
         // 2. 读FMT块 - 如果 fmt.nFmtSize>16 说明需要还有一个附属大小没有读
         fread(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
         if ( chunk.nChunkSize>16 )
         {
                   fread(&wfx, 1, sizeof(WAVEFORMATX), fpwave);
         }
         else
         {
                   memcpy(fmt.chFmtID, chunk.chChunkID, 4);
                   fmt.nFmtSize = chunk.nChunkSize;
                   fread(&fmt.wf, 1, sizeof(WAVEFORMAT), fpwave);
         }
 
         // 3.转到data块 - 有些还有fact块等。
         while(!bDataBlock)
         {
                   fread(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
                   if ( !memcmp(chunk.chChunkID, "data", 4) )
                   {
                            bDataBlock = 1;
                            break;
                   }
                   // 因为这个不是data块,就跳过块数据
                   fseek(fpwave, chunk.nChunkSize, SEEK_CUR);
         }
}
 
// 从WAVE文件读一个完整的PCM音频帧
// 返回值: 0-错误 >0: 完整帧大小
int ReadPCMFrame(short speech[], FILE* fpwave, int nChannels, int nBitsPerSample)
{
         int nRead = 0;
         int x = 0, y=0;
         unsigned short ush1=0, ush2=0, ush=0;
 
         // 原始PCM音频帧数据
         unsigned char pcmFrame_8b1[PCM_FRAME_SIZE];
         unsigned char pcmFrame_8b2[PCM_FRAME_SIZE<<1];
         unsigned short pcmFrame_16b1[PCM_FRAME_SIZE];
         unsigned short pcmFrame_16b2[PCM_FRAME_SIZE<<1];
 
         if (nBitsPerSample==8 && nChannels==1)
         {
                   nRead = fread(pcmFrame_8b1, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for(x=0; x<PCM_FRAME_SIZE; x++)
                   {
                            speech[x] =(short)((short)pcmFrame_8b1[x] << 7);
                   }
         }
         else
         if (nBitsPerSample==8 && nChannels==2)
         {
                   nRead = fread(pcmFrame_8b2, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for( x=0, y=0; y<PCM_FRAME_SIZE; y++,x+=2 )
                   {
                            // 1 - 取两个声道之左声道
                            speech[y] =(short)((short)pcmFrame_8b2[x+0] << 7);
                            // 2 - 取两个声道之右声道
                            //speech[y] =(short)((short)pcmFrame_8b2[x+1] << 7);
                            // 3 - 取两个声道的平均值
                            //ush1 = (short)pcmFrame_8b2[x+0];
                            //ush2 = (short)pcmFrame_8b2[x+1];
                            //ush = (ush1 + ush2) >> 1;
                            //speech[y] = (short)((short)ush << 7);
                   }
         }
         else
         if (nBitsPerSample==16 && nChannels==1)
         {
                   nRead = fread(pcmFrame_16b1, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for(x=0; x<PCM_FRAME_SIZE; x++)
                   {
                            speech[x] = (short)pcmFrame_16b1[x+0];
                   }
         }
         else
         if (nBitsPerSample==16 && nChannels==2)
         {
                   nRead = fread(pcmFrame_16b2, (nBitsPerSample/8), PCM_FRAME_SIZE*nChannels, fpwave);
                   for( x=0, y=0; y<PCM_FRAME_SIZE; y++,x+=2 )
                   {
                            //speech[y] = (short)pcmFrame_16b2[x+0];
                            speech[y] = (short)((int)((int)pcmFrame_16b2[x+0] + (int)pcmFrame_16b2[x+1])) >> 1;
                   }
         }
 
         // 如果读到的数据不是一个完整的PCM帧, 就返回0
         if (nRead<PCM_FRAME_SIZE*nChannels) return 0;
 
         return nRead;
}
 
// WAVE音频采样频率是8khz
// 音频样本单元数 = 8000*0.02 = 160 (由采样频率决定)
// 声道数 1 : 160
//        2 : 160*2 = 320
// bps决定样本(sample)大小
// bps = 8 --> 8位 unsigned char
//       16 --> 16位 unsigned short
int EncodeWAVEFileToAMRFile(const char* pchWAVEFilename, const char* pchAMRFileName, int nChannels, int nBitsPerSample)
{
         FILE* fpwave;
         FILE* fpamr;
 
         /* input speech vector */
         short speech[160];
 
         /* counters */
         int byte_counter, frames = 0, bytes = 0;
 
         /* pointer to encoder state structure */
         int *enstate;
        
         /* requested mode */
         enum Mode req_mode = MR122;
         int dtx = 0;
 
         /* bitstream filetype */
         unsigned char amrFrame[MAX_AMR_FRAME_SIZE];
 
         fpwave = fopen(pchWAVEFilename, "rb");
         if (fpwave == NULL)
         {
                   return 0;
         }
 
         // 创建并初始化amr文件
         fpamr = fopen(pchAMRFileName, "wb");
         if (fpamr == NULL)
         {
                   fclose(fpwave);
                   return 0;
         }
         /* write magic number to indicate single channel AMR file storage format */
         bytes = fwrite(AMR_MAGIC_NUMBER, sizeof(char), strlen(AMR_MAGIC_NUMBER), fpamr);
 
         /* skip to pcm audio data*/
         SkipToPCMAudioData(fpwave);
 
         enstate = Encoder_Interface_init(dtx);
 
         while(1)
         {
                   // read one pcm frame
                   if (!ReadPCMFrame(speech, fpwave, nChannels, nBitsPerSample)) break;
 
                   frames++;
 
                   /* call encoder */
                   byte_counter = Encoder_Interface_Encode(enstate, req_mode, speech, amrFrame, 0);
 
                   bytes += byte_counter;
                   fwrite(amrFrame, sizeof (unsigned char), byte_counter, fpamr );
         }
 
         Encoder_Interface_exit(enstate);
 
         fclose(fpamr);
         fclose(fpwave);
 
         return frames;
}


3.      AMR解码
3GPP提供了解码代码,并提供了一个decoder.c程序,该程序示范了如何对amr音频进行解码。解码成一个wave文件(8khz 16位单声道)。
 
解码是需要注意AMR坏帧的处理。在AMR读帧算法中有说明。
 
文件解码器代码在 amrFileDecoder.c 中。
 
#include "amrFileCodec.h"
 
void WriteWAVEFileHeader(FILE* fpwave, int nFrame)
{
         char tag[10] = "";
 
         // 1. 写RIFF头
         strcpy(tag, "RIFF");
         memcpy(riff.chRiffID, tag, 4);
         riff.nRiffSize = 4                                     // WAVE
                   + sizeof(XCHUNKHEADER)               // fmt
                   + sizeof(WAVEFORMATX)           // WAVEFORMATX
                   + sizeof(XCHUNKHEADER)               // DATA
                   + nFrame*160*sizeof(short);    //
         strcpy(tag, "WAVE");
         memcpy(riff.chRiffFormat, tag, 4);
         fwrite(&riff, 1, sizeof(RIFFHEADER), fpwave);
 
         // 2. 写FMT块
         strcpy(tag, "fmt ");
         memcpy(chunk.chChunkID, tag, 4);
         chunk.nChunkSize = sizeof(WAVEFORMATX);
         fwrite(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
         memset(&wfx, 0, sizeof(WAVEFORMATX));
         wfx.nFormatTag = 1;
         wfx.nChannels = 1; // 单声道
         wfx.nSamplesPerSec = 8000; // 8khz
         wfx.nAvgBytesPerSec = 16000;
         wfx.nBlockAlign = 2;
         wfx.nBitsPerSample = 16; // 16位
         fwrite(&wfx, 1, sizeof(WAVEFORMATX), fpwave);
 
         // 3. 写data块头
         strcpy(tag, "data");
         memcpy(chunk.chChunkID, tag, 4);
         chunk.nChunkSize = nFrame*160*sizeof(short);
         fwrite(&chunk, 1, sizeof(XCHUNKHEADER), fpwave);
}
 
const int round(const double x)
{
         return((int)(x+0.5));
}
 
// 根据帧头计算当前帧大小
int caclAMRFrameSize(unsigned char frameHeader)
{
         int mode;
         int temp1 = 0;
         int temp2 = 0;
         int frameSize;
 
         temp1 = frameHeader;
 
         // 编码方式编号 = 帧头的3-6位
         temp1 &= 0x78; // 0111-1000
         temp1 >>= 3;
 
         mode = amrEncodeMode[temp1];
 
         // 计算amr音频数据帧大小
         // 原理: amr 一帧对应20ms,那么一秒有50帧的音频数据
         temp2 = round((double)(((double)mode / (double)AMR_FRAME_COUNT_PER_SECOND) / (double)8));
 
         frameSize = round((double)temp2 + 0.5);
         return frameSize;
}
 
// 读第一个帧 - (参考帧)
// 返回值: 0-出错; 1-正确
int ReadAMRFrameFirst(FILE* fpamr, unsigned char frameBuffer[], int* stdFrameSize, unsigned char* stdFrameHeader)
{
         memset(frameBuffer, 0, sizeof(frameBuffer));
 
         // 先读帧头
         fread(stdFrameHeader, 1, sizeof(unsigned char), fpamr);
         if (feof(fpamr)) return 0;
 
         // 根据帧头计算帧大小
         *stdFrameSize = caclAMRFrameSize(*stdFrameHeader);
 
         // 读首帧
         frameBuffer[0] = *stdFrameHeader;
         fread(&(frameBuffer[1]), 1, (*stdFrameSize-1)*sizeof(unsigned char), fpamr);
         if (feof(fpamr)) return 0;
 
         return 1;
}
 
// 返回值: 0-出错; 1-正确
int ReadAMRFrame(FILE* fpamr, unsigned char frameBuffer[], int stdFrameSize, unsigned char stdFrameHeader)
{
         int bytes = 0;
         unsigned char frameHeader; // 帧头
 
         memset(frameBuffer, 0, sizeof(frameBuffer));
 
         // 读帧头
         // 如果是坏帧(不是标准帧头),则继续读下一个字节,直到读到标准帧头
         while(1)
         {
                   bytes = fread(&frameHeader, 1, sizeof(unsigned char), fpamr);
                   if (feof(fpamr)) return 0;
                   if (frameHeader == stdFrameHeader) break;
         }
 
         // 读该帧的语音数据(帧头已经读过)
         frameBuffer[0] = frameHeader;
         bytes = fread(&(frameBuffer[1]), 1, (stdFrameSize-1)*sizeof(unsigned char), fpamr);
         if (feof(fpamr)) return 0;
 
         return 1;
}
 
// 将AMR文件解码成WAVE文件
int DecodeAMRFileToWAVEFile(const char* pchAMRFileName, const char* pchWAVEFilename)
{
         FILE* fpamr = NULL;
         FILE* fpwave = NULL;
         char magic[8];
         int * destate;
         int nFrameCount = 0;
         int stdFrameSize;
         unsigned char stdFrameHeader;
 
         unsigned char amrFrame[MAX_AMR_FRAME_SIZE];
         short pcmFrame[PCM_FRAME_SIZE];
 
         fpamr = fopen(pchAMRFileName, "rb");
         if ( fpamr==NULL ) return 0;
 
         // 检查amr文件头
         fread(magic, sizeof(char), strlen(AMR_MAGIC_NUMBER), fpamr);
         if (strncmp(magic, AMR_MAGIC_NUMBER, strlen(AMR_MAGIC_NUMBER)))
         {
                   fclose(fpamr);
                   return 0;
         }
 
         // 创建并初始化WAVE文件
         fpwave = fopen(pchWAVEFilename, "wb");
         WriteWAVEFileHeader(fpwave, nFrameCount);
 
         /* init decoder */
         destate = Decoder_Interface_init();
 
         // 读第一帧 - 作为参考帧
         memset(amrFrame, 0, sizeof(amrFrame));
         memset(pcmFrame, 0, sizeof(pcmFrame));
         ReadAMRFrameFirst(fpamr, amrFrame, &stdFrameSize, &stdFrameHeader);
 
         // 解码一个AMR音频帧成PCM数据
         Decoder_Interface_Decode(destate, amrFrame, pcmFrame, 0);
         nFrameCount++;
         fwrite(pcmFrame, sizeof(short), PCM_FRAME_SIZE, fpwave);
 
         // 逐帧解码AMR并写到WAVE文件里
         while(1)
         {
                   memset(amrFrame, 0, sizeof(amrFrame));
                   memset(pcmFrame, 0, sizeof(pcmFrame));
                   if (!ReadAMRFrame(fpamr, amrFrame, stdFrameSize, stdFrameHeader)) break;
 
                   // 解码一个AMR音频帧成PCM数据 (8k-16b-单声道)
                   Decoder_Interface_Decode(destate, amrFrame, pcmFrame, 0);
                   nFrameCount++;
                   fwrite(pcmFrame, sizeof(short), PCM_FRAME_SIZE, fpwave);
         }
 
         Decoder_Interface_exit(destate);
 
         fclose(fpwave);
 
         // 重写WAVE文件头
         fpwave = fopen(pchWAVEFilename, "r+");
         WriteWAVEFileHeader(fpwave, nFrameCount);
         fclose(fpwave);
 
         return nFrameCount;
}
 


4.      AMR帧读取算法
因为可能存在异常帧,所以不一定所有的语音帧大小一致,对于跟正常帧大小不一致的,或者帧头跟正常帧头不一致的,就不交给解码器,直接抛弃该坏帧。
 
读取帧的算法,用C语言来编写,readAMRFrame.c,JAVA可以用类似的方法。
下面是算法描述流程图。
读首帧(标准帧)
ReadFirstAMRFrame
根据帧头计算标准帧的大小
caclAMRFrameSize
AMR音频文件流
读帧头(字节)
frameHeader
判断是否为坏帧?
Y
N
读本帧音频数据
帧头 + 音频数据 = 当前帧数据


5.      参考资料
l         rfc3267
http://www.rfc-editor.org/rfc/rfc3267.txt
http://ietfreport.isoc.org/rfc/PDF/rfc3267.pdf
l         3GPP TS 26.104 V 6.1.0 (2004-03)
http://www.3gpp.org/ftp/Specs/html-info/26104-CRs.htm
l         3GPP AMR Floating-point Speech Codec
http://www.3gpp.org/ftp/Specs/html-info/26104.htm
l         “amr编程汇总”
http://blog.csdn.net/windcao/archive/2006/01/04/570348.aspx
l         关于AMR文件格式的解释
http://www.mcublog.com/blog/user1/11409/archives/2006/16832.html
l         


本文来自:我爱研发网(52RD.com) 详细出处:http://www.52rd.com/bbs/Archive_Thread.asp?SID=115539&TID=2

Ios实现amr编解码

阅读数 1186

AMR2与AMR编码区别

阅读数 5472