• libopus 实现pcm 编码到opus

    opus 是一种音频格式，常用于语音通话、视频会议中。最近做了个pcm 到opus 的编码，踩了不少坑，特此记录一下。

    目录

    1、基础知识

    2、使用流程

    2.1 创建编码器

    2.2 编码器配置

    2.3 进行编码

    2.4 完整代码

    3、结果验证

    4、参考资料

    1、基础知识

    opus 支持2.5、5、10、20、40、60ms 等帧长，对于一个48000khz 的 16bit，双通道，20 ms 的pcm 音频来说，每ms 样本数为 48000/1000 = 48，采用位深为16bit/8 = 2byte，所以需要的pcm 字节数为

       pcm size = 48 样本/ms  X 20ms X 2byte X 2 channel = 3840 byte

     对于采样为16 bit 的2声道的PCM 数据来说，其内存布局如下图所示

    LLLL LLLL LLLL LLLL RRRR RRRR RRRR RRRR

     opus 编码函数是 opus_encode，其输入数组是 opus_int16 数组，2字节，要进行unsigned char 数组到 opus_int16 数组的转换后才能送入编码器。

    2、使用流程

    2.1 创建编码器

    1. OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusEncoder *opus_encoder_create(
    2.     opus_int32 Fs,
    3.     int channels,
    4.     int application,
    5.     int *error
    6. );

    fs：采样率，8000，12000，16000，24000，48000 之一

    channels：通道数

    application：编码模式，有三种：

     OPUS_APPLICATION_VOIP：对语音信号进行处理，适用于voip 业务场景

     OPUS_APPLICATION_AUDIO：这个模式适用于音乐类型等非语音内容

     OPUS_APPLICATION_RESTRICTED_LOWDELAY：低延迟模式

    error ：编码返回值

    2.2 编码器配置

    opus_encoder_ctl(OpusEncoder *st, int request, ...)

     st：opus_encoder_create 创建的结构体

     request：宏定义的配置参数

     典型配置

    1.     opus_encoder_ctl(encoder, OPUS_SET_VBR(0));//0:CBR, 1:VBR
    2.     opus_encoder_ctl(encoder, OPUS_SET_VBR_CONSTRAINT(true));
    3.     opus_encoder_ctl(encoder, OPUS_SET_BITRATE(96000));
    4.     opus_encoder_ctl(encoder, OPUS_SET_COMPLEXITY(8));//8    0~10
    5.     opus_encoder_ctl(encoder, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE));
    6.     opus_encoder_ctl(encoder, OPUS_SET_LSB_DEPTH(16));//每个采样16个bit，2个byte
    7.     opus_encoder_ctl(encoder, OPUS_SET_DTX(0));
    8.     opus_encoder_ctl(encoder, OPUS_SET_INBAND_FEC(0));

    2.3 进行编码

    1. OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode(
    2.     OpusEncoder *st,
    3.     const opus_int16 *pcm,
    4.     int frame_size,
    5.     unsigned char *data,
    6.     opus_int32 max_data_bytes
    7. )

    st：opus编码器实例

    pcm：输入的pcm 数据，双通道的话数据交叉存储，大小为 frame_size x channels x sizeof(ipus_int16)。

    frme_size：每个通道中输入音频信号的样本数，这里不是传pcm 数组大小，比如采用的是 48000 hz 编码，20ms 帧长，那么frame_size 应该是48*2 = 960，pcm 分配大小= frame_size x channels x sizeof(ipus_int16)。

    data：输出缓冲区，接收编码后的数据

    max_data_bytes：输出缓冲区大小

    返回值：实际编码后输出数据大小

    2.4 完整代码

    base_type.h

    1.  
    2. #ifndef __BASE_TYPE_H__
    3. #define __BASE_TYPE_H__
    4. typedef struct StreamInfo
    5. {
    6.     unsigned char *data;
    7.     int len;
    8.     int dts;
    9. }StreamInfo;
    10.  
    11. #endif

    OpusEncoderImpl.h

    1.  
    2. #ifndef __OPUSENCODERIMPL_H
    3. #define __OPUSENCODERIMPL_H 
    4. #include "include/opus/opus.h"
    5. #include 
    6. #include 
    7. #include "base_type.h"
    8. #include 
    9. #include 
    10.  
    11.  
    12. class OpusEncoderImpl
    13. {
    14. private:
    15.    OpusEncoder *encoder;
    16.    const int channel_num;
    17.    int sample_rate;
    18.    std::queue info_queue;
    19.    std::queue <unsigned char> pcm_queue;
    20.    std::mutex mutex;
    21.    bool isRuning = true;
    22.    std::mutex access_mutex;
    23.    std::unique_ptr m_thread;
    24. public:
    25.     OpusEncoderImpl(int sampleRate, int channel);
    26.     void Feed(unsigned char*data, int len);
    27.     bool PopFrame(StreamInfo &info);
    28.     void EncodeRun();
    29.     void Stop();
    30.     ~OpusEncoderImpl();
    31. };

    OpusEncoderImpl.cpp

    1. #include "OpusEncoderImpl.h"
    2. #include "OpusDecoderImpl.h"
    3. #include 
    4. #include 
    5. #define MAX_PACKET_SIZE 3*1276
    6.  
    7. /*
    8. * sampleRate:采样率
    9. * channel：通道数
    10. */
    11.  
    12. OpusEncoderImpl::OpusEncoderImpl(int sampleRate, int channel):channel_num(channel),sample_rate(sampleRate)
    13.  {
    14.     int err;
    15.     int applications[3] = {OPUS_APPLICATION_AUDIO, OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY};
    16.    
    17.     encoder = opus_encoder_create(sampleRate, channel_num, applications[1], &err);
    18.  
    19.     if(err != OPUS_OK || encoder == NULL) {
    20.         printf("打开opus 编码器失败\n");
    21.     }
    22.  
    23.     opus_encoder_ctl(encoder, OPUS_SET_VBR(0));//0:CBR, 1:VBR
    24.     opus_encoder_ctl(encoder, OPUS_SET_VBR_CONSTRAINT(true));
    25.     opus_encoder_ctl(encoder, OPUS_SET_BITRATE(96000));
    26.     opus_encoder_ctl(encoder, OPUS_SET_COMPLEXITY(8));//8    0~10
    27.     opus_encoder_ctl(encoder, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE));
    28.     opus_encoder_ctl(encoder, OPUS_SET_LSB_DEPTH(16));//每个采样16个bit，2个byte
    29.     opus_encoder_ctl(encoder, OPUS_SET_DTX(0));
    30.     opus_encoder_ctl(encoder, OPUS_SET_INBAND_FEC(0));
    31.  
    32.     EncodeRun();
    33. }
    34. //每一帧pcm 是23ms
    35. void OpusEncoderImpl::Feed(unsigned char *data, int len) {
    36.     mutex.lock();
    37.     for(auto i = 0;i < len;i++) {
    38.         pcm_queue.emplace(data[i]);
    39.     }
    40.     mutex.unlock();
    41. }
    42.  
    43. bool OpusEncoderImpl::PopFrame(StreamInfo &info) {
    44.     if(info_queue.size() > 0) {
    45.         access_mutex.lock();
    46.         info = info_queue.front();
    47.         info_queue.pop();
    48.         access_mutex.unlock();
    49.         return true;
    50.     }
    51.  
    52.     return false;
    53. }
    54.  
    55.  
    56. //48000 采样率，48个样本/ms * 20ms * 2 channel = 1920
    57. void OpusEncoderImpl::EncodeRun() {
    58.     m_thread = std::make_unique([this](){
    59.         const int frame_size = 48*20;//960
    60.         const int input_len = sizeof(opus_int16) * frame_size * 2;
    61.  
    62.         FILE *opus_file = fopen("/data/bin/out.customopus", "wb+");
    63.         FILE *pcm_file = fopen("/data/bin/out.pcm", "wb+");
    64.         OpusDecoderImpl decoder(48000, channel_num);
    65.  
    66.         opus_int16 input_data[frame_size * 2] = {0};//frame_size*channels*sizeof(opus_int16)
    67.         unsigned char input_buffer[input_len] = {0};//每一帧的数据量
    68.         unsigned char out_data[MAX_PACKET_SIZE] = {0};
    69.         
    70.         while (isRuning) {   
    71.             if(pcm_queue.size() >= input_len) {
    72.                 mutex.lock();              
    73.                 for(int i = 0;i < input_len;i++) 
    74.                 {
    75.                     input_buffer[i] = pcm_queue.front();
    76.                     pcm_queue.pop();
    77.                 }
    78.  
    79.                 // for (size_t i = 0; i < frame_size * channel_num; i++)
    80.                 // {
    81.                 //     input_data[i] = input_buffer[2*i + 1] << 8 | input_buffer[2*i];
    82.                 // }
    83.  
    84.                 mutex.unlock();
    85.                 memcpy(input_data, input_buffer, input_len);
    86.                 // fwrite(input_buffer, 1, input_len, pcm_file);
    87.                 // fflush(pcm_file);          
    88.                 auto ret = opus_encode(encoder, input_data, frame_size, out_data, MAX_PACKET_SIZE);
    89.                 if(ret < 0) {
    90.                     printf("opus编码失败, %d\n", ret);
    91.                     break;
    92.                 }
    93.  
    94.                 //写入文件
    95.                 // uint32_t len = static_cast(ret);
    96.                 // fwrite(&len, 1, sizeof(uint32_t), opus_file);
    97.                 //fwrite(out_data, 1, ret, opus_file);              
    98.                 //fflush(opus_file);             
    99.                 unsigned char* opus_buffer = (unsigned char*)malloc(ret);
    100.                 memcpy(opus_buffer, out_data, ret);
    101.                 //decoder.Decode(opus_buffer, ret);
    102.  
    103.                 StreamInfo info;
    104.                 info.data = opus_buffer;
    105.                 info.len = ret;
    106.                 info.dts = 20;
    107.                 access_mutex.lock();             
    108.                 info_queue.push(info);
    109.                 access_mutex.unlock();                      
    110.                 
    111.             }else {
    112.                 usleep(1000);
    113.             }  
    114.         } 
    115.     });
    116.  
    117. }
    118.  
    119. void OpusEncoderImpl::Stop() {
    120.     isRuning = false;
    121.     m_thread->join();
    122.  
    123.     while (pcm_queue.size() > 0)
    124.     {
    125.         pcm_queue.pop();
    126.     }
    127.  
    128.     opus_encoder_destroy(encoder);
    129.     
    130. }
    131.  
    132. OpusEncoderImpl::~OpusEncoderImpl() {
    133.  
    134. }

    3、结果验证

    验证方法一是将编码后的文件打包成ogg，或者将编码后的数据再解码成pcm，用audacity 查看，这里是采用的是后者。

    OpusDecoderImpl.h

    1.  
    2. #ifndef __OPUSDECODERIMPL_H
    3. #define __OPUSDECODERIMPL_H
    4. #include 
    5. #include "include/opus/opus.h"
    6. #include 
    7. #include 
    8. #include "base_type.h"
    9. #include 
    10. #include 
    11.  
    12. class OpusDecoderImpl
    13. {
    14. private:
    15.     /* data */
    16.     OpusDecoder *decoder;
    17.     int sample_rate;
    18.     int channel_num;
    19.     FILE *pcm_file;
    20. public:
    21.     bool Decode(unsigned char* in_data, int len);
    22.     OpusDecoderImpl(int sampleRate, int channel);
    23.     ~OpusDecoderImpl();
    24. };
    25.  
    26. #endif

    OpusDecoderImpl.cpp

    1. #include "OpusDecoderImpl.h"
    2. #define MAX_FRAME_SIZE 6*960
    3. #define CHANNELS 2
    4.  
    5. OpusDecoderImpl::OpusDecoderImpl(int sampleRate, int channel) 
    6. {
    7.     int err;
    8.     decoder = opus_decoder_create(sampleRate, channel, &err);
    9.     opus_decoder_ctl(decoder, OPUS_SET_LSB_DEPTH(16));
    10.     sample_rate = sample_rate;
    11.     channel_num = channel;
    12.     if(err < 0 || decoder == NULL)
    13.     {
    14.         printf("创建解码器失败\n");
    15.         return;
    16.     }
    17.  
    18.     pcm_file = fopen("/data/bin/decode.pcm", "wb+");
    19. }
    20.  
    21. bool OpusDecoderImpl::Decode(unsigned char* in_data, int len)
    22. {
    23.     unsigned char pcm_bytes[MAX_FRAME_SIZE * CHANNELS * 2];
    24.     opus_int16 out[MAX_FRAME_SIZE * CHANNELS];
    25.     auto frame_size = opus_decode(decoder, in_data, len, out, MAX_FRAME_SIZE, 0);
    26.  
    27.     if (frame_size < 0)
    28.     {
    29.        printf("解码失败\n");
    30.        return false;
    31.     }
    32.  
    33.     for (auto i = 0; i < channel_num * frame_size; i++)
    34.     {
    35.         pcm_bytes[2 * i] = out[i] & 0xFF;
    36.         pcm_bytes[2 * i + 1] = (out[i] >> 8) & 0xFF;
    37.     }
    38.  
    39.     fwrite(pcm_bytes, sizeof(short), frame_size * channel_num, pcm_file);
    40.     fflush(pcm_file);
    41.     return true;
    42. }
    43.  
    44. OpusDecoderImpl::~OpusDecoderImpl()
    45. {
    46.  
    47. }

    补上函数调用(ps：代码可能会有语法错误，请自行解决)

    1. int main(int argc, char** argc)
    2. {
    3.     OpusEncoderImpl opusEncoder = new OpusEncoderImpl(48000, 2);
    4.  
    5.     for (size_t i = 0; i < 100; i++)
    6.     {
    7.         opusEncoder.Feed(pcm_data, pcm_len);//送pcm 数据编码
    8.     }
    9.  
    10.     //读取编码后的opus，一般放在单独线程，这里只是为了方便
    11.     StreamInfo info;
    12.     while (opusEncoder.PopFrame(info))
    13.     {
    14.         .....
    15.     }
    16.     
    17.     opusEncoder.Stop();
    18.     
    19. }

    4、参考资料

    音频和OPUS开源库简介_WuYuJun's blog的博客-CSDN博客_opus库

    音视频编解码--Opus编解码系列1_Fenngtun的博客-CSDN博客

    Qt 之 opus编码_老菜鸟的每一天的博客-CSDN博客_opus编码

      

  • 相关阅读:
    深入探讨AJAX接口进度监控：实现步骤、代码示例与技术原理
    Apache Doris 系列： 基础篇-Flink DataStream 读写Doris
    [mtk6771] Android13 修改蓝牙默认名称
    【SSM框架】Mybatis详解03（案例源码文末自取）
    入门力扣自学笔记120 C++ （题目编号1417）
    网络安全（黑客技术）—小白自学笔记
    log4j2安全漏洞修复
    90、网络硬件一文通
    索引的优化
    vue3的watch、computed写法及扩展（ 对比vue2）
  • 原文地址：https://blog.csdn.net/sinat_27720649/article/details/126530085