portaudio.cpp revision 33ecfa2cc6e6e09cfc17e4b10249fb1e0b30fb7d 
1/*
2 * Copyright (C) 2009 Wind River Systems
3 *      Author: Ho-Eun Ryu <ho-eun.ryu@windriver.com>
4 */
5
6#include <stdlib.h>
7#include <string.h>
8
9#include <OMX_Core.h>
10#include <OMX_Component.h>
11
12#include <componentbase.h>
13#include <portaudio.h>
14
15#define LOG_TAG "portaudio"
16#include <log.h>
17
18PortAudio::PortAudio()
19{
20    memset(&audioparam, 0, sizeof(audioparam));
21    ComponentBase::SetTypeHeader(&audioparam, sizeof(audioparam));
22}
23
24OMX_ERRORTYPE PortAudio::SetPortAudioParam(
25    const OMX_AUDIO_PARAM_PORTFORMATTYPE *p, bool overwrite_readonly)
26{
27    if (!overwrite_readonly) {
28        OMX_ERRORTYPE ret;
29
30        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
31        if (ret != OMX_ErrorNone)
32            return ret;
33        if (audioparam.nPortIndex != p->nPortIndex)
34            return OMX_ErrorBadPortIndex;
35    }
36    else
37        audioparam.nPortIndex = p->nPortIndex;
38
39    audioparam.nIndex = p->nIndex;
40    audioparam.eEncoding = p->eEncoding;
41
42    return OMX_ErrorNone;
43}
44
45const OMX_AUDIO_PARAM_PORTFORMATTYPE *PortAudio::GetPortAudioParam(void)
46{
47    return &audioparam;
48}
49
50/* end of PortAudio */
51
52PortMp3::PortMp3()
53{
54    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
55
56    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
57    audioparam.eEncoding = OMX_AUDIO_CodingMP3;
58    SetPortAudioParam(&audioparam, false);
59
60    memset(&mp3param, 0, sizeof(mp3param));
61    ComponentBase::SetTypeHeader(&mp3param, sizeof(mp3param));
62}
63
64OMX_ERRORTYPE PortMp3::SetPortMp3Param(const OMX_AUDIO_PARAM_MP3TYPE *p,
65                                       bool overwrite_readonly)
66{
67    if (!overwrite_readonly) {
68        OMX_ERRORTYPE ret;
69
70        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
71        if (ret != OMX_ErrorNone)
72            return ret;
73        if (mp3param.nPortIndex != p->nPortIndex)
74            return OMX_ErrorBadPortIndex;
75    }
76    else {
77        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
78
79        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
80        audioparam.nPortIndex = p->nPortIndex;
81        SetPortAudioParam(&audioparam, true);
82
83        mp3param.nPortIndex = p->nPortIndex;
84    }
85
86    mp3param.nChannels = p->nChannels;
87    mp3param.nBitRate = p->nBitRate;
88    mp3param.nSampleRate = p->nSampleRate;
89    mp3param.nAudioBandWidth = p->nAudioBandWidth;
90    mp3param.eChannelMode = p->eChannelMode;
91    mp3param.eFormat = p->eFormat;
92
93    return OMX_ErrorNone;
94}
95
96const OMX_AUDIO_PARAM_MP3TYPE *PortMp3::GetPortMp3Param(void)
97{
98    return &mp3param;
99}
100
101/* end of PortMp3 */
102
103PortAac::PortAac()
104{
105    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
106
107    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
108    audioparam.eEncoding = OMX_AUDIO_CodingAAC;
109    SetPortAudioParam(&audioparam, false);
110
111    memset(&aacparam, 0, sizeof(aacparam));
112    ComponentBase::SetTypeHeader(&aacparam, sizeof(aacparam));
113}
114
115OMX_ERRORTYPE PortAac::SetPortAacParam(const OMX_AUDIO_PARAM_AACPROFILETYPE *p,
116                                       bool overwrite_readonly)
117{
118    if (!overwrite_readonly) {
119        OMX_ERRORTYPE ret;
120
121        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
122        if (ret != OMX_ErrorNone)
123            return ret;
124        if (aacparam.nPortIndex != p->nPortIndex)
125            return OMX_ErrorBadPortIndex;
126    }
127    else {
128        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
129
130        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
131        audioparam.nPortIndex = p->nPortIndex;
132        SetPortAudioParam(&audioparam, true);
133
134        aacparam.nPortIndex = p->nPortIndex;
135    }
136
137    aacparam.nChannels = p->nChannels;
138    aacparam.nBitRate = p->nBitRate;
139    aacparam.nSampleRate = p->nSampleRate;
140    aacparam.nAudioBandWidth = p->nAudioBandWidth;
141    aacparam.nFrameLength = p->nFrameLength;
142    aacparam.nAACtools = p->nAACtools;
143    aacparam.nAACERtools = p->nAACERtools;
144    aacparam.eAACProfile = p->eAACProfile;
145    aacparam.eAACStreamFormat = p->eAACStreamFormat;
146    aacparam.eChannelMode = p->eChannelMode;
147
148    return OMX_ErrorNone;
149}
150
151const OMX_AUDIO_PARAM_AACPROFILETYPE *PortAac::GetPortAacParam(void)
152{
153    return &aacparam;
154}
155
156/* end of PortAac */
157
158PortWma::PortWma()
159{
160    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
161
162    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
163    audioparam.eEncoding = OMX_AUDIO_CodingWMA;
164    SetPortAudioParam(&audioparam, false);
165
166    memset(&wmaparam, 0, sizeof(wmaparam));
167    ComponentBase::SetTypeHeader(&wmaparam, sizeof(wmaparam));
168}
169
170OMX_ERRORTYPE PortWma::SetPortWmaParam(const OMX_AUDIO_PARAM_WMATYPE *p,
171                                       bool overwrite_readonly)
172{
173    if (!overwrite_readonly) {
174        OMX_ERRORTYPE ret;
175
176        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
177        if (ret != OMX_ErrorNone)
178            return ret;
179        if (wmaparam.nPortIndex != p->nPortIndex)
180            return OMX_ErrorBadPortIndex;
181    }
182    else {
183        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
184
185        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
186        audioparam.nPortIndex = p->nPortIndex;
187        SetPortAudioParam(&audioparam, true);
188
189        wmaparam.nPortIndex = p->nPortIndex;
190    }
191
192    wmaparam.nChannels = p->nChannels;
193    wmaparam.nBitRate = p->nBitRate;
194    wmaparam.eFormat = p->eFormat;
195    wmaparam.eProfile = p->eProfile;
196    wmaparam.nSamplingRate = p->nSamplingRate;
197    wmaparam.nBlockAlign = p->nBlockAlign;
198    wmaparam.nEncodeOptions = p->nEncodeOptions;
199    wmaparam.nSuperBlockAlign = p->nSuperBlockAlign;
200
201    return OMX_ErrorNone;
202}
203
204const OMX_AUDIO_PARAM_WMATYPE *PortWma::GetPortWmaParam(void)
205{
206    return &wmaparam;
207}
208
209/* end of PortWma */
210
211PortPcm::PortPcm()
212{
213    OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
214
215    memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
216    audioparam.eEncoding = OMX_AUDIO_CodingPCM;
217    SetPortAudioParam(&audioparam, false);
218
219    memset(&pcmparam, 0, sizeof(pcmparam));
220    ComponentBase::SetTypeHeader(&pcmparam, sizeof(pcmparam));
221}
222
223OMX_ERRORTYPE PortPcm::SetPortPcmParam(const OMX_AUDIO_PARAM_PCMMODETYPE *p,
224                                       bool overwrite_readonly)
225{
226    if (!overwrite_readonly) {
227        OMX_ERRORTYPE ret;
228
229        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
230        if (ret != OMX_ErrorNone)
231            return ret;
232        if (pcmparam.nPortIndex != p->nPortIndex)
233            return OMX_ErrorBadPortIndex;
234    }
235    else {
236        OMX_AUDIO_PARAM_PORTFORMATTYPE audioparam;
237
238        memcpy(&audioparam, GetPortAudioParam(), sizeof(audioparam));
239        audioparam.nPortIndex = p->nPortIndex;
240        SetPortAudioParam(&audioparam, true);
241
242        pcmparam.nPortIndex = p->nPortIndex;
243    }
244
245    pcmparam.nChannels = p->nChannels;
246    pcmparam.eNumData = p->eNumData;
247    pcmparam.eEndian = p->eEndian;
248    pcmparam.bInterleaved = p->bInterleaved;
249    pcmparam.nBitPerSample = p->nBitPerSample;
250    pcmparam.nSamplingRate = p->nSamplingRate;
251    pcmparam.ePCMMode = p->ePCMMode;
252    memcpy(&pcmparam.eChannelMapping[0], &p->eChannelMapping[0],
253           sizeof(OMX_U32) * p->nChannels);
254
255    return OMX_ErrorNone;
256}
257
258const OMX_AUDIO_PARAM_PCMMODETYPE *PortPcm::GetPortPcmParam(void)
259{
260    return &pcmparam;
261}
262
263/* end of PortPcm */
264