ffmpeg 实现pcm转opus

旧城等待， 2022-09-13 04:08 635阅读 0赞

[https://blog.csdn.net/hyl999/article/details/109952644][https_blog.csdn.net_hyl999_article_details_109952644]

首先可能要重新编译ffmpeg，支持libopus，添加./configure --enable-encoder=opus --enable-encoder=libopus --enable-libopus

具体怎么编译可以自己网上查找，此次不做介绍，

代码  
PcmToOpus.h

//  
// Created by hhy on 2020/11/20.  
//  
  
\#ifndef FFMPEGTEST\_PCMTOOPUS\_H  
\#define FFMPEGTEST\_PCMTOOPUS\_H  
  
\#include <string>  
\#include <iostream>  
\#include <chrono>  
  
\#ifdef \_\_cplusplus  
extern "C" \{  
\#endif  
\#include <libavcodec/avcodec.h>  
\#include <libavformat/avformat.h>  
\#include <libavutil/frame.h>  
\#include <libavutil/mem.h>  
\#include <libavutil/opt.h>  
\#include <libavutil/channel\_layout.h>  
\#include <libavutil/samplefmt.h>  
\#include <libswresample/swresample.h>  
\#include <libavutil/frame.h>  
\#include <libavutil/mem.h>  
\#include <libswscale/swscale.h>  
  
\#ifdef \_\_cplusplus  
\}  
\#endif  
  
class PcmToOpus \{  
  
\};  
  
  
\#endif //FFMPEGTEST\_PCMTOOPUS\_H  
PcmToOpus.cpp

//  
// Created by hhy on 2020/11/20.  
//  
  
\#include "PcmToOpus.h"  
  
using namespace std;  
  
const char inPath\[\] = "./pcm.pcm";  
const char outPath\[\] = "./opus.opus";  
  
string GetError(const int &index)  
\{  
char buf\[256\] = \{0\};  
av\_strerror(index,buf,sizeof(buf));  
return string(buf);  
\}  
  
int main()  
\{  
std::cout<< "Hello" << std::endl;  
  
/// 注册环境上下文  
av\_register\_all();  
  
/// 注册编码环境  
avcodec\_register\_all();  
  
/// 查找OPUS音频编码器  
const char\* codec\_name = "libopus";  
AVCodec \*ACodec = avcodec\_find\_encoder\_by\_name(codec\_name);  
if(!ACodec)  
\{  
cout << "avcodec\_find\_decoder - faild!" << endl;  
return -1;  
\}  
  
/// 创建音频编码器上下文  
AVCodecContext \*ACodecContext = avcodec\_alloc\_context3(ACodec);  
if(!ACodecContext)  
\{  
cout << "avcodec\_alloc\_context3 - faild!" << endl;  
return -2;  
\}  
  
  
// 设置音频参数  
/// 比特率  
ACodecContext->bit\_rate = 48000;  
  
/// 采样率  
ACodecContext->sample\_rate = 48000; //opus  
  
/// 采样格式 假如源音频是AV\_SAMPLE\_FMT\_S16，则用AV\_SAMPLE\_FMT\_S16，我的pcm是AV\_SAMPLE\_FMT\_FLT  
ACodecContext->sample\_fmt = AV\_SAMPLE\_FMT\_FLT;//AV\_SAMPLE\_FMT\_S16;  
  
/// 通道数  
ACodecContext->channels = 2; //必须双通道，不然webrtc不支持  
  
/// 通道类型  
ACodecContext->channel\_layout = AV\_CH\_LAYOUT\_STEREO; //av\_get\_default\_channel\_layout(ACodecContext->channels);//  
  
  
ACodecContext->flags |= AV\_CODEC\_FLAG\_GLOBAL\_HEADER;  
  
/// 打开音频编码器  
int result = avcodec\_open2(ACodecContext, ACodec, nullptr);  
if(result != 0)  
\{  
cout << "avcodec\_open2 - faild:" << result << endl;  
return -3;  
\}  
  
/// 打开音频输出封装上下文  
AVFormatContext \*AFormatContext = nullptr;  
result = avformat\_alloc\_output\_context2(&AFormatContext, nullptr, nullptr, outPath);  
if(result < 0)  
\{  
cout << "avformat\_alloc\_output\_context2 - faild:" << result << endl;  
return -4;  
\}  
  
/// 创建音频输出流  
//AVStream \*AStream = avformat\_new\_stream(AFormatContext,ACodec);  
AVStream \*AStream = avformat\_new\_stream(AFormatContext,nullptr);  
if(!AStream)  
\{  
cout << "avformat\_new\_stream - faild!" << endl;  
return -5;  
\}  
  
/// 音频流媒体附加信息  
AStream->codecpar->codec\_tag = 0;  
  
/// 音频流信息拷贝  
result = avcodec\_parameters\_from\_context(AStream->codecpar, ACodecContext);  
if(result < 0)  
\{  
cout << "avcodec\_parameters\_from\_context - faild:" << GetError(result) << endl;  
return -5;  
\}  
  
/// 打印信息  
av\_dump\_format(AFormatContext, 0, outPath, 1);  
  
// 打开io,写入头信息  
result = avio\_open(&AFormatContext->pb, outPath, AVIO\_FLAG\_WRITE);  
if(result < 0)  
\{  
cout << "avio\_open - faild:" << GetError(result) << endl;  
return -6;  
\}  
  
  
//pcm Stream \#0:0: Audio: pcm\_f32le, 44100 Hz, 2 channels, flt, 2822 kb/s  
/// 创建音频重采样上下文  
SwrContext \*ASwrContext = nullptr;  
ASwrContext = swr\_alloc\_set\_opts(NULL,  
ACodecContext->channel\_layout,  
ACodecContext->sample\_fmt,  
ACodecContext->sample\_rate,  
ACodecContext->channel\_layout,  
AV\_SAMPLE\_FMT\_FLT, //注：输入源音频的类型  
44100,//注：输入源音频的采样率  
0, 0);  
if(!ASwrContext)  
\{  
cout << "swr\_alloc\_set\_opts - faild:" << endl;  
return -8;  
\}  
  
/// 音频重采样初始化  
result = swr\_init(ASwrContext);  
if(result < 0)  
\{  
cout << "swr\_init - faild:" << GetError(result) << endl;  
return -9;  
\}  
  
  
/// 获取输入音频转码的数据大小，假如输入是实时流，接受的每帧音频不够readSize大小的话，需要收到readSize再编码，我这里是直接读取pcm文件，可以从文件直接读取readSize的大小  
int readSize = ACodecContext->channels \* ACodecContext->frame\_size \* av\_get\_bytes\_per\_sample(ACodecContext->sample\_fmt);//AFrame->nb\_samples \* 2 \* 2;  
//int readSize = av\_samples\_get\_buffer\_size(NULL, ACodecContext->channels, AFrame->nb\_samples, ACodecContext->sample\_fmt, 1);  
  
char \*pcm = new char\[readSize+1\];  
FILE \*fp = fopen(inPath,"rb");  
if(!fp)  
\{  
cout << "fopen inPath - faild!" << endl;  
return -10;  
\}  
int k = 1;  
  
  
/// 写入头信息，必须编码器初始化好后调用，不然出现意想不到的错误  
result = avformat\_write\_header(AFormatContext, nullptr);  
if(result == AVSTREAM\_INIT\_IN\_INIT\_OUTPUT)  
\{  
cout << "2 avformat\_write\_header - faild:" << GetError(result) << endl;  
return -7;  
\}  
  
while(1)  
\{  
int len = fread(pcm,1,readSize,fp);  
if(len <= 0)  
\{  
break;  
\}  
  
AFrame->format = ACodecContext->sample\_fmt;//AV\_SAMPLE\_FMT\_S16;  
AFrame->channel\_layout = ACodecContext->channel\_layout;//av\_get\_default\_channel\_layout(ACodecContext->channels);//  
AFrame->nb\_samples = ACodecContext->frame\_size; //1024; // 一帧音频存放的样本数量  
AFrame->sample\_rate = ACodecContext->sample\_rate;//采样率  
AFrame->pts = 960\*k;//时间戳，必须写上，不然下面AFrame->extended\_data不正确  
result = av\_frame\_get\_buffer(AFrame,0); // 创建音频输出空间  
if(result < 0)  
\{  
cout << "av\_frame\_get\_buffer - faild:" << GetError(result) << endl;  
return -9;  
\}  
  
/// 转换音频  
const uint8\_t \*data\[1\];  
data\[0\] = (uint8\_t \*)pcm;  
len = swr\_convert(ASwrContext,  
AFrame->extended\_data,  
AFrame->nb\_samples,  
data,  
AFrame->nb\_samples);  
if(len <= 0)  
\{  
break;  
\}  
  
/// 音频编码  
AVPacket APacket;  
av\_init\_packet(&APacket);  
result = avcodec\_send\_frame(ACodecContext, AFrame);  
if(result != 0)  
\{  
cout << "avcodec\_send\_frame - faild:" << GetError(result) << endl;  
continue;  
\}  
result = avcodec\_receive\_packet(ACodecContext, &APacket);  
if(result != 0)  
\{  
cout << "avcodec\_receive\_packet - faild:" << GetError(result) << endl;  
continue;  
\}  
  
/// 音频封装入opus  
APacket.stream\_index = 0;  
APacket.dts = 0;  
k++;  
cout << "APacket.pts:" << APacket.pts << endl;  
result = av\_interleaved\_write\_frame(AFormatContext, &APacket);  
if(result != 0)  
\{  
cout << "av\_interleaved\_write\_frame - faild:" << GetError(result) << endl;  
continue;  
\}  
\}  
delete pcm;  
pcm = nullptr;  
  
fclose(fp);  
  
/// 写入视频索引  
av\_write\_trailer(AFormatContext);  
  
/// 关闭视频索引  
avio\_close(AFormatContext->pb);  
  
/// 清理 - 音频封装上下文  
avformat\_free\_context(AFormatContext);  
  
/// 关闭编码器  
avcodec\_close(ACodecContext);  
  
/// 清理编码器上下文  
avcodec\_free\_context(&ACodecContext);  
  
  
return 0;  
\}  
  
注意:  
1.ffmpeg需要支持opus，我用的是ffmpeg4.3.1

2. opus采样率必须是：8000、12000、16000、24000、或48000

3. opus必须双通道，不然webrtc不支持

4. 采样格式可以是：AV\_SAMPLE\_FMT\_S16，AV\_SAMPLE\_FMT\_FLT，需要看输入源是什么格式做选择

5. 获取输入音频编码的数据大小，假如输入是实时流，接受的每帧音频不够readSize大小的话，需要收到readSize大小的数据再送去编码，直接读取pcm文件可以不要这么考虑，pcm转aac也是这样的，需要注意

6. 假如是保存成opus文件格式，需要写入头信息，必须编码器初始化好后调用写入头函数，不然出现意想不到的错误。

7. 假如是aac转opus，需要先将aac转pcm在编码opus，可以用ffmpeg命令aac转opus先测试下：

ffmpeg -i output.aac -acodec libopus -ac 2 -ar 48000 testopus.ogg

————————————————  
版权声明：本文为CSDN博主「hhy980205」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/hyl999/article/details/109952644

[https_blog.csdn.net_hyl999_article_details_109952644]: https://blog.csdn.net/hyl999/article/details/109952644