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_os.h"
13 #include "uvoice_types.h"
14 #include "uvoice_player.h"
15
16 #include "uvoice_common.h"
17 #include "uvoice_play.h"
18
19 #include "opensource/amrwb/dec_if.h"
20
21
22 #define AMRWB_MAGIC_NUMBER "#!AMR-WB\n"
23
24 typedef struct {
25 void *amrwbdec;
26 } amrwb_decoder_t;
27
28 extern const UWord8 block_size[];
29
amrwb_decoder_reset(void * priv)30 static int amrwb_decoder_reset(void *priv)
31 {
32 media_decoder_t *mdecoder = (media_decoder_t *)priv;
33 amrwb_decoder_t *amrwb;
34
35 if (!mdecoder) {
36 M_LOGE("mdecoder null !\n");
37 return -1;
38 }
39
40 amrwb = mdecoder->decoder;
41 if (!amrwb) {
42 M_LOGE("amrwb decoder null !\n");
43 return -1;
44 }
45
46 D_IF_reset(amrwb->amrwbdec);
47 M_LOGD("amrwb decoder reset\n");
48 return 0;
49 }
50
amrwb_decoder_process(void * priv,const uint8_t * buffer,int nbytes)51 static int amrwb_decoder_process(void *priv, const uint8_t *buffer, int nbytes)
52 {
53 media_decoder_t *mdecoder = (media_decoder_t *)priv;
54 amrwb_decoder_t *amrwb;
55 const uint8_t *readptr = buffer;
56 uint8_t frame_header;
57 int rem_size = nbytes;
58 int frame_size;
59 short *out_buffer;
60 int ret;
61
62 int16_t dec_mode;
63
64 if (!mdecoder) {
65 M_LOGE("mdecoder null !\n");
66 return -1;
67 }
68
69 amrwb = mdecoder->decoder;
70 if (!amrwb) {
71 M_LOGE("amrwb decoder null !\n");
72 return -1;
73 }
74
75 out_buffer = mdecoder->buffer_out;
76
77 if (!mdecoder->running) {
78 #ifndef IF2
79 if (memcmp(buffer, AMRWB_MAGIC_NUMBER, strlen(AMRWB_MAGIC_NUMBER))) {
80 M_LOGE("amrwb magic number not found !\n");
81 return -1;
82 }
83 readptr += strlen(AMRWB_MAGIC_NUMBER);
84 rem_size -= strlen(AMRWB_MAGIC_NUMBER);
85 #endif
86
87 media_pcminfo_t pcm_info;
88 memset(&pcm_info, 0, sizeof(pcm_info));
89 pcm_info.rate = 16000;
90 pcm_info.frames = L_FRAME16k;
91 pcm_info.channels = 1;
92 pcm_info.bits = 16;
93 mdecoder->message(mdecoder->priv,
94 PLAYER_MSG_PCM_INFO, &pcm_info);
95
96 media_info_t media_info;
97 memset(&media_info, 0, sizeof(media_info_t));
98 media_info.bitrate = 12000;
99 mdecoder->message(mdecoder->priv,
100 PLAYER_MSG_MEDIA_INFO, &media_info);
101 mdecoder->running = 1;
102 }
103
104 while (1) {
105 frame_header = readptr[0];
106 #ifdef IF2
107 dec_mode = (frame_header >> 4);
108 #else
109 dec_mode = (frame_header >> 3) & 0xf;
110 #endif
111 rem_size--;
112 frame_size = block_size[dec_mode] - 1;
113 if (rem_size < frame_size) {
114 mdecoder->unproc_size = rem_size + 1;
115 break;
116 }
117
118 if (frame_header & 0x04) {
119 //M_LOGD("frame_size %d rem_size %d\n", frame_size, rem_size);
120 D_IF_decode(amrwb->amrwbdec, readptr, out_buffer, _good_frame);
121
122 if (mdecoder->output(mdecoder->priv,
123 out_buffer, mdecoder->buffer_out_size)) {
124 M_LOGE("output failed !\n");
125 return -1;
126 }
127 } else {
128 M_LOGW("bad frame\n");
129 }
130
131 readptr += frame_size + 1;
132 rem_size -= frame_size;
133 if (rem_size <= 0) {
134 mdecoder->unproc_size = 0;
135 break;
136 }
137 }
138
139 return 0;
140 }
141
amrwb_decoder_action(void * priv,player_action_t action,void * arg)142 static int amrwb_decoder_action(void *priv, player_action_t action, void *arg)
143 {
144 return 0;
145 }
146
amrwb_decoder_create(media_decoder_t * mdecoder)147 int amrwb_decoder_create(media_decoder_t *mdecoder)
148 {
149 amrwb_decoder_t *amrwb;
150
151 if (!mdecoder) {
152 M_LOGE("mdecoder null !\n");
153 return -1;
154 }
155
156 amrwb = snd_zalloc(sizeof(amrwb_decoder_t), AFM_MAIN);
157 if (!amrwb) {
158 M_LOGE("alloc amrwb decoder failed !\n");
159 return -1;
160 }
161
162 amrwb->amrwbdec = D_IF_init();
163 if (!amrwb->amrwbdec) {
164 M_LOGE("init amrwbdec failed !\n");
165 snd_free(amrwb);
166 return -1;
167 }
168
169 mdecoder->buffer_out_size = sizeof(short) * L_FRAME16k;
170 mdecoder->buffer_out = snd_zalloc(mdecoder->buffer_out_size, AFM_MAIN);
171 if (!mdecoder->buffer_out) {
172 M_LOGE("alloc out buffer failed !\n");
173 snd_free(amrwb);
174 return -1;
175 }
176
177 mdecoder->input_size = 256;
178
179 mdecoder->decode = amrwb_decoder_process;
180 mdecoder->action = amrwb_decoder_action;
181 mdecoder->reset = amrwb_decoder_reset;
182 mdecoder->decoder = amrwb;
183
184 M_LOGD("amrwb decoder create\n");
185 return 0;
186 }
187
amrwb_decoder_release(media_decoder_t * mdecoder)188 int amrwb_decoder_release(media_decoder_t *mdecoder)
189 {
190 amrwb_decoder_t *amrwb;
191
192 if (!mdecoder) {
193 M_LOGE("mdecoder null !\n");
194 return -1;
195 }
196
197 if (mdecoder->buffer_out) {
198 snd_free(mdecoder->buffer_out);
199 mdecoder->buffer_out = NULL;
200 mdecoder->buffer_out_size = 0;
201 }
202
203 amrwb = mdecoder->decoder;
204 if (!amrwb) {
205 M_LOGE("amrwb null !\n");
206 return -1;
207 }
208
209 D_IF_exit(amrwb->amrwbdec);
210
211 snd_free(amrwb);
212
213 M_LOGD("amrwb decoder release\n");
214 return 0;
215 }
216
217