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