1/*
2 * portaudio.cpp, port class for audio
3 *
4 * Copyright (c) 2009-2010 Wind River Systems, Inc.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19#include <stdlib.h>
20#include <string.h>
21
22#include <OMX_Core.h>
23#include <OMX_Component.h>
24
25#include <componentbase.h>
26#include <portaudio.h>
27
28#define LOG_TAG "portaudio"
29#include <log.h>
30
31PortAudio::PortAudio()
32{
33    memset(&audioparam, 0, sizeof(audioparam));
34    ComponentBase::SetTypeHeader(&audioparam, sizeof(audioparam));
35}
36
37OMX_ERRORTYPE PortAudio::SetPortAudioParam(
38    const OMX_AUDIO_PARAM_PORTFORMATTYPE *p, bool overwrite_readonly)
39{
40    if (!overwrite_readonly) {
41        OMX_ERRORTYPE ret;
42
43        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
44        if (ret != OMX_ErrorNone)
45            return ret;
46        if (audioparam.nPortIndex != p->nPortIndex)
47            return OMX_ErrorBadPortIndex;
48    }
49    else
50        audioparam.nPortIndex = p->nPortIndex;
51
52    audioparam.nIndex = p->nIndex;
53    audioparam.eEncoding = p->eEncoding;
54
55    return OMX_ErrorNone;
56}
57
58const OMX_AUDIO_PARAM_PORTFORMATTYPE *PortAudio::GetPortAudioParam(void)
59{
60    return &audioparam;
61}
62
63/* end of PortAudio */
64
65PortMp3::PortMp3()
66{
67    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
68
69    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
70    audioparam.eEncoding = OMX_AUDIO_CodingMP3;
71    SetPortAudioParam(&audioparam, false);
72
73    memset(&mp3param, 0, sizeof(mp3param));
74    ComponentBase::SetTypeHeader(&mp3param, sizeof(mp3param));
75}
76
77OMX_ERRORTYPE PortMp3::SetPortMp3Param(const OMX_AUDIO_PARAM_MP3TYPE *p,
78                                       bool overwrite_readonly)
79{
80    if (!overwrite_readonly) {
81        OMX_ERRORTYPE ret;
82
83        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
84        if (ret != OMX_ErrorNone)
85            return ret;
86        if (mp3param.nPortIndex != p->nPortIndex)
87            return OMX_ErrorBadPortIndex;
88    }
89    else {
90        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
91
92        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
93        audioparam.nPortIndex = p->nPortIndex;
94        SetPortAudioParam(&audioparam, true);
95
96        mp3param.nPortIndex = p->nPortIndex;
97    }
98
99    mp3param.nChannels = p->nChannels;
100    mp3param.nBitRate = p->nBitRate;
101    mp3param.nSampleRate = p->nSampleRate;
102    mp3param.nAudioBandWidth = p->nAudioBandWidth;
103    mp3param.eChannelMode = p->eChannelMode;
104    mp3param.eFormat = p->eFormat;
105
106    return OMX_ErrorNone;
107}
108
109const OMX_AUDIO_PARAM_MP3TYPE *PortMp3::GetPortMp3Param(void)
110{
111    return &mp3param;
112}
113
114/* end of PortMp3 */
115
116PortAac::PortAac()
117{
118    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
119
120    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
121    audioparam.eEncoding = OMX_AUDIO_CodingAAC;
122    SetPortAudioParam(&audioparam, false);
123
124    memset(&aacparam, 0, sizeof(aacparam));
125    ComponentBase::SetTypeHeader(&aacparam, sizeof(aacparam));
126}
127
128OMX_ERRORTYPE PortAac::SetPortAacParam(const OMX_AUDIO_PARAM_AACPROFILETYPE *p,
129                                       bool overwrite_readonly)
130{
131    if (!overwrite_readonly) {
132        OMX_ERRORTYPE ret;
133
134        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
135        if (ret != OMX_ErrorNone)
136            return ret;
137        if (aacparam.nPortIndex != p->nPortIndex)
138            return OMX_ErrorBadPortIndex;
139    }
140    else {
141        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
142
143        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
144        audioparam.nPortIndex = p->nPortIndex;
145        SetPortAudioParam(&audioparam, true);
146
147        aacparam.nPortIndex = p->nPortIndex;
148    }
149
150    aacparam.nChannels = p->nChannels;
151    aacparam.nBitRate = p->nBitRate;
152    aacparam.nSampleRate = p->nSampleRate;
153    aacparam.nAudioBandWidth = p->nAudioBandWidth;
154    aacparam.nFrameLength = p->nFrameLength;
155    aacparam.nAACtools = p->nAACtools;
156    aacparam.nAACERtools = p->nAACERtools;
157    aacparam.eAACProfile = p->eAACProfile;
158    aacparam.eAACStreamFormat = p->eAACStreamFormat;
159    aacparam.eChannelMode = p->eChannelMode;
160
161    return OMX_ErrorNone;
162}
163
164const OMX_AUDIO_PARAM_AACPROFILETYPE *PortAac::GetPortAacParam(void)
165{
166    return &aacparam;
167}
168
169/* end of PortAac */
170
171PortWma::PortWma()
172{
173    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
174
175    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
176    audioparam.eEncoding = OMX_AUDIO_CodingWMA;
177    SetPortAudioParam(&audioparam, false);
178
179    memset(&wmaparam, 0, sizeof(wmaparam));
180    ComponentBase::SetTypeHeader(&wmaparam, sizeof(wmaparam));
181}
182
183OMX_ERRORTYPE PortWma::SetPortWmaParam(const OMX_AUDIO_PARAM_WMATYPE *p,
184                                       bool overwrite_readonly)
185{
186    if (!overwrite_readonly) {
187        OMX_ERRORTYPE ret;
188
189        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
190        if (ret != OMX_ErrorNone)
191            return ret;
192        if (wmaparam.nPortIndex != p->nPortIndex)
193            return OMX_ErrorBadPortIndex;
194    }
195    else {
196        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
197
198        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
199        audioparam.nPortIndex = p->nPortIndex;
200        SetPortAudioParam(&audioparam, true);
201
202        wmaparam.nPortIndex = p->nPortIndex;
203    }
204
205    wmaparam.nChannels = p->nChannels;
206    wmaparam.nBitRate = p->nBitRate;
207    wmaparam.eFormat = p->eFormat;
208    wmaparam.eProfile = p->eProfile;
209    wmaparam.nSamplingRate = p->nSamplingRate;
210    wmaparam.nBlockAlign = p->nBlockAlign;
211    wmaparam.nEncodeOptions = p->nEncodeOptions;
212    wmaparam.nSuperBlockAlign = p->nSuperBlockAlign;
213
214    return OMX_ErrorNone;
215}
216
217const OMX_AUDIO_PARAM_WMATYPE *PortWma::GetPortWmaParam(void)
218{
219    return &wmaparam;
220}
221
222/* end of PortWma */
223
224PortPcm::PortPcm()
225{
226    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
227
228    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
229    audioparam.eEncoding = OMX_AUDIO_CodingPCM;
230    SetPortAudioParam(&audioparam, false);
231
232    memset(&pcmparam, 0, sizeof(pcmparam));
233    ComponentBase::SetTypeHeader(&pcmparam, sizeof(pcmparam));
234}
235
236OMX_ERRORTYPE PortPcm::SetPortPcmParam(const OMX_AUDIO_PARAM_PCMMODETYPE *p,
237                                       bool overwrite_readonly)
238{
239    if (!overwrite_readonly) {
240        OMX_ERRORTYPE ret;
241
242        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
243        if (ret != OMX_ErrorNone)
244            return ret;
245        if (pcmparam.nPortIndex != p->nPortIndex)
246            return OMX_ErrorBadPortIndex;
247    }
248    else {
249        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
250
251        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
252        audioparam.nPortIndex = p->nPortIndex;
253        SetPortAudioParam(&audioparam, true);
254
255        pcmparam.nPortIndex = p->nPortIndex;
256    }
257
258    pcmparam.nChannels = p->nChannels;
259    pcmparam.eNumData = p->eNumData;
260    pcmparam.eEndian = p->eEndian;
261    pcmparam.bInterleaved = p->bInterleaved;
262    pcmparam.nBitPerSample = p->nBitPerSample;
263    pcmparam.nSamplingRate = p->nSamplingRate;
264    pcmparam.ePCMMode = p->ePCMMode;
265    memcpy(&pcmparam.eChannelMapping[0], &p->eChannelMapping[0],
266           sizeof(OMX_U32) * p->nChannels);
267
268    return OMX_ErrorNone;
269}
270
271const OMX_AUDIO_PARAM_PCMMODETYPE *PortPcm::GetPortPcmParam(void)
272{
273    return &pcmparam;
274}
275
276/* end of PortPcm */
277
278PortAmr::PortAmr()
279{
280    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
281
282    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
283    audioparam.eEncoding = OMX_AUDIO_CodingAMR;
284    SetPortAudioParam(&audioparam, false);
285
286    memset(&amrparam, 0, sizeof(amrparam));
287    ComponentBase::SetTypeHeader(&amrparam, sizeof(amrparam));
288}
289
290OMX_ERRORTYPE PortAmr::SetPortAmrParam(const OMX_AUDIO_PARAM_AMRTYPE *p,
291                                       bool overwrite_readonly)
292{
293    if (!overwrite_readonly) {
294        OMX_ERRORTYPE ret;
295
296        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
297        if (ret != OMX_ErrorNone)
298            return ret;
299        if (amrparam.nPortIndex != p->nPortIndex)
300            return OMX_ErrorBadPortIndex;
301    }
302    else {
303        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
304
305        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
306        audioparam.nPortIndex = p->nPortIndex;
307        SetPortAudioParam(&audioparam, true);
308
309        amrparam.nPortIndex = p->nPortIndex;
310    }
311
312    amrparam.nChannels       = p->nChannels;
313    amrparam.nBitRate        = p->nBitRate;
314    amrparam.eAMRBandMode    = p->eAMRBandMode;
315    amrparam.eAMRDTXMode     = p->eAMRDTXMode;
316    amrparam.eAMRFrameFormat = p->eAMRFrameFormat;
317
318    return OMX_ErrorNone;
319}
320
321const OMX_AUDIO_PARAM_AMRTYPE *PortAmr::GetPortAmrParam(void)
322{
323    return &amrparam;
324}
325
326/* end of PortAmr */
327