src/FMedia_AudioInImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <FBaseSysLog.h>
  19 #include "FMedia_AudioInImpl.h"
  20 #include "FMedia_AudioInEvent.h"
  21 #include "FMedia_AudioInEventArg.h"
  22 #include "FMedia_AudioManagerConvert.h"
  23
  24 using namespace Tizen::Base;
  25 using namespace Tizen::Base::Runtime;
  26 using namespace Tizen::Base::Collection;
  27
  28 namespace Tizen { namespace Media
  29 {
  30
  31 bool _AudioInImpl::__isConstructed = false;
  32 int _AudioInImpl::__runFlag = false;
  33 const int _AudioInImpl::_AUDIO_IN_OPTIMAL_SAMPLE_RATE = 44100;
  34 const int _AudioInImpl::_AUDIO_IN_MINIMUM_BUFFER_SIZE = 1024;
  35 const int _AudioInImpl::_AUDIO_IN_MAXIMUM_BUFFER_SIZE = 164112;
  36 const AudioChannelType _AudioInImpl::_AUDIO_IN_OPTIMAL_CHANNEL_TYPE = AUDIO_CHANNEL_TYPE_STEREO;
  37 const AudioSampleType _AudioInImpl::_AUDIO_IN_OPTIMAL_SAMPLE_TYPE = AUDIO_TYPE_PCM_S16_LE;
  38
  39 _AudioInImpl::_AudioInImpl(void)
  40         : __audioInState(AUDIOIN_STATE_ERROR)
  41         , __pAudioInEventListener(null)
  42         , __audioInHandle(null)
  43         , __audioInOptimalBufferSize(0)
  44         , __interruptFlag(false)
  45 {
  46 }
  47
  48 _AudioInImpl::~_AudioInImpl(void)
  49 {
  50         result r = E_SUCCESS;
  51         __isConstructed = false;
  52
  53         if (__audioInState < AUDIOIN_STATE_UNPREPARED && __audioInState >= AUDIOIN_STATE_PREPARED)
  54         {
  55                 if (__audioInState == AUDIOIN_STATE_RECORDING || __audioInState == AUDIOIN_STATE_STOPPED )
  56                 {
  57                         r = this->Reset();
  58                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  59                 }
  60
  61                 r = this->Unprepare();
  62                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  63         }
  64
  65         if (__pAudioInEvent.get() && __pAudioInEventListener)
  66         {
  67                 __pAudioInEvent->RemoveListener(*__pAudioInEventListener);
  68                 __pAudioInEventListener = null;
  69         }
  70         return;
  71
  72 CATCH:
  73         return;
  74 }
  75
  76 _AudioInImpl*
  77 _AudioInImpl::GetInstance(AudioIn* pAudioIn)
  78 {
  79         if (pAudioIn != null)
  80         {
  81                 return pAudioIn->__pAudioInImpl;
  82         }
  83
  84         return null;
  85 }
  86
  87 const _AudioInImpl*
  88 _AudioInImpl::GetInstance(const AudioIn* pAudioIn)
  89 {
  90         if (pAudioIn != null)
  91         {
  92                 return pAudioIn->__pAudioInImpl;
  93         }
  94
  95         return null;
  96 }
  97
  98 result
  99 _AudioInImpl::Construct(Tizen::Media::IAudioInEventListener& listener)
 100 {
 101         result r = E_SUCCESS;
 102
 103         SysTryReturnResult(NID_MEDIA, !__isConstructed, E_DEVICE_BUSY, "The input device is already in use");
 104         __isConstructed = true;
 105
 106         //Setting up the Events
 107         __pAudioInEvent.reset(new (std::nothrow) _AudioInEvent);
 108         SysTryCatch(NID_MEDIA, __pAudioInEvent.get(), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 109
 110         r = __pAudioInEvent->Construct();
 111         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 112
 113         r = __pAudioInEvent->AddListener(listener);
 114         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 115
 116         __pAudioInEventListener = &listener;
 117
 118         //BufferQueue
 119         r = __bufferQueue.Construct();
 120         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 121
 122         //Buffer Sync
 123         __pBufferSync.reset(new (std::nothrow) Monitor);
 124         SysTryCatch(NID_MEDIA, __pBufferSync.get(), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(r));
 125         r = __pBufferSync->Construct();
 126         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 127
 128         __audioInState = AUDIOIN_STATE_INITIALIZED;
 129         return r;
 130
 131 CATCH:
 132         __isConstructed = false;
 133         SetLastResult(r);
 134         return r;
 135 }
 136
 137
 138 int
 139 _AudioInImpl::GetMaxBufferSize(void)
 140 {
 141         result r = E_SUCCESS;
 142         SysTryCatch(NID_MEDIA, __audioInState < AUDIOIN_STATE_UNPREPARED && __audioInState >= AUDIOIN_STATE_PREPARED, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioIn state is not proper.");
 143         return _AUDIO_IN_MAXIMUM_BUFFER_SIZE;
 144 CATCH:
 145         SetLastResult(r);
 146         return -1;
 147 }
 148
 149
 150 int
 151 _AudioInImpl::GetMinBufferSize(void)
 152 {
 153         result r = E_SUCCESS;
 154         SysTryCatch(NID_MEDIA, __audioInState < AUDIOIN_STATE_UNPREPARED && __audioInState >= AUDIOIN_STATE_PREPARED, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioIn state is not proper.");
 155         return _AUDIO_IN_MINIMUM_BUFFER_SIZE;
 156 CATCH:
 157         SetLastResult(r);
 158         return -1;
 159 }
 160
 161 AudioChannelType
 162 _AudioInImpl::GetOptimizedChannelType(void)
 163 {
 164         result r = E_SUCCESS;
 165         SetLastResult(r);
 166         return _AUDIO_IN_OPTIMAL_CHANNEL_TYPE;
 167 }
 168
 169
 170 int
 171 _AudioInImpl::GetOptimizedSampleRate(void)
 172 {
 173         result r = E_SUCCESS;
 174         SetLastResult(r);
 175         return _AUDIO_IN_OPTIMAL_SAMPLE_RATE;
 176 }
 177
 178 AudioSampleType
 179 _AudioInImpl::GetOptimizedSampleType(void)
 180 {
 181         result r = E_SUCCESS;
 182         SetLastResult(r);
 183         return _AUDIO_IN_OPTIMAL_SAMPLE_TYPE;
 184 }
 185
 186 AudioInState
 187 _AudioInImpl::GetState(void)
 188 {
 189         result r = E_SUCCESS;
 190         SysLog(NID_MEDIA, "The current state of AudioIn is %d", __audioInState);
 191         SetLastResult(r);
 192         return __audioInState;
 193 }
 194
 195 result
 196 _AudioInImpl::Prepare(AudioSampleType audioSampleType, AudioChannelType audioChannelType, int audioSampleRate)
 197 {
 198         result r = E_SUCCESS;
 199         int ret = 0;
 200
 201         SysTryReturnResult(NID_MEDIA, __audioInState == AUDIOIN_STATE_UNPREPARED || __audioInState == AUDIOIN_STATE_INITIALIZED, E_INVALID_STATE, "AudioIn state is not proper.");
 202         SysTryReturnResult(NID_MEDIA, audioSampleType == AUDIO_TYPE_PCM_U8 || audioSampleType == AUDIO_TYPE_PCM_S16_LE, E_INVALID_ARG,
 203                                 "Invalid argument is used. Audio sample is type is not valid.");
 204         SysTryReturnResult(NID_MEDIA, audioChannelType == AUDIO_CHANNEL_TYPE_MONO || audioChannelType == AUDIO_CHANNEL_TYPE_STEREO, E_INVALID_ARG,
 205                                 "Invalid argument is used. Audio channel type is not valid");
 206         SysTryReturnResult(NID_MEDIA, audioSampleRate >= 8000 && audioSampleRate <= 48000, E_INVALID_ARG,
 207                                 "Invalid argument is used. Audio sample rate is not valid.");
 208
 209         ret = audio_in_create(audioSampleRate, _AudioManagerConvert::ConvertChannelTypeAudio(audioChannelType), _AudioManagerConvert::ConvertSampleTypeAudio(audioSampleType), &__audioInHandle);
 210         r = MapExceptionToResult(ret);
 211         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
 212                         "[%s] Failed to perform audio_in_create operation with error code : 0x%x", GetErrorMessage(r), ret);
 213
 214         ret = audio_in_set_interrupted_cb(__audioInHandle, AudioIoInterrupted, this);
 215         r = MapExceptionToResult(ret);
 216         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
 217                         "[%s] Failed to perform audio_in_set_interrupted_cb operation with error code : 0x%x", GetErrorMessage(r), ret);
 218
 219         ret = audio_in_get_buffer_size(__audioInHandle, &__audioInOptimalBufferSize);
 220         if (ret == AUDIO_IO_ERROR_NONE)
 221         {
 222                 SysLog(NID_MEDIA, "The optimal buffer size is %d", __audioInOptimalBufferSize);
 223         }
 224         else
 225         {
 226                 r = MapExceptionToResult(ret);
 227                 SysLogException(NID_MEDIA, r, "[%s] Failed to perform audio_out_get_buffer_size operation with error code : 0x%x",GetErrorMessage(r), ret);
 228         }
 229
 230         __audioInState = AUDIOIN_STATE_PREPARED;
 231         return r;
 232
 233 CATCH:
 234         __audioInHandle = null;
 235         SysLog(NID_MEDIA, "This function is failed in %s with error code : %x. And the value of __audioInOptimalBufferSize is %x\n", __FUNCTION__, r, __audioInOptimalBufferSize);
 236         return r;
 237 }
 238
 239 result
 240 _AudioInImpl::Reset(void)
 241 {
 242         result r = E_SUCCESS;
 243         SysTryReturnResult(NID_MEDIA, __audioInState <AUDIOIN_STATE_UNPREPARED && __audioInState> AUDIOIN_STATE_PREPARED, E_INVALID_STATE,
 244                                                 "AudioIn state is in an invalid state. the current state is %d.", __audioInState);
 245         if (__audioInState == AUDIOIN_STATE_RECORDING )
 246         {
 247                 Stop();
 248         }
 249         __bufferQueue.RemoveAll();
 250         __audioInState = AUDIOIN_STATE_PREPARED;
 251         return r;
 252 }
 253
 254 result
 255 _AudioInImpl::Unprepare(void)
 256 {
 257         result r = E_SUCCESS;
 258         int ret = 0;
 259         SysTryReturnResult(NID_MEDIA, __audioInState == AUDIOIN_STATE_PREPARED || __audioInState == AUDIOIN_STATE_STOPPED, E_INVALID_STATE,
 260                                 "AudioIn state is in an invalid state. the current state is  %d", __audioInState);
 261         __bufferQueue.RemoveAll();
 262         __audioInState = AUDIOIN_STATE_UNPREPARED;
 263
 264         if (__audioInHandle)
 265         {
 266                 ret = audio_in_unset_interrupted_cb(__audioInHandle);
 267                 r = MapExceptionToResult(ret);
 268                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
 269                                         "[%s] Failed to perform audio_in_unset_interrupted_cb operation with error code : 0x%x", GetErrorMessage(r), ret);
 270
 271                 ret = audio_in_destroy(__audioInHandle);
 272                 r = MapExceptionToResult(ret);
 273                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
 274                                         "[%s] Failed to perform audio_in_destroy operation with error code : 0x%x", GetErrorMessage(r), ret);
 275         }
 276         __audioInHandle = null;
 277         return r;
 278 CATCH:
 279         __audioInState = AUDIOIN_STATE_INITIALIZED;
 280         return r;
 281 }
 282
 283 result
 284 _AudioInImpl::Start(void)
 285 {
 286         result r = E_SUCCESS;
 287         int ret = AUDIO_IO_ERROR_NONE;
 288         SysTryReturnResult(NID_MEDIA, __audioInState == AUDIOIN_STATE_PREPARED || __audioInState == AUDIOIN_STATE_STOPPED, E_INVALID_STATE,
 289                                 "AudioIn state is in an invalid state");
 290         SysTryCatch(NID_MEDIA, __bufferQueue.GetCount() > 0, r = E_SYSTEM, E_SYSTEM,
 291                                 "[E_SYSTEM] A system error has been occurred. There is no buffers queued.");
 292
 293         ret = audio_in_prepare(__audioInHandle);
 294         r = MapExceptionToResult(ret);
 295         SysTryReturnResult(NID_MEDIA, r != E_DEVICE_BUSY, E_DEVICE_BUSY, "AudioIn cannot Start, higher priority task at work.");
 296         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform audio_in_prepare operation with error code : %x", GetErrorMessage(r), ret);
 297
 298         __pWorkerThread.reset(new (std::nothrow) Thread);
 299         SysTryCatch(NID_MEDIA, __pWorkerThread.get(), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 300
 301         r = __pWorkerThread->Construct(*this);
 302         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, r, "[%s]  Propagating.", GetErrorMessage(r));
 303
 304         __runFlag = true;
 305         r = __pWorkerThread->Start();
 306         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, r, "[%s]  Propagating.", GetErrorMessage(r));
 307
 308         __audioInState = AUDIOIN_STATE_RECORDING;
 309         return r;
 310 CATCH:
 311         if (__runFlag)
 312         {
 313                 ret = audio_in_unprepare(__audioInHandle);
 314                 SysTryLog(NID_MEDIA, ret == AUDIO_IO_ERROR_NONE, "Failed to perform audio_in_unprepare operation with error code : %x", ret);
 315         }
 316         SetLastResult(r);
 317         __audioInState = AUDIOIN_STATE_ERROR;
 318         return r;
 319 }
 320
 321 result
 322 _AudioInImpl::Stop(void)
 323 {
 324         result r = E_SUCCESS;
 325         SysTryReturnResult(NID_MEDIA, __audioInState == AUDIOIN_STATE_RECORDING, E_INVALID_STATE,
 326                                 "The state of AudioIn is in an invalied state. the current state is %d", __audioInState);
 327         __runFlag = false;
 328
 329         if (__pWorkerThread.get())
 330         {
 331                 r = __pBufferSync->Enter();
 332                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 333                 r = __pBufferSync->Notify();
 334                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 335                 r = __pBufferSync->Exit();
 336                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 337                 r = __pWorkerThread->Join();
 338                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 339         }
 340         else
 341         {
 342                 SysLog(NID_MEDIA, "There is no thread to stop.");
 343         }
 344
 345         __audioInState = AUDIOIN_STATE_STOPPED;
 346         return r;
 347 }
 348
 349 result
 350 _AudioInImpl::AddBuffer(const Tizen::Base::ByteBuffer* pByteBuffer)
 351 {
 352         result r = E_SUCCESS;
 353
 354         TryReturn(__audioInState >= AUDIOIN_STATE_PREPARED && __audioInState < AUDIOIN_STATE_UNPREPARED, E_INVALID_STATE, "AudioIn state is not proper.");
 355         SysTryReturnResult(NID_MEDIA, __audioInState >= AUDIOIN_STATE_PREPARED && __audioInState < AUDIOIN_STATE_UNPREPARED, E_INVALID_STATE, "AudioIn state is not proper.");
 356         SysTryReturnResult(NID_MEDIA, (pByteBuffer->GetCapacity() >= _AUDIO_IN_MINIMUM_BUFFER_SIZE), E_INVALID_ARG,
 357                 "Invalid argument is used. The size of buffer is too small, the current size is %d. The size of buffer should be between %d and %d",
 358                 pByteBuffer->GetCapacity(), _AUDIO_IN_MINIMUM_BUFFER_SIZE, _AUDIO_IN_MAXIMUM_BUFFER_SIZE);
 359         SysTryReturnResult(NID_MEDIA, _AUDIO_IN_MAXIMUM_BUFFER_SIZE >= pByteBuffer->GetCapacity(), E_OVERFLOW,
 360                 "Invalid argument is used. The size of buffer is too big, the current size is %d. The size of buffer should be between %d and %d", pByteBuffer->GetCapacity(), _AUDIO_IN_MINIMUM_BUFFER_SIZE, _AUDIO_IN_MAXIMUM_BUFFER_SIZE);
 361
 362         r = __pBufferSync->Enter();
 363         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 364
 365         r = __bufferQueue.Enqueue((const ByteBuffer*) (pByteBuffer));
 366         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 367
 368         r = __pBufferSync->Notify();
 369         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 370
 371         r = __pBufferSync->Exit();
 372         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  Propagating.", GetErrorMessage(r));
 373         return r;
 374 }
 375
 376 Tizen::Base::Object*
 377 _AudioInImpl::Run(void)
 378 {
 379         ByteBuffer* pBuffer = null;
 380         int buffer_size = 0;
 381         unsigned char* pData = null;
 382         unsigned char* pInitialPointer = null;
 383         int ret = 0;
 384         result r = E_SUCCESS;
 385
 386         while (__runFlag)
 387         {
 388                 r = __pBufferSync->Enter();
 389                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 390                 if (__bufferQueue.Peek((const Tizen::Base::ByteBuffer * &)pBuffer) == E_UNDERFLOW)
 391                 {
 392                         //wait
 393                         __pBufferSync->Wait();
 394                         if (!__runFlag)
 395                         {
 396                                 r = __pBufferSync->Exit();
 397                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 398                                 ret = audio_in_unprepare(__audioInHandle);
 399                                 SysTryLog(NID_MEDIA, ret == AUDIO_IO_ERROR_NONE, "Failed to perform audio_in_unprepare operation with error code : %x", ret);
 400                                 return this;
 401                         }
 402                         r = __bufferQueue.Peek((const Tizen::Base::ByteBuffer * &)pBuffer);
 403                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 404                 }
 405                 r = __pBufferSync->Exit();
 406                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 407
 408                 buffer_size = pBuffer->GetCapacity();
 409                 pData = (unsigned char*) pBuffer->GetPointer();
 410                 SysTryCatch(NID_MEDIA, pData != null, r = E_INVALID_ARG, r, "Invalid argument is used. Data to read is null.");
 411
 412                 if (__runFlag)
 413                 {
 414                         ret = audio_in_read(__audioInHandle, (void*) pData, buffer_size);
 415                         if (ret != buffer_size)
 416                         {
 417                                 SysLog(NID_MEDIA, "The size of data read is smaller than buffer size");
 418                         }
 419                         else
 420                         {
 421                                 __pBufferSync->Enter();
 422                                 r = __bufferQueue.Dequeue((const Tizen::Base::ByteBuffer * &)pBuffer);
 423                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 424
 425                                 r = __pBufferSync->Exit();
 426                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 427
 428                                 pInitialPointer = (unsigned char*) pBuffer->GetPointer();
 429                                 if (pInitialPointer)
 430                                 {
 431                                         pBuffer->SetPosition(pData - pInitialPointer);
 432                                 }
 433                                 SendBufferEndReachedEvent(pBuffer);
 434                         }
 435                 }
 436         }
 437         ret = audio_in_unprepare(__audioInHandle);
 438         SysTryLog(NID_MEDIA, ret == AUDIO_IO_ERROR_NONE, "Failed to perform audio_in_unprepare operation with error code : %x", ret);
 439         SysLog(NID_MEDIA, "AudioIn thread is terminated.");
 440         return null;
 441 CATCH:
 442         ret = audio_in_unprepare(__audioInHandle);
 443         SysTryLog(NID_MEDIA, ret == AUDIO_IO_ERROR_NONE, "Failed to perform audio_in_unprepare operation with error code : %x", ret);
 444         return null;
 445 }
 446
 447 void
 448 _AudioInImpl::AudioIoInterrupted(audio_io_interrupted_code_e code, void *pUserData)
 449 {
 450         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
 451         _AudioInImpl *pAudioInImpl = (_AudioInImpl *)pUserData;
 452
 453         switch (code)
 454         {
 455         case AUDIO_IO_INTERRUPTED_COMPLETED:
 456                 if (pAudioInImpl->__audioInState == AUDIOIN_STATE_STOPPED)
 457                 {
 458                         if (!(pAudioInImpl->__interruptFlag))
 459                         {
 460                                 pAudioInImpl->SendReleased();
 461                         }
 462                         pAudioInImpl->__interruptFlag = false;
 463                 }
 464                 break;
 465         case AUDIO_IO_INTERRUPTED_BY_CALL:
 466                 pAudioInImpl->__interruptFlag = true;
 467                 //Intentional Fall through
 468         case AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG:
 469                 //Intentional Fall through
 470         case AUDIO_IO_INTERRUPTED_BY_MEDIA:
 471                 //Intentional Fall through
 472         case AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT:
 473                 //Intentional Fall through
 474                 if (pAudioInImpl->__audioInState == AUDIOIN_STATE_RECORDING)
 475                 {
 476                         pAudioInImpl->SendAudioFocusChanged();
 477                 }
 478                 break;
 479         case AUDIO_IO_INTERRUPTED_BY_ALARM:
 480                 //Intentional Fall through
 481         case AUDIO_IO_INTERRUPTED_BY_EMERGENCY:
 482                 if (pAudioInImpl->__audioInState == AUDIOIN_STATE_RECORDING)
 483                 {
 484                         pAudioInImpl->SendInterrupted();
 485                 }
 486                 break;
 487         default:
 488                 SysLog(NID_MEDIA, "Interrupt code obtained is wrong, the code is %d", code);
 489                 break;
 490         }
 491 }
 492
 493 result
 494 _AudioInImpl::SendBufferEndReachedEvent(Tizen::Base::ByteBuffer* pBuffer)
 495 {
 496         _AudioInEventArg* pAudioInEventArg = null;
 497
 498         pAudioInEventArg = new (std::nothrow) _AudioInEventArg;
 499         TryReturn(pAudioInEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 500
 501         pAudioInEventArg->SetData(pBuffer);
 502
 503         pAudioInEventArg->SetEventType(_AUDIOIN_EVENT_RECORDED_DATA);
 504
 505         __pAudioInEvent->FireAsync(*pAudioInEventArg);
 506         return E_SUCCESS;
 507 }
 508
 509
 510 result
 511 _AudioInImpl::SendInterrupted(void)
 512 {
 513         result r = E_SUCCESS;
 514         _AudioInEventArg* pAudioInEventArg = null;
 515         pAudioInEventArg = new (std::nothrow) _AudioInEventArg;
 516         SysTryReturnResult(NID_MEDIA, pAudioInEventArg != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 517         this->Stop();
 518         pAudioInEventArg->SetEventType(_AUDIOIN_EVENT_INTERRUPTED);
 519         r = __pAudioInEvent->FireAsync(*pAudioInEventArg);
 520         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 521         return r;
 522 CATCH:
 523         delete pAudioInEventArg;
 524         return r;
 525 }
 526
 527 result
 528 _AudioInImpl::SendAudioFocusChanged(void)
 529 {
 530         result r = E_SUCCESS;
 531         _AudioInEventArg* pAudioInEventArg = null;
 532         pAudioInEventArg = new (std::nothrow) _AudioInEventArg;
 533         SysTryReturnResult(NID_MEDIA, pAudioInEventArg != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 534         this->Stop();
 535         pAudioInEventArg->SetEventType(_AUDIOIN_EVENT_AUDIO_FOCUS_CHANGED);
 536         r = __pAudioInEvent->FireAsync(*pAudioInEventArg);
 537         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 538         return r;
 539 CATCH:
 540         delete pAudioInEventArg;
 541         return r;
 542 }
 543
 544 result
 545 _AudioInImpl::SendReleased(void)
 546 {
 547         result r = E_SUCCESS;
 548         _AudioInEventArg* pAudioInEventArg = null;
 549         pAudioInEventArg = new (std::nothrow) _AudioInEventArg;
 550         SysTryReturnResult(NID_MEDIA, pAudioInEventArg != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 551         pAudioInEventArg->SetEventType(_AUDIOIN_EVENT_RELEASED);
 552         r = __pAudioInEvent->FireAsync(*pAudioInEventArg);
 553         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(r));
 554         return r;
 555 CATCH:
 556         delete pAudioInEventArg;
 557         return r;
 558 }
 559
 560 result
 561 _AudioInImpl::MapExceptionToResult(int reason)
 562 {
 563         //All the fall through are intentional
 564         switch (reason)
 565         {
 566         //Successful
 567         case AUDIO_IO_ERROR_NONE:
 568                 return E_SUCCESS;
 569                 break;
 570         //Out of memory
 571         case AUDIO_IO_ERROR_OUT_OF_MEMORY:
 572                 return E_OUT_OF_MEMORY;
 573                 break;
 574         //Invalid parameter
 575         case AUDIO_IO_ERROR_INVALID_PARAMETER:
 576                 return E_INVALID_ARG;
 577                 break;
 578         //Invalid operation
 579         case AUDIO_IO_ERROR_INVALID_OPERATION:
 580                 return E_INVALID_OPERATION;
 581                 break;
 582         //Device not opened
 583         case AUDIO_IO_ERROR_DEVICE_NOT_OPENED:
 584                 return E_INVALID_STATE;
 585                 break;
 586         //invalid buffer
 587         case AUDIO_IO_ERROR_INVALID_BUFFER:
 588                 return E_INVALID_ARG;
 589                 break;
 590         //Device not closed
 591         case AUDIO_IO_ERROR_DEVICE_NOT_CLOSED:
 592                 return E_INVALID_STATE;
 593                 break;
 594         //Sound policy error
 595         case AUDIO_IO_ERROR_SOUND_POLICY:
 596                 return E_DEVICE_BUSY;
 597                 break;
 598         default:
 599                 return E_SYSTEM;
 600                 break;
 601         }
 602 }
 603
 604 }} //Tizen::Media