Opus介绍及编译

https://blog.csdn.net/grandgrandpa/article/details/96438388

opus是一个有损声音编码的格式,由IETF开发,没有任何专利或限制,适用于网络上的实时声音传输,标准格式为RFC 6716,其技术来源于Skype的SILK及Xiph.Org的CELT编码

     主要特性如下:

•     6 kb /秒到510 kb / s的比特率
•     采样率从8 kHz（窄带）到48 kHz（全频）
•     帧大小从2.5毫秒到60毫秒
•     支持恒定比特率（CBR）和可变比特率（VBR）
•     从窄带到全频段的音频带宽
•     支持语音和音乐
•     支持单声道和立体声
•     支持多达255个频道（多数据流的帧）
•     可动态调节比特率，音频带宽和帧大小
•     良好的鲁棒性丢失率和数据包丢失隐藏（PLC）
•     浮点和定点实现

     基于OPUS强大的PLC能力以及良好的VOIP音质, 我们决定在我们的视频会议中引入OPUS编码,用于Android/iOS/Windows视频会议客户端,以及视频会议媒体服务器中.
 

首先需要在opus官网上下载opus相关的源码资料

http://www.opus-codec.org/

在downloads里面可以看到全部的源码下载

这里我们需要下载

opus-tools-0.2.1.tar.gz和opus-1.3.1.tar.gz

下载后可以在ubuntu里解压

然后

./configure

（如果是其余平台如Mips或Arm，需要添加 --host=（交叉编译链），在ARM和mips平台推荐使用--enable-fixed-point命令关闭浮点运算）

然后 make && make install

之后，会出现一堆供测试用的可执行文件

之前笔者犯了一个错误，就是直接用opus_demo文件对MP3和wav格式的音频进行编码，结果导致出错

1. = Compiling libopus ==

3. To build from a distribution tarball, you only need to do the following:

5. % ./configure

6. % make

8. To build from the git repository, the following steps are necessary:

10. 0) Set up a development environment:

12. On an Ubuntu or Debian family Linux distribution:

14. % sudo apt-get install git autoconf automake libtool gcc make

16. On a Fedora/Redhat based Linux:

18. % sudo dnf install git autoconf automake libtool gcc make

20. Or for older Redhat/Centos Linux releases:

22. % sudo yum install git autoconf automake libtool gcc make

24. On Apple macOS, install Xcode and brew.sh, then in the Terminal enter:

26. % brew install autoconf automake libtool

在README里面我们可以看到

input and output are little-endian signed 16-bit PCM files or opus
bitstreams with simple opus_demo proprietary framing.

所以更换了pcm格式的文件，我们便可以进行编码

编码的命令为：

./opus_demo -e voip 48000 2 128000 xxx.pcm xxx.opus

之后便生成你参数指定的opus文件

其中-e指的事编码，voip是编码格式，还有audio和restricted-lowdelay两种格式，48000是采样率，2是指双通道，128000是比特率，随后是输入文件和输出文件

这些输入./opus_demo --help都会有提示

随后我们可以对生成的opus文件解码

./opus_demo -d 48000 2  xxx.opus xxx.pcm

之后会解码生成pcm文件

当然，如果想直接将wav，flac格式的音频文件，编码成可播放的opus文件

需要使用opus_tools

同样是./configure make && install之后

然后使用

./opus_enc xxx.wav xxx.opus命令

生成的opus文件便可以播放啦

使用步骤：

1.创建opus解码器：

1. OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusDecoder *opus_decoder_create(

2. opus_int32 Fs,//采样率，可以设置的大小为8000, 12000, 16000, 24000, 48000.

3. int channels,//声道数，网络中实时音频一般为单声道

4. int *error//是否创建失败,返回0表示创建成功

5. );

2.解码：

1. OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode(

2. OpusDecoder *st, //上一步的返回值

3. const unsigned char *data,//要解码的数据

4. opus_int32 len, //数据长度

5. opus_int16 *pcm, //解码后的数据,注意是一个以16位长度为基本单位的数组

6. int frame_size, //每个声道给pcm数组的长度

7. int decode_fec //是否需要fec,设置0为不需要，1为需要

8. ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);

3.把解码数据放入字符数组中

