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
11 #include "uvoice_types.h"
12 #include "uvoice_event.h"
13 #include "uvoice_recorder.h"
14
15 #include "uvoice_os.h"
16 #include "uvoice_config.h"
17 #include "uvoice_common.h"
18 #include "uvoice_audio.h"
19 #include "uvoice_record.h"
20 #include "uvoice_resampler.h"
21
22 #include "audio_common.h"
23 #include "audio_stream.h"
24
25
26 static uvoice_recorder_t *g_mrecorder;
27
28 static int recorder_clr_sink(void);
29
recorder_state_post(recorder_t * recorder,recorder_state_t state)30 static int recorder_state_post(recorder_t *recorder,
31 recorder_state_t state)
32 {
33 return 0;//uvoice_event_post(UVOICE_EV_RECORDER,
34 // UVOICE_CODE_RECORDER_STATE, state);
35 }
36
recorder_reset(recorder_t * recorder)37 static void recorder_reset(recorder_t *recorder)
38 {
39 recorder->stop = 0;
40 recorder->error = 0;
41 recorder->record_len = 0;
42 }
43
recorder_encode_default(void * priv,uint8_t * buffer,int nbytes)44 static int recorder_encode_default(void *priv,
45 uint8_t *buffer, int nbytes)
46 {
47 return nbytes;
48 }
49
recorder_action_default(void * priv,recorder_action_t action,void * arg)50 static int recorder_action_default(void *priv,
51 recorder_action_t action, void *arg)
52 {
53 return 0;
54 }
55
recorder_type_parse(char * sink)56 static media_type_t recorder_type_parse(char *sink)
57 {
58 if (!sink)
59 return MEDIA_TYPE_UNKNOWN;
60 else if (!strncmp(sink, "fs:", strlen("fs:")))
61 return MEDIA_TYPE_FILE;
62 else if (!strncmp(sink, "pt:", strlen("pt:")))
63 return MEDIA_TYPE_FLASH;
64 return MEDIA_TYPE_UNKNOWN;
65 }
66
recorder_format_assert(media_format_t format)67 static bool recorder_format_assert(media_format_t format)
68 {
69 switch (format) {
70 case MEDIA_FMT_WAV:
71 case MEDIA_FMT_PCM:
72 case MEDIA_FMT_SPX:
73 case MEDIA_FMT_AMR:
74 case MEDIA_FMT_AMRWB:
75 case MEDIA_FMT_OPS:
76 return true;
77 default:
78 return false;
79 }
80 return false;
81 }
82
recorder_stack_size(media_format_t format)83 static int recorder_stack_size(media_format_t format)
84 {
85 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
86 int size = 4096;
87
88 if (!recorder)
89 return size;
90
91 switch (format) {
92 case MEDIA_FMT_OPS:
93 size = 32768;
94 break;
95 case MEDIA_FMT_SPX:
96 size = 8192;
97 break;
98 case MEDIA_FMT_AMR:
99 case MEDIA_FMT_AMRWB:
100 size = 20 * 1024;
101 }
102
103 if (recorder->ns_enable || recorder->ec_enable)
104 size = 12 * 1024;
105
106 if (recorder->agc_enable)
107 size = 10 * 1024;
108
109 return size;
110 }
111
recorder_bitrate_default(media_format_t format)112 static int recorder_bitrate_default(media_format_t format)
113 {
114 if (format == MEDIA_FMT_MP3)
115 return 128000;
116 else if (format == MEDIA_FMT_OPS)
117 return 27800;
118 return 100000;
119 }
120
recorder_param_set(media_pcminfo_t * info,int rate,int channels,int bits,int frames)121 static int recorder_param_set(media_pcminfo_t *info,
122 int rate, int channels, int bits, int frames)
123 {
124 if (!info) {
125 M_LOGE("info null !\n");
126 return -1;
127 }
128
129 if (!pcm_rate_valid(rate)) {
130 M_LOGE("sample rate invalid !\n");
131 return -1;
132 }
133
134 if (!pcm_bits_valid(bits)) {
135 M_LOGE("bits invalid !\n");
136 return -1;
137 }
138
139 if (!pcm_channel_valid(channels)) {
140 M_LOGE("channels invalid !\n");
141 return -1;
142 }
143
144 if (frames < 0) {
145 M_LOGE("frames invalid !\n");
146 return -1;
147 }
148
149 info->rate = rate;
150 info->channels = channels;
151 info->bits = bits;
152 info->frames = frames;
153 return 0;
154 }
155
recorder_task(void * arg)156 static void recorder_task(void *arg)
157 {
158 recorder_t *recorder = (recorder_t *)arg;
159 media_encoder_t *mencoder;
160 media_packer_t *mpacker;
161 uint8_t *data_buffer;
162 int data_buffer_size;
163 int ret;
164
165 if (!recorder) {
166 M_LOGE("recorder null !\n");
167 return;
168 }
169
170 mencoder = recorder->mencoder;
171 if (!mencoder) {
172 M_LOGE("mencoder null !\n");
173 return;
174 }
175
176 mpacker = recorder->mpacker;
177 if (!mpacker) {
178 M_LOGE("mpacker null !\n");
179 return;
180 }
181
182 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
183
184 if (recorder->state == RECORDER_STAT_READY ||
185 recorder->state == RECORDER_STAT_STOP) {
186 if (mencoder->action(mencoder, RECORDER_START, NULL)) {
187 M_LOGE("start encoder failed !\n");
188 os_mutex_unlock(recorder->lock);
189 return;
190 }
191
192 if (recorder->state == RECORDER_STAT_STOP)
193 M_LOGI("stop->running\n");
194 else
195 M_LOGI("ready->running\n");
196 recorder->state = RECORDER_STAT_RUNNING;
197 recorder_state_post(recorder, recorder->state);
198 }
199
200 if (recorder->state != RECORDER_STAT_RUNNING) {
201 M_LOGE("recorder not running ! state %d\n",
202 recorder->state);
203 os_mutex_unlock(recorder->lock);
204 return;
205 }
206
207 os_mutex_unlock(recorder->lock);
208
209 while (1) {
210 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
211 if (recorder->stop) {
212 if (recorder->state == RECORDER_STAT_RUNNING) {
213 mencoder->action(mencoder, RECORDER_STOP, NULL);
214 if (mpacker->action)
215 mpacker->action(mpacker, RECORDER_STOP, NULL);
216 in_stream_stop(recorder->in);
217 recorder->state = RECORDER_STAT_STOP;
218 recorder->stop = 0;
219 recorder_state_post(recorder, recorder->state);
220 M_LOGI("running->stop\n");
221 os_mutex_unlock(recorder->lock);
222 if (recorder->error) {
223 M_LOGE("recorder error, release it\n");
224 recorder_clr_sink();
225 }
226 break;
227 }
228 }
229
230 if (!in_stream_configured(recorder->in)) {
231 media_pcminfo_t *info = &recorder->pcm_info;
232 media_pcminfo_t temp_info;
233
234 memcpy(&temp_info, info, sizeof(temp_info));
235 if (in_stream_configure(recorder->in, &temp_info)) {
236 M_LOGE("configure stream failed !\n");
237 recorder->stop = 1;
238 recorder->error = 1;
239 os_mutex_unlock(recorder->lock);
240 continue;
241 }
242
243 recorder->src_rate = temp_info.rate;
244 if (temp_info.rate != info->rate) {
245 #ifdef UVOICE_RESAMPLE_ENABLE
246 if (!recorder->resampler) {
247 uvoice_resampler_create(&recorder->resampler, recorder->src_rate,
248 recorder->dst_rate, temp_info.channels, temp_info.bits);
249 if (!recorder->resampler) {
250 M_LOGE("create resampler failed !\n");
251 recorder->stop = 1;
252 recorder->error = 1;
253 os_mutex_unlock(recorder->lock);
254 continue;
255 }
256 } else {
257 uvoice_resampler_update(recorder->resampler, recorder->src_rate,
258 recorder->dst_rate, temp_info.channels, temp_info.bits);
259 }
260 #endif
261 }
262 }
263
264 ret = in_stream_read(recorder->in, recorder->buffer,
265 recorder->buffer_size);
266 if (ret <= 0) {
267 M_LOGE("read failed %d!\n", ret);
268 recorder->stop = 1;
269 recorder->error = 1;
270 os_mutex_unlock(recorder->lock);
271 continue;
272 } else if (ret != recorder->buffer_size) {
273 M_LOGW("read %d ret %d\n",
274 recorder->buffer_size, ret);
275 }
276
277 data_buffer_size = ret;
278 data_buffer = recorder->buffer;
279
280 #ifdef UVOICE_RESAMPLE_ENABLE
281 if (uvoice_resampler_process(recorder->resampler, recorder->buffer, ret,
282 &data_buffer, &data_buffer_size)) {
283 M_LOGE("resample error\n");
284 }
285 #endif
286
287 if (data_buffer_size <= 0) {
288 M_LOGE("data_buffer_size err %d\n", data_buffer_size);
289 os_mutex_unlock(recorder->lock);
290 continue;
291 }
292
293 recorder->buffer_dirty_size = data_buffer_size;
294 recorder->record_len += data_buffer_size;
295
296 if (!mencoder->header_pack) {
297 if (mencoder->header_gen &&
298 mencoder->header_gen(mencoder, &recorder->pcm_info)) {
299 M_LOGE("init header failed !\n");
300 recorder->stop = 1;
301 recorder->error = 1;
302 os_mutex_unlock(recorder->lock);
303 continue;
304 }
305
306 if (mencoder->header && mencoder->header_size > 0) {
307 M_LOGD("header pack\n");
308 ret = mpacker->pack(mpacker,
309 mencoder->header, mencoder->header_size);
310 if (ret < 0) {
311 M_LOGE("pack header failed !\n");
312 snd_free(mencoder->header);
313 mencoder->header = NULL;
314 mencoder->header_size = 0;
315 recorder->stop = 1;
316 os_mutex_unlock(recorder->lock);
317 continue;
318 } else if (ret != mencoder->header_size) {
319 M_LOGW("pack %d ret %d\n", mencoder->header_size, ret);
320 }
321
322 if (mencoder->header_cplt) {
323 snd_free(mencoder->header);
324 mencoder->header = NULL;
325 mencoder->header_size = 0;
326 }
327 }
328 mencoder->header_pack = 1;
329 }
330 os_mutex_unlock(recorder->lock);
331
332 ret = mencoder->encode(mencoder,
333 data_buffer, recorder->buffer_dirty_size);
334 if (ret <= 0) {
335 M_LOGE("encode failed %d!\n", ret);
336 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
337 recorder->stop = 1;
338 recorder->error = 1;
339 os_mutex_unlock(recorder->lock);
340 continue;
341 }
342 recorder->buffer_dirty_size = ret;
343
344 ret = mpacker->pack(mpacker, data_buffer,
345 recorder->buffer_dirty_size);
346 if (ret < 0) {
347 M_LOGE("pack failed %d!\n", ret);
348 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
349 recorder->stop = 1;
350 recorder->error = 1;
351 os_mutex_unlock(recorder->lock);
352 } else if (ret == 0) {
353 M_LOGW("pack end\n");
354 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
355 recorder->stop = 1;
356 os_mutex_unlock(recorder->lock);
357 } else if (ret != recorder->buffer_dirty_size) {
358 M_LOGW("pack %d ret %d\n",
359 recorder->buffer_dirty_size, ret);
360 }
361 }
362
363 os_sem_signal(recorder->cplt_sem);
364 M_LOGD("exit\n");
365 }
366
recorder_get_stream(uint8_t * buffer,int nbytes)367 static int recorder_get_stream(uint8_t *buffer, int nbytes)
368 {
369 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
370 media_encoder_t *mencoder;
371 uint8_t *data_buffer;
372 uint8_t *data_ptr;
373 int data_size;
374 int ret;
375
376 if (!recorder) {
377 M_LOGE("recorder null !\n");
378 return -1;
379 }
380
381 if (!buffer) {
382 M_LOGE("buffer null !\n");
383 return -1;
384 }
385
386 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
387 mencoder = recorder->mencoder;
388 if (!mencoder) {
389 M_LOGE("mencoder null !\n");
390 os_mutex_unlock(recorder->lock);
391 return -1;
392 }
393
394 if (recorder->state == RECORDER_STAT_READY ||
395 recorder->state == RECORDER_STAT_STOP) {
396 if (mencoder->action(mencoder, RECORDER_START, NULL)) {
397 M_LOGE("start encoder failed !\n");
398 os_mutex_unlock(recorder->lock);
399 return -1;
400 }
401
402 if (recorder->state == RECORDER_STAT_STOP)
403 M_LOGI("stop->running\n");
404 else
405 M_LOGI("ready->running\n");
406 recorder->state = RECORDER_STAT_RUNNING;
407
408 }
409
410 if (recorder->state != RECORDER_STAT_RUNNING) {
411 M_LOGE("recorder not running ! state %d\n",
412 recorder->state);
413 os_mutex_unlock(recorder->lock);
414 return -1;
415 }
416
417 if (!in_stream_configured(recorder->in)) {
418 media_pcminfo_t *info = &recorder->pcm_info;
419 media_pcminfo_t temp_info;
420
421 if (info->frames <= 0) {
422 info->frames = nbytes / (info->channels * (info->bits >> 3));
423 mencoder->frames = info->frames;
424 }
425
426 memcpy(&temp_info, info, sizeof(temp_info));
427 in_stream_configure(recorder->in, &temp_info);
428
429 recorder->src_rate = temp_info.rate;
430 if (temp_info.rate != info->rate) {
431 #ifdef UVOICE_RESAMPLE_ENABLE
432 uvoice_resampler_create(&recorder->resampler, recorder->src_rate,
433 recorder->dst_rate, temp_info.channels, temp_info.bits);
434 if (!recorder->resampler) {
435 M_LOGE("create resampler failed !\n");
436 os_mutex_unlock(recorder->lock);
437 return -1;
438 }
439 #endif
440 }
441 }
442
443 data_size = (nbytes * recorder->src_rate) / recorder->dst_rate;
444 if (data_size > nbytes) {
445 if (!recorder->rec_buffer) {
446 recorder->rec_buffer = snd_zalloc(data_size, AFM_MAIN);
447 if (!recorder->rec_buffer) {
448 M_LOGE("alloc record buffer failed !\n");
449 os_mutex_unlock(recorder->lock);
450 return -1;
451 }
452 }
453 data_buffer = recorder->rec_buffer;
454 } else {
455 data_buffer = buffer;
456 }
457
458 ret = in_stream_read(recorder->in, data_buffer, data_size);
459 if (ret <= 0) {
460 M_LOGE("read failed !\n");
461 os_mutex_unlock(recorder->lock);
462 return -1;
463 } else if (ret != data_size) {
464 M_LOGW("read %d ret %d\n", data_size, ret);
465 }
466
467 data_ptr = data_buffer;
468 data_size = ret;
469
470 #ifdef UVOICE_RESAMPLE_ENABLE
471 if (uvoice_resampler_process(recorder->resampler, data_buffer, ret,
472 &data_ptr, &data_size)) {
473 M_LOGE("resample error\n");
474 }
475
476 if (data_size <= 0) {
477 M_LOGE("data_size err %d\n", data_size);
478 os_mutex_unlock(recorder->lock);
479 return -1;
480 }
481 #endif
482
483 recorder->buffer_dirty_size = data_size;
484
485 ret = mencoder->encode(mencoder,
486 data_ptr, recorder->buffer_dirty_size);
487 if (ret <= 0) {
488 M_LOGE("encode failed !\n");
489 os_mutex_unlock(recorder->lock);
490 return -1;
491 }
492
493 if (data_ptr != buffer)
494 memcpy(buffer, data_ptr, ret);
495
496 os_mutex_unlock(recorder->lock);
497 return ret;
498 }
499
recorder_start(void)500 static int recorder_start(void)
501 {
502 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
503
504 if (!recorder) {
505 M_LOGE("recorder null !\n");
506 return -1;
507 }
508
509 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
510
511 if (recorder->type == MEDIA_TYPE_STREAM) {
512 M_LOGE("media type stream !\n");
513 os_mutex_unlock(recorder->lock);
514 return -1;
515 }
516
517 if (recorder->state != RECORDER_STAT_READY &&
518 recorder->state != RECORDER_STAT_STOP) {
519 M_LOGE("recorder not ready/stop !\n");
520 os_mutex_unlock(recorder->lock);
521 return -1;
522 }
523 os_mutex_unlock(recorder->lock);
524
525 M_LOGD("start record task\n");
526
527 os_task_create(&recorder->task,
528 "uvoice_record_task",
529 recorder_task,
530 recorder,
531 recorder_stack_size(recorder->format),
532 UVOICE_TASK_PRI_HIGHER);
533
534 return 0;
535 }
536
recorder_stop(void)537 static int recorder_stop(void)
538 {
539 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
540
541 if (!recorder) {
542 M_LOGE("recorder null !\n");
543 return -1;
544 }
545
546 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
547 if (recorder->type == MEDIA_TYPE_STREAM) {
548 M_LOGE("stream stop not required !\n");
549 os_mutex_unlock(recorder->lock);
550 return -1;
551 }
552
553 if (recorder->state != RECORDER_STAT_RUNNING) {
554 M_LOGE("recorder can't stop ! state %d\n",
555 recorder->state);
556 os_mutex_unlock(recorder->lock);
557 return -1;
558 }
559
560 if (!recorder->stop) {
561 recorder->stop = 1;
562 os_mutex_unlock(recorder->lock);
563 if (os_sem_wait(recorder->cplt_sem, 5000)) {
564 M_LOGE("wait stop timeout !\n");
565 return -1;
566 }
567
568 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
569 if (recorder->state != RECORDER_STAT_STOP) {
570 M_LOGE("recorder stop failed ! state %d\n",
571 recorder->state);
572 os_mutex_unlock(recorder->lock);
573 return -1;
574 } else {
575 M_LOGD("recorder stop\n");
576 }
577 }
578
579 os_mutex_unlock(recorder->lock);
580 return 0;
581 }
582
recorder_get_state(recorder_state_t * state)583 static int recorder_get_state(recorder_state_t *state)
584 {
585 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
586
587 if (!recorder) {
588 M_LOGE("recorder null !\n");
589 return -1;
590 }
591
592 if (!state) {
593 M_LOGE("arg null !\n");
594 return -1;
595 }
596
597 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
598 *state = recorder->state;
599 os_mutex_unlock(recorder->lock);
600 return 0;
601 }
602
recorder_get_position(int * position)603 static int recorder_get_position(int *position)
604 {
605 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
606 media_pcminfo_t *info;
607
608 if (!recorder) {
609 M_LOGE("recorder null !\n");
610 return -1;
611 }
612
613 if (!position) {
614 M_LOGE("arg null !\n");
615 return -1;
616 }
617
618 info = &recorder->pcm_info;
619
620 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
621 if (recorder->state == RECORDER_STAT_RUNNING ||
622 recorder->state == RECORDER_STAT_STOP) {
623 *position = (recorder->record_len /
624 (info->channels * (info->bits >> 3))) / info->rate;
625 }
626
627 os_mutex_unlock(recorder->lock);
628 return 0;
629 }
630
recorder_set_sink(media_format_t format,int rate,int channels,int bits,int frames,int bitrate,char * sink)631 static int recorder_set_sink(media_format_t format,
632 int rate, int channels,
633 int bits, int frames, int bitrate, char *sink)
634 {
635 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
636
637 if (!recorder) {
638 M_LOGE("recorder null !\n");
639 return -1;
640 }
641
642 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
643 if (recorder->state != RECORDER_STAT_IDLE) {
644 M_LOGE("recorder not released !\n");
645 goto __exit;
646 }
647
648 M_LOGD("sink %s\n", sink ? sink : "null");
649
650 recorder->dst_rate = rate;
651 recorder->src_rate = rate;
652
653 if (frames <= 0 && sink)
654 frames = 640;
655
656 if (recorder_param_set(&recorder->pcm_info, recorder->dst_rate,
657 channels, bits, frames)) {
658 M_LOGE("set record param failed !\n");
659 goto __exit;
660 }
661
662 if (sink) {
663 if (format_parse_byname(sink, &recorder->format)) {
664 M_LOGE("parse format failed !\n");
665 goto __exit;
666 }
667
668 if (!recorder_format_assert(recorder->format)) {
669 M_LOGE("format unsupport !\n");
670 goto __exit;
671 }
672 } else {
673 recorder->format = format;
674 }
675
676 if (recorder->format == MEDIA_FMT_UNKNOWN) {
677 M_LOGE("format unsupport !\n");
678 goto __exit;
679 }
680
681 recorder->mencoder = media_encoder_create(recorder->format);
682 if (!recorder->mencoder) {
683 M_LOGE("create media encoder failed !\n");
684 goto __exit;
685 }
686
687 if (!recorder->mencoder->initialized) {
688 recorder->mencoder->encode = recorder_encode_default;
689 recorder->mencoder->action = recorder_action_default;
690 recorder->mencoder->initialized = 1;
691 }
692
693 recorder->mencoder->frames = frames;
694 recorder->mencoder->rate = recorder->dst_rate;
695 recorder->mencoder->channels = channels;
696 recorder->mencoder->bits = bits;
697 recorder->mencoder->bitrate = bitrate > 0 ? bitrate :
698 recorder_bitrate_default(recorder->format);
699
700 if (sink) {
701 recorder->type = recorder_type_parse(sink);
702 if (recorder->type == MEDIA_TYPE_UNKNOWN) {
703 M_LOGE("media type unsupport !\n");
704 goto __exit2;
705 }
706
707 recorder->mpacker = media_packer_create(
708 sink, recorder->type);
709 if (!recorder->mpacker) {
710 M_LOGE("create media packer fail !\n");
711 goto __exit3;
712 }
713
714 #if (BOARD_HAASEDUK1 == 1)
715 recorder->buffer_size = frames * channels * (bits >> 3) + 512; // avoid crash when use frames = 1024
716 #else
717 recorder->buffer_size = frames * channels * (bits >> 3);
718 #endif
719
720 M_LOGD("alloc record buffer %d\n", recorder->buffer_size);
721 recorder->buffer = snd_zalloc(
722 recorder->buffer_size, AFM_MAIN);
723 if (!recorder->buffer) {
724 M_LOGE("alloc record buffer failed !\n");
725 goto __exit4;
726 }
727 } else {
728 recorder->type = MEDIA_TYPE_STREAM;
729 }
730
731 recorder->in = in_stream_create();
732 if (!recorder->in) {
733 M_LOGE("create in stream failed !\n");
734 if (recorder->buffer) {
735 snd_free(recorder->buffer);
736 recorder->buffer = NULL;
737 }
738 goto __exit4;
739 }
740
741 recorder->state = RECORDER_STAT_READY;
742 M_LOGI("idle->ready\n");
743 os_mutex_unlock(recorder->lock);
744 return 0;
745
746 __exit4:
747 media_packer_release(recorder->mpacker);
748 __exit3:
749 recorder->type = MEDIA_TYPE_UNKNOWN;
750 __exit2:
751 #ifdef UVOICE_RESAMPLE_ENABLE
752 uvoice_resampler_release(recorder->resampler);
753 recorder->resampler = NULL;
754 #else
755 M_LOGI("resampler not enable\n");
756 #endif
757 __exit1:
758 media_encoder_release(recorder->mencoder);
759 recorder->mencoder = NULL;
760 __exit:
761 os_mutex_unlock(recorder->lock);
762 return -1;
763 }
764
recorder_clr_sink(void)765 static int recorder_clr_sink(void)
766 {
767 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
768 media_encoder_t *mencoder = NULL;
769 media_packer_t *mpacker = NULL;
770 int ret;
771
772 if (!recorder) {
773 M_LOGE("recorder null !\n");
774 return -1;
775 }
776
777 os_mutex_lock(recorder->lock, OS_WAIT_FOREVER);
778
779 if (recorder->state == RECORDER_STAT_IDLE) {
780 M_LOGW("recorder is idle\n");
781 os_mutex_unlock(recorder->lock);
782 return -1;
783 }
784
785 if (recorder->type != MEDIA_TYPE_STREAM) {
786 if (recorder->state != RECORDER_STAT_STOP &&
787 recorder->state != RECORDER_STAT_READY) {
788 M_LOGE("state %d can't clr sink\n", recorder->state);
789 os_mutex_unlock(recorder->lock);
790 return -1;
791 }
792 }
793
794 mencoder = recorder->mencoder;
795 if (!mencoder) {
796 M_LOGE("mencoder null !\n");
797 os_mutex_unlock(recorder->lock);
798 return -1;
799 }
800
801 if (recorder->type == MEDIA_TYPE_STREAM) {
802 if (recorder->state == RECORDER_STAT_RUNNING) {
803 mencoder->action(mencoder, RECORDER_STOP, NULL);
804 in_stream_stop(recorder->in);
805 recorder->state = RECORDER_STAT_STOP;
806 M_LOGI("running->stop\n");
807 }
808 } else {
809 mpacker = recorder->mpacker;
810 if (!mpacker) {
811 M_LOGE("mpacker null !\n");
812 os_mutex_unlock(recorder->lock);
813 return -1;
814 }
815 }
816
817 if (recorder->state != RECORDER_STAT_STOP &&
818 recorder->state != RECORDER_STAT_READY) {
819 M_LOGE("recorder can't clr sink ! state %d\n",
820 recorder->state);
821 os_mutex_unlock(recorder->lock);
822 return -1;
823 }
824
825 if (recorder->type != MEDIA_TYPE_STREAM) {
826 if (!mencoder->header_cplt &&
827 mencoder->header_update && mpacker->update) {
828 if (mencoder->header && mencoder->header_size > 0) {
829 M_LOGD("header update\n");
830 mencoder->header_update(mencoder, mpacker->size);
831 ret = mpacker->update(mpacker,
832 mencoder->header, mencoder->header_size, 0);
833 if (ret < 0)
834 M_LOGE("pack header failed !\n");
835
836 snd_free(mencoder->header);
837 mencoder->header = NULL;
838 mencoder->header_size = 0;
839 }
840 }
841 }
842
843 #ifdef UVOICE_RESAMPLE_ENABLE
844 uvoice_resampler_release(recorder->resampler);
845 #endif
846 media_encoder_release(mencoder);
847 media_packer_release(mpacker);
848
849 if (recorder->buffer) {
850 snd_free(recorder->buffer);
851 recorder->buffer = NULL;
852 }
853
854 if (recorder->rec_buffer) {
855 snd_free(recorder->rec_buffer);
856 recorder->rec_buffer = NULL;
857 }
858
859 in_stream_release(recorder->in);
860
861 recorder->resampler = NULL;
862 recorder->mencoder = NULL;
863 recorder->mpacker = NULL;
864 recorder->in = NULL;
865
866 recorder_reset(recorder);
867 recorder->format = MEDIA_FMT_UNKNOWN;
868 recorder->type = MEDIA_TYPE_UNKNOWN;
869 if (recorder->state == RECORDER_STAT_STOP)
870 M_LOGI("stop->idle\n");
871 else
872 M_LOGI("ready->idle\n");
873 recorder->state = RECORDER_STAT_IDLE;
874
875 os_mutex_unlock(recorder->lock);
876 return 0;
877 }
878
recorder_format_support(media_format_t format)879 static int recorder_format_support(media_format_t format)
880 {
881 if (recorder_format_assert(format))
882 return 1;
883 return 0;
884 }
885
recorder_ns_enable(int enable)886 static int recorder_ns_enable(int enable)
887 {
888 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
889 int ret = 0;
890
891 if (!recorder) {
892 M_LOGE("recorder null !\n");
893 return -1;
894 }
895
896 enable = !!enable;
897
898 if (recorder->ns_enable != enable) {
899 recorder->ns_enable = enable;
900 if (recorder->ns_enable)
901 ret = audio_param_set(PARAM_KEY_NOISE_SUPPRESSION,
902 PARAM_VAL_ENABLE);
903 else
904 ret = audio_param_set(PARAM_KEY_NOISE_SUPPRESSION,
905 PARAM_VAL_DISABLE);
906 }
907
908 return ret;
909 }
910
recorder_ec_enable(int enable)911 static int recorder_ec_enable(int enable)
912 {
913 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
914 int ret = 0;
915
916 if (!recorder) {
917 M_LOGE("recorder null !\n");
918 return -1;
919 }
920
921 enable = !!enable;
922
923 if (recorder->ec_enable != enable) {
924 recorder->ec_enable = enable;
925 if (recorder->ec_enable)
926 ret = audio_param_set(PARAM_KEY_ECHO_CANCELLATION,
927 PARAM_VAL_ENABLE);
928 else
929 ret = audio_param_set(PARAM_KEY_ECHO_CANCELLATION,
930 PARAM_VAL_DISABLE);
931 }
932
933 return ret;
934 }
935
recorder_agc_enable(int enable)936 static int recorder_agc_enable(int enable)
937 {
938 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
939 int ret = 0;
940
941 if (!recorder) {
942 M_LOGE("recorder null !\n");
943 return -1;
944 }
945
946 enable = !!enable;
947
948 if (recorder->agc_enable != enable) {
949 recorder->agc_enable = enable;
950 if (recorder->agc_enable)
951 ret = audio_param_set(PARAM_KEY_AUTO_GAIN_CONTROL,
952 PARAM_VAL_ENABLE);
953 else
954 ret = audio_param_set(PARAM_KEY_AUTO_GAIN_CONTROL,
955 PARAM_VAL_DISABLE);
956 }
957
958 return ret;
959 }
960
recorder_vad_enable(int enable)961 static int recorder_vad_enable(int enable)
962 {
963 recorder_t *recorder = g_mrecorder ? g_mrecorder->priv : NULL;
964 int ret = 0;
965
966 if (!recorder) {
967 M_LOGE("recorder null !\n");
968 return -1;
969 }
970
971 enable = !!enable;
972
973 if (recorder->vad_enable != enable) {
974 recorder->vad_enable = enable;
975 if (recorder->vad_enable)
976 ret = audio_param_set(PARAM_KEY_VOICE_ACTIVE_DETECT,
977 PARAM_VAL_ENABLE);
978 else
979 ret = audio_param_set(PARAM_KEY_VOICE_ACTIVE_DETECT,
980 PARAM_VAL_DISABLE);
981 }
982
983 return ret;
984 }
985
recorder_reference(recorder_t * recorder)986 static int recorder_reference(recorder_t *recorder)
987 {
988 if (!recorder)
989 return -1;
990 recorder->reference_count++;
991 return recorder->reference_count;
992 }
993
recorder_dereference(recorder_t * recorder)994 static int recorder_dereference(recorder_t *recorder)
995 {
996 if (!recorder)
997 return -1;
998 recorder->reference_count--;
999 return recorder->reference_count;
1000 }
1001
recorder_init(void)1002 static recorder_t *recorder_init(void)
1003 {
1004 recorder_t *recorder = snd_zalloc(sizeof(recorder_t), AFM_EXTN);
1005 if (!recorder) {
1006 M_LOGE("alloc recorder failed !\n");
1007 return NULL;
1008 }
1009
1010 recorder->cplt_sem = os_sem_new(0);
1011 recorder->lock = os_mutex_new();
1012
1013 recorder->reference_count = 1;
1014 recorder->format = MEDIA_FMT_UNKNOWN;
1015 recorder->type = MEDIA_TYPE_UNKNOWN;
1016 return recorder;
1017 }
1018
recorder_deinit(recorder_t * recorder)1019 static int recorder_deinit(recorder_t *recorder)
1020 {
1021 if (!recorder) {
1022 M_LOGE("recorder null !\n");
1023 return -1;
1024 }
1025
1026 if (recorder->state != RECORDER_STAT_IDLE) {
1027 M_LOGE("recorder not released !\n");
1028 return -1;
1029 }
1030
1031 os_mutex_free(recorder->lock);
1032 os_sem_free(recorder->cplt_sem);
1033 snd_free(recorder);
1034 return 0;
1035 }
1036
uvoice_recorder_create(void)1037 uvoice_recorder_t *uvoice_recorder_create(void)
1038 {
1039 uvoice_recorder_t *mrecorder = g_mrecorder;
1040
1041 if (mrecorder) {
1042 if (recorder_reference(mrecorder->priv) < 0) {
1043 M_LOGE("get uvoice recorder failed !\n");
1044 return NULL;
1045 }
1046 return mrecorder;
1047 }
1048
1049 mrecorder = snd_zalloc(sizeof(uvoice_recorder_t), AFM_EXTN);
1050 if (!mrecorder) {
1051 M_LOGE("alloc uvoice recorder failed !\n");
1052 return NULL;
1053 }
1054
1055 mrecorder->priv = recorder_init();
1056 if (!mrecorder->priv) {
1057 M_LOGE("init recoder failed !\n");
1058 snd_free(mrecorder);
1059 return NULL;
1060 }
1061
1062 mrecorder->start = recorder_start;
1063 mrecorder->stop = recorder_stop;
1064 mrecorder->get_stream = recorder_get_stream;
1065 mrecorder->set_sink = recorder_set_sink;
1066 mrecorder->clr_sink = recorder_clr_sink;
1067 mrecorder->get_state = recorder_get_state;
1068 mrecorder->get_position = recorder_get_position;
1069 mrecorder->ns_enable = recorder_ns_enable;
1070 mrecorder->ec_enable = recorder_ec_enable;
1071 mrecorder->agc_enable = recorder_agc_enable;
1072 mrecorder->vad_enable = recorder_vad_enable;
1073 mrecorder->format_support = recorder_format_support;
1074
1075 g_mrecorder = mrecorder;
1076 M_LOGI("uvoice recorder create\n");
1077 return mrecorder;
1078 }
1079
uvoice_recorder_release(uvoice_recorder_t * mrecorder)1080 int uvoice_recorder_release(uvoice_recorder_t *mrecorder)
1081 {
1082 if (!mrecorder) {
1083 M_LOGE("uvoice recorder null !\n");
1084 return -1;
1085 }
1086
1087 if (mrecorder != g_mrecorder) {
1088 M_LOGE("uvoice recorder invalid !\n");
1089 return -1;
1090 }
1091
1092 if (recorder_dereference(mrecorder->priv) == 0) {
1093 if (recorder_deinit(mrecorder->priv)) {
1094 M_LOGE("free recorder failed !\n");
1095 return -1;
1096 }
1097
1098 snd_free(mrecorder);
1099 g_mrecorder = NULL;
1100 M_LOGI("uvoice recorder release\n");
1101 }
1102
1103 return 0;
1104 }
1105
1106