AMR音频编解码

最新推荐文章于 2015-12-11 08:33:02 发布
最新推荐文章于 2015-12-11 08:33:02 发布
阅读量4.7k 收藏 6
点赞数
文章标签： interface file struct 算法 null byte
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinlking/article/details/3721585
版权
http://blog.csdn.net/dinggo/archive/2007/12/29/2002298.aspx

AMR音频编解码
<script>function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.getSelection?d.getSelection():'');void(keyit=window.open('http://www.365key.com/storeit.aspx?t='+escape(d.title)+'&u='+escape(d.location.href)+'&c='+escape(t),'keyit','scrollbars=no,width=475,height=575,left=75,top=20,status=no,resizable=yes'));keyit.focus();}</script>  
目录
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         对于 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;
}

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
读本帧音频数据
帧头 + 音频数据 = 当前帧数据
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 


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         

jinlking
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
amr国际音频编解码实现源码（Qt工程）
09-12
2. **文件读写模块**：为了存储和加载AMR音频，源码可能包含了读取和写入AMR文件的函数。AMR文件的格式基于RTP（Real-time Transport Protocol）头，因此需要正确解析和构造这些头信息。 3. **Qt集成**：这部分代码...
AMR解码编程(C++直接用opencore-amr-0.1.3库)
zyx4843的专栏
02-18 3312
先定义每种帧的大小数组 const int sizes[] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 6, 5, 5, 0, 0, 0, 0 }; 初始化解码器 void *m_pAmr = Decoder_Interface_init(); 判断文件头，去掉文件头，读取第一个帧头，以第一个帧头为标准，后面用于判断坏帧 if (0 == mem
AMR编解码程序
12-27
3GPP官网发布的AMR编解码程序的C代码
[转]AMR音频编解码
weixin_34061042的博客
06-19 520
目录1.    概述2.    AMR编码3.    AMR解码4.    AMR帧读取算法5.    参考资料  1.      概述现在很多智能手机都支持多媒体功能，特别是音频和视频播放功能，而AMR文件格式是手机端普遍支持的音频文件格式。 AMR，全称是：Adaptive Multi-Rate，自适应多速率，是一种音频编码文件格式，专用于有效地压缩语音频率。 AMR音频主要用于移...
【原】AMR音频解码插件开发总结
weixin_30408309的博客
07-28 98
近段时间一直在忙碌AMR音频解码插件的开发，由于对驱动开发和音频编解码知识了解不是很多，加之自身经验欠缺，致使开发过程中碰到太多棘手的问题。经过努力学习和领导的大力帮助下终于完成了插件的开发，现将开发过程中得来的经验总结下来，为近段时间自己学来的东西理个头绪，也为今后有类似开发的朋友一个参考。 AMR解码插件开发之环境配置 本文开发此插件是在Windows XP环境下进行，需要安装Win...
Android amr语音编解码解惑
jinvasshole
11-28 225
关于android中的语音压缩编码，今天算是好好的研究了一下，有了小小的心得:首先关于采集到得声音源的格式是PCM-16bit的格式，什么是PCM格式，大家看下面的这篇文章:http://blog.csdn.net/tkboy/archive/2009/12/19/5038947.aspxPCM就是无压缩的声音源，PCM信号是由[1]、[0]等符号构成的数字信号，android设备采取的声音源也就...
amr-SPEECH.rar_amr_语音编解码_语音解码
09-21
用户可以通过调用这些接口，实现对AMR音频文件的编码和解码操作，以便在自己的应用程序中使用AMR格式的语音数据。 在实际应用中，AMR编解码技术不仅用于移动通信，还广泛应用于语音记录、语音识别、VoIP（Voice ...
delphi实现amr音频文件解码
03-26
这是一个完整的delphi单元文件，实现amr语音文件转换为wav文件，amr窄带和宽带二种格式都支持。
3GPP中AMR编解码C源码和协议 （可用于微信语音聊天软件编解码）
02-26
3gpp官方的amr编解码C源码和协议 可用于嵌入式微信语音聊天等，软件编解码
amr编解码C代码，附有3GPP格式说明方档
06-05
amr编解码C代码，附有3GPP格式说明方档，并有相关应用说明
amr音频文件
08-24
可用于音频转换测试，该音频头文件码为amr，希望能帮到你。
Amr语音编解码最新2015年C代码
12-09
当前最新C代码，里面包含了测试代码，可以直接VS编译DLL，PC版通过，移动版本未测试
AMR格式解码
09-18
AMR解码 解码出来的数据为原始的PCM数据
AMR 文件解析及编解码流程
xiangjai的专栏
10-22 3052
CONTENT:         ＊  AMR简介          ＊ AMR 话音质量评定           ＊ AMR 文件结构解析            ＊ AMR 帧结构解析             ＊ AMR 帧读取算法              ＊ AMR 解码原理及流程               ＊ AMR 模式选择自适应机制               一、A
音频实时传输和播放AMR硬编码与硬解码
EricFantastic
12-11 4412
在Android中我所知道的音频编解码有两种方式： （一）使用AudioRecord采集音频，用这种方式采集的是未经压缩的音频流；用AudioTrack播放实时音频流。用这两个类的话，如果需要对音频进行编解码，就需要自己移植编解码库了，比如可以移植ilbc，speex等开源编解码库。  ilbc的编解码实现可以查看这个专栏：http://blog.csdn.net/column/details
AMR 编码方式列表
北方大冬瓜的博客
08-24 3283
因为需要编写某手机平台上的语音拨号软件，需要先解码 AMR 文件，下面先列出 AMR 编码方式，这对应 Speech Frame 中的 FT 标志位（共 4 Bits）：Mode 0 - AMR 4.75 - Encodes at 4.75kbit/sMode 1 - AMR 5.15 - Encodes at 5.15kbit/sMode 2 - AMR 5.9 - Encodes at 5.9
amr编码
JachHu的专栏
07-03 1910
目录 1. 概述 2. AMR编码 3. AMR解码 4. AMR帧读取算法 5. 参考资料 1. 概述 现在很多智能手机都支持多媒体功能，特别是音频和视频播放功能，而AMR文件格式是手机端普遍支持的音频文件格式。 AMR，全称是：Adaptive Multi-Rate，自适应多速率，是一种音频编码文件格式，专用于有效地压缩语音频率。 AMR音频主要用于移动设备的音频
amr编解码源码下载
最新发布
08-25
这些库提供了一些音频编解码的功能，其中也包括AMR格式的编解码功能。你可以查找并下载这些库的源代码来获得AMR编解码的实现。 总之，想要下载AMR编解码的源代码，可以通过在GitHub、SourceForge、Google Code ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值