//注意是大端传入，所以应该转为小端
//注：frameSize是上一步的返回值，即每个声道返回的以2字节为单位的数组长度
//pcm是解码后的数据，即上一步的参数4

1. char *pcmData = new char[frameSize * channels * sizeof(opus_int16)];

2. for (int i = 0; i < channels * frameSize; ++i)

3. {

4. pcmData[i * 2] = pcm[i] & 0xFF;

5. pcmData[i * 2 + 1] = (pcm[i] >> 8) & 0xFF;

6. }

4.释放解码器

OPUS_EXPORT void opus_decoder_destroy(OpusDecoder *st);

注意事项：

1.对于连续的一段声音，一定只能用一个解码器（不能创建之后释放再去创建解码器）

2.如果使用fec，那么记得要自己检查seq确认丢失再使用fec，如果每一个包都使用fec，每一个都会给你解码出来数据的

接口应用实例：

1. #include <opus_types.h>

2. #include <opus.h>

3. #include <cstring>

4. #include <memory>

6. #include <vector>

7. #define DR_WAV_IMPLEMENTATION

8. // https://github.com/mackron/dr_libs/blob/master/dr_wav.h

9. #include "dr_wav.h"

10. ／／需要dr_wav库

12. #define FRAME_SIZE 480

13. #define MAX_FRAME_SIZE (6*FRAME_SIZE)

15. #define MAX_CHANNELS 1

16. #define MAX_PACKET_SIZE (3*1276)

18. #pragma pack(push)

19. #pragma pack(1)

21. struct WavInfo {

22. uint16_t channels;

23. uint32_t sampleRate;

24. uint32_t bitsPerSample;

25. };

27. #pragma pack(pop)

29. #ifndef nullptr

30. #define nullptr NULL

31. #endif

33. class FileStream {

34. public:

35. FileStream() {

36. cur_pos = 0;

37. }

39. void Append(const char *data, size_t size) {

40. if (cur_pos + size > Size()) {

41. vec.resize(cur_pos + size);

42. }

43. memcpy(vec.data() + cur_pos, data, size);

44. cur_pos += size;

45. }

47. void AppendU32(uint32_t val) {

48. Append((char *) (&val), sizeof(val));

49. }

51. char *Data() {

52. return vec.data();

53. }

55. size_t Size() {

56. return vec.size();

57. }

59. size_t Read(void *buff, size_t elemSize, size_t elemCount) {

60. size_t readed = std::min((vec.size() - cur_pos), (elemCount * elemSize)) / elemSize;

61. if (readed > 0) {

62. memcpy(buff, vec.data() + cur_pos, readed * elemSize);

63. cur_pos += readed * elemSize;

64. }

65. return readed;

66. }

68. bool SeekCur(int offset) {

69. if (cur_pos + offset > vec.size()) {

70. cur_pos = !vec.empty() ? (vec.size() - 1) : 0;

71. return false;

72. } else {

73. cur_pos += offset;

74. return true;

75. }

76. }

78. bool SeekBeg(int offset = 0) {

79. cur_pos = 0;

80. return SeekCur(offset);

81. }

83. bool WriteToFile(const char *filename) {

84. FILE *fin = fopen(filename, "wb");

85. if (!fin) {

86. return false;

87. }

88. fseek(fin, 0, SEEK_SET);

89. fwrite(vec.data(), sizeof(char), vec.size(), fin);

90. fclose(fin);

91. return true;

92. }

94. bool ReadFromFile(const char *filename) {

95. FILE *fin = fopen(filename, "rb");

96. if (!fin) {

97. return false;

98. }

99. fseek(fin, 0, SEEK_END);

100. long fileSize = ftell(fin);

101. vec.resize(static_cast<unsigned long long int>(fileSize));

102. fseek(fin, 0, SEEK_SET);

103. fread(vec.data(), sizeof(char), vec.size(), fin);

104. fclose(fin);

105. return true;

106. }

108. private:

109. std::vector<char> vec;

110. size_t cur_pos;

111. };

113. bool Wav2Opus(FileStream *input, FileStream *output);

115. bool Opus2Wav(FileStream *input, FileStream *output);

117. bool wav2stream(char *input, FileStream *output);

119. bool stream2wav(FileStream *input, char *output);

