1 /*
2 * Copyright (C) 2015-2020 Alibaba Group Holding Limited
3 *
4 */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <stdint.h>
9 #include <string.h>
10 #include <signal.h>
11
12 #include "uvoice_types.h"
13 #include "uvoice_player.h"
14
15 #include "uvoice_os.h"
16 #include "uvoice_common.h"
17 #include "uvoice_play.h"
18
19 #include "pvmp3decoder_api.h"
20
21 #define NO_DECODING_ERROR 0
22 #define FRAME_HEADER_MASK 0xfffe0c00
23 #define FRAME_HEADER_SIZE 4
24
25 #define HEADER_PACK(ptr) \
26 ((ptr)[0] << 24 | (ptr)[1] << 16 | (ptr)[2] << 8 | (ptr)[3])
27
28 enum {
29 PVMP3_CONTINUE = 0,
30 PVMP3_BREAK,
31 PVMP3_STOP,
32 };
33
34 typedef struct {
35 void *handler;
36 uint8_t *frame_ptr;
37 int32_t pos;
38 int32_t proc_sum;
39 int32_t rate;
40 int32_t channels;
41 int32_t bitrate;
42 int32_t frame_size;
43 int32_t frame_samples;
44 int32_t skip_id3_size;
45 uint32_t fixed_header;
46 tPVMP3DecoderExternal *config;
47 } pvmp3_decoder_t;
48
49
50 /*
51 * Taken from PVMP3 src
52 */
pvmp3_parse_header(pvmp3_decoder_t * decoder,uint32_t header)53 static int pvmp3_parse_header(pvmp3_decoder_t *decoder, uint32_t header)
54 {
55 if ((header & 0xffe00000) != 0xffe00000)
56 return -1;
57
58 uint8_t version = (uint8_t)((header >> 19) & 3);
59 if (version == 0x01)
60 return -1;
61
62 uint8_t layer = (uint8_t)((header >> 17) & 3);
63 if (layer == 0x00)
64 return -1;
65
66 uint8_t bitrate_idx = (uint8_t)((header >> 12) & 0x0f);
67 if (bitrate_idx == 0 || bitrate_idx == 0x0f)
68 return -1;
69
70 uint8_t rate_idx = (uint8_t)((header >> 10) & 3);
71 if (rate_idx == 3)
72 return -1;
73
74 static const int rate_v1[] = { 44100, 48000, 32000 };
75 int sample_rate = rate_v1[rate_idx];
76 if (version == 2 /* V2 */)
77 sample_rate /= 2;
78 else if (version == 0 /* V2.5 */)
79 sample_rate /= 4;
80
81 uint8_t padding = (header >> 9) & 1;
82
83 if (layer == 3) {
84 /* layer I */
85 static const int bitrate_v1[] = {
86 32, 64, 96, 128, 160, 192, 224, 256,
87 288, 320, 352, 384, 416, 448
88 };
89
90 static const int bitrate_v2[] = {
91 32, 48, 56, 64, 80, 96, 112, 128,
92 144, 160, 176, 192, 224, 256
93 };
94
95 decoder->bitrate = (version == 3) ?
96 bitrate_v1[bitrate_idx - 1] : bitrate_v2[bitrate_idx - 1];
97
98 decoder->frame_size = (12000 * decoder->bitrate / sample_rate + padding) * 4;
99 //M_LOGD("layer1 bitrate %d rate %d padding %u frame_size %d pos %d\n",
100 // decoder->bitrate,
101 // sample_rate, padding, decoder->frame_size, decoder->pos);
102 decoder->frame_samples = 384;
103 } else {
104 /* layer II or III */
105 static const int bitrate_v1_l2[] = {
106 32, 48, 56, 64, 80, 96, 112, 128,
107 160, 192, 224, 256, 320, 384
108 };
109
110 static const int bitrate_v1_l3[] = {
111 32, 40, 48, 56, 64, 80, 96, 112,
112 128, 160, 192, 224, 256, 320
113 };
114
115 static const int bitrate_v2[] = {
116 8, 16, 24, 32, 40, 48, 56, 64,
117 80, 96, 112, 128, 144, 160
118 };
119
120 if (version == 3) {
121 /* V1 */
122 decoder->bitrate = (layer == 2 /* L2 */) ? bitrate_v1_l2[bitrate_idx - 1]
123 : bitrate_v1_l3[bitrate_idx - 1];
124 decoder->frame_samples = 1152;
125 } else {
126 /* V2 (or 2.5) */
127 decoder->bitrate = bitrate_v2[bitrate_idx - 1];
128 decoder->frame_samples = (layer == 1 /* L3 */) ? 576 : 1152;
129 }
130
131 if (version == 3) {
132 /* V1 */
133 decoder->frame_size = 144000 * decoder->bitrate / sample_rate + padding;
134 //M_LOGD("v1 bitrate %d rate %d padding %u frame_size %d pos %d\n",
135 // decoder->bitrate,
136 // sample_rate,
137 // padding, decoder->frame_size, decoder->pos);
138 } else {
139 /* V2 or V2.5 */
140 int tmp = (layer == 1) ? 72000 : 144000;
141 decoder->frame_size = tmp * decoder->bitrate / sample_rate + padding;
142 //M_LOGD("v2 bitrate %d rate %d padding %u frame_size %d pos %d\n",
143 // decoder->bitrate,
144 // sample_rate,
145 // padding, decoder->frame_size, decoder->pos);
146 }
147 }
148
149 decoder->rate = sample_rate;
150 decoder->channels = (((header >> 6) & 3) == 3) ? 1 : 2;
151 return 0;
152 }
153
pvmp3_frame_locate(media_decoder_t * mdecoder,uint8_t * buffer,int len)154 static int pvmp3_frame_locate(media_decoder_t *mdecoder,
155 uint8_t *buffer, int len)
156 {
157 if (!mdecoder) {
158 M_LOGE("mdecoder null !\n");
159 return PVMP3_STOP;
160 }
161
162 pvmp3_decoder_t *decoder = mdecoder->decoder;
163 int skip_size;
164
165 if (decoder->proc_sum == 0) {
166 uint8_t ID3_desc[10];
167 int32_t ID3_size;
168
169 if (len - decoder->pos < sizeof(ID3_desc)) {
170 mdecoder->unproc_size = len - decoder->pos;
171 M_LOGW("buffer too short !\n");
172 return PVMP3_BREAK;
173 }
174
175 memcpy(ID3_desc, buffer + decoder->pos, sizeof(ID3_desc));
176
177 if (!memcmp("ID3", ID3_desc, 3)) {
178 ID3_size = ((ID3_desc[6] & 0x7f) << 21)
179 | ((ID3_desc[7] & 0x7f) << 14)
180 | ((ID3_desc[8] & 0x7f) << 7)
181 | (ID3_desc[9] & 0x7f);
182
183 ID3_size += 10;
184
185 decoder->skip_id3_size = ID3_size;
186
187 //M_LOGD("ID3 size %d pos %d len %d\n",
188 // decoder->skip_id3_size, decoder->pos, len);
189
190 skip_size = MIN(decoder->skip_id3_size, (len - decoder->pos));
191 decoder->skip_id3_size -= skip_size;
192 decoder->proc_sum += skip_size;
193 decoder->pos += skip_size;
194 if (decoder->pos >= len) {
195 mdecoder->unproc_size = 0;
196 return PVMP3_BREAK;
197 }
198 }
199 }
200
201 if (decoder->skip_id3_size > 0) {
202 skip_size = MIN(decoder->skip_id3_size, (len - decoder->pos));
203 decoder->skip_id3_size -= skip_size;
204 decoder->pos += skip_size;
205 decoder->proc_sum += skip_size;
206 if (decoder->pos >= len) {
207 //M_LOGD("skip_size %d skip_id3_size %d pos %d\n",
208 // skip_size, decoder->skip_id3_size, decoder->pos);
209 mdecoder->unproc_size = 0;
210 return PVMP3_BREAK;
211 } else {
212 //M_LOGD("skip id3 cplt, skip_id3_size %d pos %d proc_sum %d\n",
213 // decoder->skip_id3_size,
214 // decoder->pos, decoder->proc_sum);
215 }
216 }
217
218 int frame_pos = decoder->pos;
219 int frame_size_bak = 0;
220 int next_frame_pos = 0;
221 uint32_t header = 0;
222 uint32_t next_header = 0;
223
224 char frame_found = 0;
225 char assert_cnt = len >= 1045 ? len/1045 : 1;
226 char i;
227
228 do {
229 if (frame_pos + FRAME_HEADER_SIZE > len) {
230 mdecoder->unproc_size = len - frame_pos;
231 decoder->proc_sum += frame_pos - decoder->pos;
232 //M_LOGD("too less: frame_pos %d frame_size %d pos %d proc_sum %d unproc_size %u\n",
233 // frame_pos,
234 // decoder->frame_size,
235 // decoder->pos, decoder->proc_sum, mdecoder->unproc_size);
236 return PVMP3_BREAK;
237 }
238
239 header = HEADER_PACK(buffer + frame_pos);
240
241 if (decoder->fixed_header != 0 &&
242 (header & FRAME_HEADER_MASK) != (decoder->fixed_header & FRAME_HEADER_MASK)) {
243 frame_pos++;
244 continue;
245 }
246
247 if (pvmp3_parse_header(decoder, header)) {
248 frame_pos++;
249 continue;
250 }
251
252 //M_LOGD("frame maybe: frame_pos %d frame_size %d pos %d g_pos %d unproc_size %u\n",
253 // frame_pos,
254 // decoder->frame_size,
255 // decoder->pos, decoder->proc_sum, mdecoder->unproc_size);
256
257 /* Assert frame validation */
258 frame_size_bak = decoder->frame_size;
259 frame_found = 1;
260 next_frame_pos = frame_pos;
261
262 for (i = 0; i < assert_cnt; i++) {
263 next_frame_pos += decoder->frame_size;
264 //M_LOGD("i %d frame_pos %d next_frame_pos %d\n",
265 // i, frame_pos, next_frame_pos);
266 if (next_frame_pos + FRAME_HEADER_SIZE > len) {
267 decoder->proc_sum += frame_pos - decoder->pos;
268 mdecoder->unproc_size = len - frame_pos;
269 //M_LOGD("require more: frame_pos %d frame_size %d pos %d proc_sum %d unproc_size %u\n",
270 // frame_pos,
271 // decoder->frame_size,
272 // decoder->pos, decoder->proc_sum, mdecoder->unproc_size);
273 return PVMP3_BREAK;
274 }
275
276 next_header = HEADER_PACK(buffer + next_frame_pos);
277 if (decoder->fixed_header != 0 &&
278 (next_header & FRAME_HEADER_MASK) != (decoder->fixed_header & FRAME_HEADER_MASK)) {
279 frame_pos++;
280 frame_found = 0;
281 break;
282 }
283
284 if (pvmp3_parse_header(decoder, next_header)) {
285 frame_pos++;
286 frame_found = 0;
287 break;
288 }
289 }
290
291 if (!frame_found)
292 continue;
293
294 if (decoder->fixed_header == 0) {
295 decoder->fixed_header = header;
296 //M_LOGD("fixed header 0x%x\n", decoder->fixed_header);
297 }
298
299 decoder->frame_size = frame_size_bak;
300 decoder->frame_ptr = buffer + frame_pos;
301 decoder->proc_sum += frame_pos + decoder->frame_size - decoder->pos;
302 decoder->pos = frame_pos + decoder->frame_size;
303 mdecoder->unproc_size = len - decoder->pos;
304
305 //M_LOGD("frame found: frame_pos %d next_frame_pos %d frame_size %d pos %d g_pos %d unproc_size %d\n",
306 // frame_pos,
307 // next_frame_pos,
308 // decoder->frame_size,
309 // decoder->pos, decoder->proc_sum, mdecoder->unproc_size);
310 } while (!frame_found);
311
312 return PVMP3_CONTINUE;
313 }
314
pvmp3_decoder_reset(void * priv)315 static int pvmp3_decoder_reset(void *priv)
316 {
317 media_decoder_t *mdecoder = (media_decoder_t *)priv;
318 if (!mdecoder) {
319 M_LOGE("mdecoder null !\n");
320 return -1;
321 }
322
323 pvmp3_decoder_t *decoder = mdecoder->decoder;
324 if (!decoder) {
325 M_LOGE("decoder null !\n");
326 return -1;
327 }
328
329 decoder->bitrate = 0;
330 decoder->channels = 0;
331 decoder->rate = 0;
332 decoder->pos = 0;
333 decoder->proc_sum = 0;
334 decoder->skip_id3_size = 0;
335 decoder->frame_ptr = NULL;
336 decoder->fixed_header = 0;
337 decoder->frame_samples = 0;
338 decoder->frame_size = 0;
339
340 pvmp3_resetDecoder(decoder->handler);
341
342 M_LOGD("pvmp3 reset\n");
343 return 0;
344 }
345
pvmp3_decoder_process(void * priv,uint8_t * buffer,int nbytes)346 static int pvmp3_decoder_process(void *priv, uint8_t *buffer, int nbytes)
347 {
348 media_decoder_t *mdecoder = (media_decoder_t *)priv;
349 if (!mdecoder) {
350 M_LOGE("mdecoder null !\n");
351 return -1;
352 }
353
354 pvmp3_decoder_t *decoder = mdecoder->decoder;
355 if (!decoder) {
356 M_LOGE("decoder null !\n");
357 return -1;
358 }
359
360 tPVMP3DecoderExternal *config = decoder->config;
361 int16_t *out_buffer = (int16_t *)mdecoder->buffer_out;
362 int out_samples;
363 int i;
364 int ret;
365
366 decoder->pos = 0;
367
368 if (nbytes != mdecoder->input_size)
369 M_LOGD("tail buff %d\n", nbytes);
370
371 while (1) {
372 ret = pvmp3_frame_locate(mdecoder, buffer, nbytes);
373 if (ret == PVMP3_BREAK) {
374 //M_LOGD("request more data, unproc size %u\n",
375 // mdecoder->unproc_size);
376 break;
377 } else if (ret == PVMP3_STOP) {
378 M_LOGE("decoder error !\n");
379 return -1;
380 }
381
382 config->inputBufferCurrentLength = nbytes - (decoder->frame_ptr - buffer);
383 config->pInputBuffer = decoder->frame_ptr;
384 config->inputBufferMaxLength = nbytes - (decoder->frame_ptr - buffer);
385 config->inputBufferUsedLength = 0;
386 config->pOutputBuffer = (int16_t *)mdecoder->buffer_out;
387 config->outputFrameSize = mdecoder->buffer_out_size / sizeof(int16_t);
388
389 ret = pvmp3_framedecoder(config, decoder->handler);
390 if (ret != NO_DECODING_ERROR)
391 continue;
392
393 if (!mdecoder->running) {
394 //M_LOGD("rate %d channels %d bitrate %d frame_size %d\n",
395 // config->samplingRate,
396 // config->num_channels,
397 // config->bitRate, config->outputFrameSize);
398 media_pcminfo_t pcm_info;
399 memset(&pcm_info, 0, sizeof(media_pcminfo_t));
400 pcm_info.rate = config->samplingRate;
401 pcm_info.frames = config->outputFrameSize / config->num_channels;
402 if (mdecoder->stere_enable)
403 pcm_info.channels = config->num_channels;
404 else
405 pcm_info.channels = 1;
406 pcm_info.bits = 16;
407 mdecoder->message(mdecoder->priv,
408 PLAYER_MSG_PCM_INFO, &pcm_info);
409
410 media_info_t media_info;
411 memset(&media_info, 0, sizeof(media_info_t));
412 media_info.bitrate = config->bitRate * 1000;
413 mdecoder->message(mdecoder->priv,
414 PLAYER_MSG_MEDIA_INFO, &media_info);
415 mdecoder->running = 1;
416 }
417
418 out_samples = config->outputFrameSize;
419 if (out_samples * sizeof(int16_t) > mdecoder->buffer_out_size) {
420 M_LOGE("out samples %u overrange !\n", out_samples);
421 return -1;
422 }
423
424 if (config->num_channels == 2 && !mdecoder->stere_enable) {
425 out_samples = config->outputFrameSize / 2;
426 for (i = 0; i < out_samples; i++)
427 out_buffer[i] = out_buffer[2 * i];
428 }
429
430 if (mdecoder->output(mdecoder->priv,
431 (uint8_t *)out_buffer, out_samples * sizeof(int16_t))) {
432 M_LOGE("output failed !\n");
433 return -1;
434 }
435 }
436
437 return 0;
438 }
439
pvmp3_decoder_action(void * priv,player_action_t action,void * arg)440 static int pvmp3_decoder_action(void *priv,
441 player_action_t action, void *arg)
442 {
443 return 0;
444 }
445
pvmp3_decoder_create(media_decoder_t * mdecoder)446 int pvmp3_decoder_create(media_decoder_t *mdecoder)
447 {
448 pvmp3_decoder_t *decoder;
449 int mem_size;
450
451 if (!mdecoder) {
452 M_LOGE("mdecoder null !\n");
453 return -1;
454 }
455
456 decoder = snd_zalloc(
457 sizeof(pvmp3_decoder_t), AFM_MAIN);
458 if (!decoder) {
459 M_LOGE("alloc pvmp3 decoder failed !\n");
460 return -1;
461 }
462
463 decoder->config = snd_zalloc(
464 sizeof(tPVMP3DecoderExternal), AFM_MAIN);
465 if (!decoder->config) {
466 M_LOGE("alloc decoder config failed !\n");
467 snd_free(decoder);
468 return -1;
469 }
470
471 decoder->config->equalizerType = flat;
472 decoder->config->crcEnabled = false;
473
474 mem_size = pvmp3_decoderMemRequirements();
475
476 decoder->handler = snd_zalloc(mem_size, AFM_MAIN);
477 if (!decoder->handler) {
478 M_LOGE("alloc decoder memory failed !\n");
479 snd_free(decoder->config);
480 snd_free(decoder);
481 return -1;
482 }
483
484 pvmp3_InitDecoder(decoder->config, decoder->handler);
485
486 mdecoder->decode = pvmp3_decoder_process;
487 mdecoder->action = pvmp3_decoder_action;
488 mdecoder->reset = pvmp3_decoder_reset;
489 mdecoder->decoder = decoder;
490
491 M_LOGD("pvmp3 create\n");
492 return 0;
493 }
494
pvmp3_decoder_release(media_decoder_t * mdecoder)495 int pvmp3_decoder_release(media_decoder_t *mdecoder)
496 {
497 pvmp3_decoder_t *decoder;
498
499 if (!mdecoder) {
500 M_LOGE("mdecoder null !\n");
501 return -1;
502 }
503
504 decoder = mdecoder->decoder;
505 if (!decoder) {
506 M_LOGE("decoder null !\n");
507 return -1;
508 }
509
510 snd_free(decoder->handler);
511 snd_free(decoder->config);
512 snd_free(decoder);
513 mdecoder->decoder = NULL;
514 M_LOGD("pvmp3 release\n");
515 return 0;
516 }
517
518