Opus介绍及编译

刺骨的言语ヽ痛彻心扉 2022-09-12 11:44 296阅读 0赞

[Opus介绍及编译\_grandgrandpa的博客-CSDN博客\_opus源码][Opus_grandgrandpa_-CSDN_opus]

[音频编码之opus(一)][opus]

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相关的源码资料

[Opus Codec][]

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

这里我们需要下载

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

[下载后可以在ubuntu里解压][opus-1.3.1.tar.gz]

[然后][opus-1.3.1.tar.gz]

[./configure][opus-1.3.1.tar.gz]

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

[然后 make && make install][opus-1.3.1.tar.gz]

[之后，会出现一堆供测试用的可执行文件][opus-1.3.1.tar.gz]

![SouthEast][]

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

1.  `= Compiling libopus ==`
2.  
3.  `To build from a distribution tarball, you only need to do the following:`
4.  
5.  `% ./configure`
6.  `% make`
7.  
8.  `To build from the git repository, the following steps are necessary:`
9.  
10. `0) Set up a development environment:`
11. 
12. `On an Ubuntu or Debian family Linux distribution:`
13. 
14. `% sudo apt-get install git autoconf automake libtool gcc make`
15. 
16. `On a Fedora/Redhat based Linux:`
17. 
18. `% sudo dnf install git autoconf automake libtool gcc make`
19. 
20. `Or for older Redhat/Centos Linux releases:`
21. 
22. `% sudo yum install git autoconf automake libtool gcc make`
23. 
24. `On Apple macOS, install Xcode and brew.sh, then in the Terminal enter:`
25. 
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>`
5.  
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库`
11. 
12. `#define FRAME_SIZE 480`
13. `#define MAX_FRAME_SIZE (6*FRAME_SIZE)`
14. 
15. `#define MAX_CHANNELS 1`
16. `#define MAX_PACKET_SIZE (3*1276)`
17. 
18. `#pragma pack(push)`
19. `#pragma pack(1)`
20. 
21. `struct WavInfo {`
22. `uint16_t channels;`
23. `uint32_t sampleRate;`
24. `uint32_t bitsPerSample;`
25. `};`
26. 
27. `#pragma pack(pop)`
28. 
29. `#ifndef nullptr`
30. `#define nullptr NULL`
31. `#endif`
32. 
33. `class FileStream {`
34. `public:`
35. `FileStream() {`
36. `cur_pos = 0;`
37. `}`
38. 
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. `}`
46. 
47. `void AppendU32(uint32_t val) {`
48. `Append((char *) (&val), sizeof(val));`
49. `}`
50. 
51. `char *Data() {`
52. `return vec.data();`
53. `}`
54. 
55. `size_t Size() {`
56. `return vec.size();`
57. `}`
58. 
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. `}`
67. 
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. `}`
77. 
78. `bool SeekBeg(int offset = 0) {`
79. `cur_pos = 0;`
80. `return SeekCur(offset);`
81. `}`
82. 
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. `}`
93. 
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. `}`
107. 
108. `private:`
109. `std::vector<char> vec;`
110. `size_t cur_pos;`
111. `};`
112. 
113. `bool Wav2Opus(FileStream *input, FileStream *output);`
114. 
115. `bool Opus2Wav(FileStream *input, FileStream *output);`
116. 
117. `bool wav2stream(char *input, FileStream *output);`
118. 
119. `bool stream2wav(FileStream *input, char *output);`
120. 
121. 
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. `}`
141. 
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. `}`
157. 
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. `}`
173. 
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. `}`
185. 
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. `}`
246. 
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. `}`
278. 
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. `}`
299. 
300. 
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. `}`
339. 
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. `}`
347. 
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. `}`
355. 
356. `int main(int argc, char *argv[]) {`
357. `printf("Opus Demo\n");`
358. 
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;`
20. 
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)];`
29. 
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);`
38. 
39. `delete[]out;`
40. `delete[]pcmData;`
41. `return true;`
42. `}`
43. 
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;`
52. 
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)];`
60. 
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. `}`
67. 
68. `std::string(pcmData, sizeof(opus_int16) * channels * frameSize).swap(result);`
69. 
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. `};`

[Opus_grandgrandpa_-CSDN_opus]: https://blog.csdn.net/grandgrandpa/article/details/96438388
[opus]: https://blog.csdn.net/yangysng07/article/details/41558961/?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.searchformbaiduhighlight&spm=1001.2101.3001.4242
[Opus Codec]: http://www.opus-codec.org/
[opus-tools-0.2.1.tar.gz]: https://ftp.mozilla.org/pub/mozilla.org/opus/opus-tools-0.1.9.tar.gz
[opus-1.3.1.tar.gz]: http://downloads.xiph.org/releases/opus/opus-1.1.tar.gz
[SouthEast]: /images/20220828/76b90e1ced9e4717a26c2fc5e5f454c6.png