122. bool wavWrite_int16(char *filename, int16_t *buffer, int sampleRate, uint32_t totalSampleCount) {

123. drwav_data_format format = {};

124. format.container = drwav_container_riff; // <-- drwav_container_riff = normal WAV files, drwav_container_w64 = Sony Wave64.

125. format.format = DR_WAVE_FORMAT_PCM; // <-- Any of the DR_WAVE_FORMAT_* codes.

126. format.channels = 1;

127. format.sampleRate = (drwav_uint32) sampleRate;

128. format.bitsPerSample = 16;

129. drwav *pWav = drwav_open_file_write(filename, &format);

130. if (pWav) {

131. drwav_uint64 samplesWritten = drwav_write(pWav, totalSampleCount, buffer);

132. drwav_uninit(pWav);

133. if (samplesWritten != totalSampleCount) {

134. fprintf(stderr, "ERROR\n");

135. return false;

136. }

137. return true;

138. }

139. return false;

140. }

142. int16_t *wavRead_int16(char *filename, uint32_t *sampleRate, uint64_t *totalSampleCount) {

143. unsigned int channels;

144. int16_t *buffer = drwav_open_and_read_file_s16(filename, &channels, sampleRate, totalSampleCount);

145. if (buffer == nullptr) {

146. fprintf(stderr, "ERROR\n");

147. return nullptr;

148. }

149. if (channels != 1) {

150. drwav_free(buffer);

151. buffer = nullptr;

152. *sampleRate = 0;

153. *totalSampleCount = 0;

154. }

155. return buffer;

156. }

158. bool wav2stream(char *input, FileStream *output) {

159. uint32_t sampleRate = 0;

160. uint64_t totalSampleCount = 0;

161. int16_t *wavBuffer = wavRead_int16(input, &sampleRate, &totalSampleCount);

162. if (wavBuffer == nullptr) return false;

163. WavInfo info = {};

164. info.bitsPerSample = 16;

165. info.sampleRate = sampleRate;

166. info.channels = 1;

167. output->SeekBeg();

168. output->Append((char *) &info, sizeof(info));

169. output->Append((char *) wavBuffer, totalSampleCount * sizeof(int16_t));

170. free(wavBuffer);

171. return true;

172. }

174. bool stream2wav(FileStream *input, char *output) {

175. WavInfo info = {};

176. input->SeekBeg();

177. size_t read = input->Read(&info, sizeof(info), 1);

178. if (read != 1) {

179. return false;

180. }

181. size_t totalSampleCount = (input->Size() - sizeof(info)) / 2;

182. return wavWrite_int16(output, (int16_t *) (input->Data() + sizeof(info)), info.sampleRate,

183. static_cast<uint32_t>(totalSampleCount));

184. }

186. bool Wav2Opus(FileStream *input, FileStream *output) {

187. WavInfo in_info = {};

188. input->SeekBeg();

189. size_t read = input->Read(&in_info, sizeof(in_info), 1);

190. if (read != 1) {

191. return false;

192. }

193. uint32_t bitsPerSample = in_info.bitsPerSample;

194. uint32_t sampleRate = in_info.sampleRate;

195. uint16_t channels = in_info.channels;

196. int err = 0;

197. if (channels > MAX_CHANNELS) {

198. return false;

199. }

200. OpusEncoder *encoder = opus_encoder_create(sampleRate, channels, OPUS_APPLICATION_AUDIO, &err);

201. if (!encoder || err < 0) {

202. fprintf(stderr, "failed to create an encoder: %s\n", opus_strerror(err));

203. if (!encoder) {

204. opus_encoder_destroy(encoder);

205. }

206. return false;

207. }

208. const uint16_t *data = (uint16_t *) (input->Data() + sizeof(in_info));

209. size_t size = (input->Size() - sizeof(in_info)) / 2;

210. opus_int16 pcm_bytes[FRAME_SIZE * MAX_CHANNELS];

211. size_t index = 0;

212. size_t step = static_cast<size_t>(FRAME_SIZE * channels);

213. FileStream encodedData;

214. unsigned char cbits[MAX_PACKET_SIZE];

215. size_t frameCount = 0;

216. size_t readCount = 0;

217. while (index < size) {

218. memset(&pcm_bytes, 0, sizeof(pcm_bytes));

219. if (index + step <= size) {

220. memcpy(pcm_bytes, data + index, step * sizeof(uint16_t));

221. index += step;

222. } else {

223. readCount = size - index;

224. memcpy(pcm_bytes, data + index, (readCount) * sizeof(uint16_t));

225. index += readCount;

226. }

227. int nbBytes = opus_encode(encoder, pcm_bytes, channels * FRAME_SIZE, cbits, MAX_PACKET_SIZE);

228. if (nbBytes < 0) {

229. fprintf(stderr, "encode failed: %s\n", opus_strerror(nbBytes));

230. break;

231. }

232. ++frameCount;

233. encodedData.AppendU32(static_cast<uint32_t>(nbBytes));

234. encodedData.Append((char *) cbits, static_cast<size_t>(nbBytes));

235. }

236. WavInfo info = {};

237. info.bitsPerSample = bitsPerSample;

238. info.sampleRate = sampleRate;

239. info.channels = channels;

240. output->SeekBeg();

241. output->Append((char *) &info, sizeof(info));

242. output->Append(encodedData.Data(), encodedData.Size());

243. opus_encoder_destroy(encoder);

244. return true;

245. }

247. bool Opus2Wav(FileStream *input, FileStream *output) {

248. WavInfo info = {};

249. input->SeekBeg();

250. size_t read = input->Read(&info, sizeof(info), 1);

251. if (read != 1) {

252. return false;

253. }

254. int channels = info.channels;

255. if (channels > MAX_CHANNELS) {

256. return false;

257. }

258. output->SeekBeg();

259. output->Append((char *) &info, sizeof(info));

260. int err = 0;

261. OpusDecoder *decoder = opus_decoder_create(info.sampleRate, channels, &err);

262. if (!decoder || err < 0) {

263. fprintf(stderr, "failed to create decoder: %s\n", opus_strerror(err));

264. if (!decoder) {

265. opus_decoder_destroy(decoder);

266. }

267. return false;

268. }

269. unsigned char cbits[MAX_PACKET_SIZE];

270. opus_int16 out[MAX_FRAME_SIZE * MAX_CHANNELS];

271. int frameCount = 0;

272. while (true) {

273. uint32_t nbBytes;

274. size_t readed = input->Read(&nbBytes, sizeof(uint32_t), 1);

275. if (readed == 0) {

276. break;

277. }

279. if (nbBytes > sizeof(cbits)) {

280. fprintf(stderr, "nbBytes > sizeof(cbits)\n");

281. break;

282. }

283. readed = input->Read(cbits, sizeof(char), nbBytes);

284. if (readed != nbBytes) {

285. fprintf(stderr, "readed != nbBytes\n");

286. break;

287. }

288. int frame_size = opus_decode(decoder, cbits, nbBytes, out, MAX_FRAME_SIZE, 0);

289. if (frame_size < 0) {

290. fprintf(stderr, "decoder failed: %s\n", opus_strerror(frame_size));

291. break;

292. }

293. ++frameCount;

294. output->Append((char *) out, channels * frame_size * sizeof(out[0]));

295. }

296. opus_decoder_destroy(decoder);

297. return true;

298. }

301. void splitpath(const char *path, char *drv, char *dir, char *name, char *ext) {

302. const char *end;

303. const char *p;

304. const char *s;

305. if (path[0] && path[1] == ':') {

306. if (drv) {

307. *drv++ = *path++;

308. *drv++ = *path++;

309. *drv = '\0';

310. }

311. } else if (drv)

312. *drv = '\0';

313. for (end = path; *end && *end != ':';)

314. end++;

315. for (p = end; p > path && *--p != '\\' && *p != '/';)

316. if (*p == '.') {

317. end = p;

318. break;

319. }

320. if (ext)

321. for (s = end; (*ext = *s++);)

322. ext++;

323. for (p = end; p > path;)

324. if (*--p == '\\' || *p == '/') {

325. p++;

326. break;

327. }

328. if (name) {

329. for (s = p; s < end;)

330. *name++ = *s++;

331. *name = '\0';

332. }

333. if (dir) {

334. for (s = path; s < p;)

335. *dir++ = *s++;

336. *dir = '\0';

337. }

338. }

340. void opus2wav(const char *in_file, char *out_file) {

341. FileStream input;

342. FileStream output;

343. input.ReadFromFile(in_file);

344. Opus2Wav(&input, &output);

345. stream2wav(&output, out_file);

346. }

348. void wav2opus(char *in_file, char *out_file) {

349. FileStream input;

350. FileStream output;

351. wav2stream(in_file, &input);

352. Wav2Opus(&input, &output);

353. output.WriteToFile(out_file);

354. }

356. int main(int argc, char *argv[]) {

357. printf("Opus Demo\n");

359. if (argc < 2)

360. return -1;

361. char *in_file = argv[1];

362. char drive[3];

363. char dir[256];

364. char fname[256];

365. char ext[256];

366. char out_file[1024];

367. splitpath(in_file, drive, dir, fname, ext);

368. if (memcmp(".wav", ext, strlen(ext)) == 0) {

369. sprintf(out_file, "%s%s%s.out", drive, dir, fname);

370. wav2opus(in_file, out_file);

371. } else if (memcmp(".out", ext, strlen(ext)) == 0) {

372. sprintf(out_file, "%s%s%s_out.wav", drive, dir, fname);

373. opus2wav(in_file, out_file);

374. }

375. printf("done.\n");

376. printf("press any key to exit.\n");

377. getchar();

378. return 0;

379. }

另附C++封装接口示例：

1. class HandlerOpusImpl

2. {

3. public:

4. //在构造函数中创建解码器

5. HandlerOpusImpl() : _perSecNum(0)

6. {

7. int sampleRate = 48000;

8. int channels = 1;

9. int err;

10. _decoder = opus_decoder_create(sampleRate, channels, &err);

11. }

12. //传入要解码的数据srcData, 以string类型返回解码后的数据result

13. bool DecodeData(std::string srcData, std::string &result)

14. {

15. int frameSize;

16. int channels = CHANNELS;

17. int sampleRate = SAMPLE_RATE;

18. opus_int16 *out;

19. char *pcmData;

21. out = new opus_int16[SAMPLE_RATE / 50 * CHANNELS];

22. //解码，如果frameSize小于0，那么说明解码失败

23. frameSize = opus_decode(_decoder, (const unsigned char *)srcData.data(), srcData.size(), out, SAMPLE_RATE / 50 * CHANNELS, 0);

24. if (frameSize <= 0)

25. {

26. return false;

27. }

28. pcmData = new char[frameSize * channels * sizeof(opus_int16)];

30. ++_perSecNum;

31. for (int i = 0; i < channels * frameSize; ++i)

32. {

33. pcmData[i * 2] = out[i] & 0xFF;

34. pcmData[i * 2 + 1] = (out[i] >> 8) & 0xFF;

35. }

36. //把数据赋值给result

37. std::string(pcmData, sizeof(opus_int16) * channels * frameSize).swap(result);

39. delete[]out;

40. delete[]pcmData;

41. return true;

42. }

44. //使用fec找回丢失的包，函数内容获取解码数据函数内容类似，不过fec标记位需要设置为1

45. bool HandleLosePack(std::string srcData, std::string &result)

46. {

47. int frameSize;

48. int channels = CHANNELS;

49. int sampleRate = SAMPLE_RATE;

50. opus_int16 *out;

51. char *pcmData;

53. out = new opus_int16[SAMPLE_RATE / 50 * CHANNELS];

54. frameSize = opus_decode(_decoder, NULL, 0, out, SAMPLE_RATE / 50 * CHANNELS, 1);

55. if (frameSize <= 0)

56. {

57. return false;

58. }

59. pcmData = new char[frameSize * channels * sizeof(opus_int16)];

61. ++_perSecNum;

62. for (int i = 0; i < channels * frameSize; ++i)

63. {

64. pcmData[i * 2] = out[i] & 0xFF;

65. pcmData[i * 2 + 1] = (out[i] >> 8) & 0xFF;

66. }

68. std::string(pcmData, sizeof(opus_int16) * channels * frameSize).swap(result);

70. delete[]out;

71. delete[]pcmData;

72. return true;

73. }

74. void DeleteCodec()

75. {

76. opus_decoder_destroy(_decoder);

77. _decoder = NULL;

78. }

79. private:

80. int _perSecNum;

81. OpusDecoder *_decoder;

82. };