src/cpp/CAudioInput.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <new>
  19
  20 #include <pulse/pulseaudio.h>
  21 #include "CAudioIODef.h"
  22 #include <sched.h>
  23
  24 #define RECORDER_PRIVILEGE "http://tizen.org/privilege/recorder"
  25 #define CLIENT_NAME "AUDIO_IO_PA_CLIENT"
  26
  27 using namespace std;
  28 using namespace tizen_media_audio;
  29
  30 struct PrivilegeData {
  31     bool isPrivilegeAllowed;
  32     pa_threaded_mainloop *paMainloop;
  33 };
  34
  35 /**
  36  * class CAudioInput inherited by CAudioIO
  37  */
  38 CAudioInput::CAudioInput(CAudioInfo& info) :
  39     CAudioIO(info),
  40     __mIsUsedSyncRead(true),
  41     __mIsInit(false) {
  42     mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN;
  43 }
  44
  45 CAudioInput::CAudioInput(
  46         unsigned int            sampleRate,
  47         CAudioInfo::EChannel    channel,
  48         CAudioInfo::ESampleType type,
  49         CAudioInfo::EAudioType  audioType) :
  50     __mIsUsedSyncRead(true),
  51     __mIsInit(false) {
  52     mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN;
  53     mAudioInfo = CAudioInfo(sampleRate, channel, type, audioType, -1);
  54 }
  55
  56 CAudioInput::~CAudioInput() {
  57 }
  58
  59 void CAudioInput::onStream(CPulseAudioClient* pClient, size_t length) {
  60     assert(pClient);
  61
  62     /*
  63      * Does not call CAudioIO::onStream() for synchronization
  64      * if a user is using read()
  65      */
  66     if (__mIsUsedSyncRead == true) {
  67 #ifdef _AUDIO_IO_DEBUG_TIMING_
  68         AUDIO_IO_LOGD("Sync Read Mode! - pClient:[%p], length:[%d]", pClient, length);
  69 #endif
  70         return;
  71     }
  72
  73     /*
  74      * Accrues callback function
  75      */
  76 #ifdef _AUDIO_IO_DEBUG_TIMING_
  77     AUDIO_IO_LOGD("pClient:[%p], length:[%d]", pClient, length);
  78 #endif
  79     CAudioIO::onStream(pClient, length);
  80 }
  81
  82 void CAudioInput::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type,
  83                               mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info) {
  84     assert(pHandler);
  85     AUDIO_IO_LOGD("[pHandler:%p], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s]",
  86                    pHandler, focus_type, state, reason_for_change, additional_info);
  87     CAudioIO::onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info);
  88 }
  89
  90 void CAudioInput::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t signal, int value) {
  91     assert(pHandler);
  92     AUDIO_IO_LOGD("[pHandler:%p], [signal:%d], [value:%d]", pHandler, signal, value);
  93     CAudioIO::onSignal(pHandler, signal, value);
  94 }
  95
  96 void CAudioInput::__setInit(bool flag) {
  97     __mIsInit = flag;
  98 }
  99
 100 bool CAudioInput::__IsInit() {
 101     return (CAudioIO::isInit() == true && __mIsInit == true);
 102 }
 103
 104 bool CAudioInput::__IsReady() {
 105     return CAudioIO::IsReady();
 106 }
 107
 108 static void __contextStateChangeCb(pa_context* c, void* user_data) {
 109     pa_threaded_mainloop *paMainloop = static_cast<pa_threaded_mainloop*>(user_data);
 110     assert(paMainloop);
 111     assert(c);
 112
 113     switch (pa_context_get_state(c)) {
 114     case PA_CONTEXT_READY:
 115         AUDIO_IO_LOGD("The context is ready");
 116         pa_threaded_mainloop_signal(paMainloop, 0);
 117         break;
 118
 119     case PA_CONTEXT_FAILED:
 120     case PA_CONTEXT_TERMINATED:
 121         AUDIO_IO_LOGD("The context is lost");
 122         pa_threaded_mainloop_signal(paMainloop, 0);
 123         break;
 124
 125     case PA_CONTEXT_UNCONNECTED:
 126     case PA_CONTEXT_CONNECTING:
 127     case PA_CONTEXT_AUTHORIZING:
 128     case PA_CONTEXT_SETTING_NAME:
 129         break;
 130     }
 131 }
 132
 133 static void __checkPrivilegeCb(pa_context *c, int success, void *user_data) {
 134     AUDIO_IO_LOGD("pa_context[%p], success[%d], user_data[%p]", c, success, user_data);
 135     assert(c);
 136     assert(user_data);
 137
 138     PrivilegeData *prData = static_cast<PrivilegeData*>(user_data);
 139     prData->isPrivilegeAllowed = success ? true : false;
 140
 141     pa_threaded_mainloop_signal(prData->paMainloop, 0);
 142 }
 143
 144 static bool __IsPrivilegeAllowed() {
 145     pa_operation *o;
 146     pa_context *c;
 147     int err = 0;
 148     PrivilegeData prData;
 149
 150     prData.paMainloop = pa_threaded_mainloop_new();
 151     if (prData.paMainloop == NULL)
 152         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_threaded_mainloop_new()");
 153     c = pa_context_new(pa_threaded_mainloop_get_api(prData.paMainloop), CLIENT_NAME);
 154     if (c == NULL)
 155         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_new()");
 156
 157     pa_context_set_state_callback(c, __contextStateChangeCb, prData.paMainloop);
 158
 159     if (pa_context_connect(c, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0)
 160         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_connect()");
 161
 162     pa_threaded_mainloop_lock(prData.paMainloop);
 163
 164     if (pa_threaded_mainloop_start(prData.paMainloop) < 0) {
 165         pa_threaded_mainloop_unlock(prData.paMainloop);
 166         THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_threaded_mainloop_start()");
 167     }
 168
 169     while (true) {
 170         pa_context_state_t state;
 171         state = pa_context_get_state(c);
 172
 173         if (state == PA_CONTEXT_READY)
 174             break;
 175
 176         if (!PA_CONTEXT_IS_GOOD(state)) {
 177             err = pa_context_errno(c);
 178             pa_threaded_mainloop_unlock(prData.paMainloop);
 179             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION,
 180                                    "pa_context's state is not good : err[%d]", err);
 181         }
 182
 183         /* Wait until the context is ready */
 184         pa_threaded_mainloop_wait(prData.paMainloop);
 185     }
 186
 187     o = pa_context_check_privilege(c, RECORDER_PRIVILEGE, __checkPrivilegeCb, &prData);
 188     if (!o) {
 189         pa_threaded_mainloop_unlock(prData.paMainloop);
 190         THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed to pa_context_check_privilege()");
 191     }
 192     while (pa_operation_get_state(o) == PA_OPERATION_RUNNING)
 193         pa_threaded_mainloop_wait(prData.paMainloop);
 194     pa_operation_unref(o);
 195
 196     pa_threaded_mainloop_unlock(prData.paMainloop);
 197     pa_threaded_mainloop_stop(prData.paMainloop);
 198     pa_context_disconnect(c);
 199     pa_context_unref(c);
 200     pa_threaded_mainloop_free(prData.paMainloop);
 201
 202     return prData.isPrivilegeAllowed;
 203 }
 204
 205 void CAudioInput::initialize() {
 206     if (__IsInit() == true) {
 207         return;
 208     }
 209
 210     try {
 211         CAudioIO::initialize();
 212         if (__IsPrivilegeAllowed() == false) {
 213             THROW_ERROR_MSG(CAudioError::EError::ERROR_PERMISSION_DENIED, "No privilege for record");
 214         }
 215
 216         // Create ASM Handler
 217         mpAudioSessionHandler = new CAudioSessionHandler(CAudioSessionHandler::EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE, mAudioInfo, this);
 218
 219         // Initialize ASM Handler
 220         mpAudioSessionHandler->initialize();
 221
 222         __setInit(true);
 223         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
 224     } catch (CAudioError& e) {
 225         finalize();
 226         throw;
 227     } catch (const std::bad_alloc&) {
 228         finalize();
 229         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
 230     }
 231 }
 232
 233 void CAudioInput::finalize() {
 234     if (__IsInit() == false) {
 235         AUDIO_IO_LOGD("Did not initialize");
 236         return;
 237     }
 238
 239     SAFE_FINALIZE(mpAudioSessionHandler);
 240     SAFE_DELETE(mpAudioSessionHandler);
 241
 242     CAudioIO::finalize();
 243
 244     __setInit(false);
 245 }
 246
 247 void CAudioInput::prepare() {
 248     if (__IsInit() == false) {
 249         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
 250     }
 251
 252     if (__IsReady() == true) {
 253         AUDIO_IO_LOGD("Already prepared CAudioInput");
 254         CAudioIO::prepare();
 255         return;
 256     }
 257
 258     try {
 259         internalLock();
 260
 261         // Check to invalid AudioType
 262         CAudioInfo::EAudioType audioType = mAudioInfo.getAudioType();
 263         if (audioType < CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA || audioType >= CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA) {
 264             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
 265                                    "The audioType is invalid [type:%d]", static_cast<int>(audioType));
 266         }
 267
 268         if (mpAudioSessionHandler->getId() < 0) {  // Did not registerSound()
 269             // Check session to skip registration
 270             if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false) {
 271                 // Register ASM Listener
 272                 AUDIO_IO_LOGD("Register ASM Listener");
 273                 mpAudioSessionHandler->registerSound();
 274             }
 275         }
 276
 277         CAudioIO::setInternalStreamInfo();
 278
 279         // Init StreamSpec
 280         AUDIO_IO_LOGD("Set Stream Spec : CPulseStreamSpec::STREAM_LATENCY_INPUT_DEFAULT");
 281         CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT;
 282         CPulseStreamSpec spec(streamSpec, mAudioInfo);
 283
 284         // Create PulseAudio Handler
 285         mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_RECORD, spec, this);
 286
 287         if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false)
 288             mpAudioSessionHandler->updatePlaying();
 289
 290         // Initialize PulseAudio Handler
 291         mpPulseAudioClient->initialize();
 292 #ifndef DISABLE_MOBILE_BACK_COMP
 293         // Uncork stream which is created with CORKED flag */
 294         mpPulseAudioClient->cork(false);
 295 #endif
 296
 297         internalUnlock();
 298
 299         // Do Prepare
 300         CAudioIO::prepare();
 301     } catch (CAudioError& e) {
 302         SAFE_FINALIZE(mpPulseAudioClient);
 303         SAFE_DELETE(mpPulseAudioClient);
 304         internalUnlock();
 305         throw;
 306     } catch (const std::bad_alloc&) {
 307         internalUnlock();
 308         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
 309     }
 310 }
 311
 312 void CAudioInput::unprepare() {
 313     if (__IsInit() == false) {
 314         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 315                         "Did not initialize CAudioInput");
 316     }
 317
 318     if (__IsReady() == false) {
 319         AUDIO_IO_LOGD("Already unprepared");
 320         return;
 321     }
 322
 323     try {
 324         CAudioIO::unprepare();
 325
 326         internalLock();
 327
 328         SAFE_FINALIZE(mpPulseAudioClient);
 329         SAFE_DELETE(mpPulseAudioClient);
 330
 331         internalUnlock();
 332
 333         if (mpAudioSessionHandler->getId() >= 0) {
 334             if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false)
 335                 mpAudioSessionHandler->updateStop();
 336         }
 337
 338         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
 339     } catch (CAudioError& e) {
 340         internalUnlock();
 341         throw;
 342     }
 343 }
 344
 345 void CAudioInput::pause() {
 346     if (__IsInit() == false || __IsReady() == false) {
 347         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 348                         "Did not initialize or prepare CAudioInput");
 349     }
 350
 351     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
 352         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE,
 353                         "Can't pause if not in Running state");
 354     }
 355
 356     if (mpPulseAudioClient->isInThread() == true) {
 357         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_OPERATION, "Can't pause in thread");
 358     }
 359
 360     try {
 361         CAudioIO::pause();
 362
 363         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
 364     } catch (CAudioError& e) {
 365         throw;
 366     }
 367 }
 368
 369 void CAudioInput::resume() {
 370     if (__IsInit() == false || __IsReady() == false) {
 371         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 372                         "Did not initialize or prepare CAudioInput");
 373     }
 374
 375     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED) {
 376         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE,
 377                         "Can't resume if not in Paused state");
 378     }
 379
 380     if (mpPulseAudioClient->isInThread() == true) {
 381         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_OPERATION, "Can't resume in thread");
 382     }
 383
 384     try {
 385         CAudioIO::resume();
 386
 387         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
 388     } catch (CAudioError& e) {
 389         throw;
 390     }
 391 }
 392
 393 void CAudioInput::drain() {
 394     THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "Did not support drain of CAudioInput");
 395 }
 396
 397 void CAudioInput::flush() {
 398     if (__IsInit() == false || __IsReady() == false) {
 399         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 400                         "Did not initialize or prepare CAudioInput");
 401     }
 402
 403     try {
 404         CAudioIO::flush();
 405     } catch (CAudioError& e) {
 406         throw;
 407     }
 408 }
 409
 410 int CAudioInput::getBufferSize() {
 411     if (__IsInit() == false) {
 412         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
 413     }
 414
 415     /* FIXME : return calculated size here to satisfy backward compatibility */
 416     return (mAudioInfo.getSampleRate() * DEFAULT_PERIOD_SIZE) / 1000 * mAudioInfo.getSampleSize();
 417 }
 418
 419 void CAudioInput::setStreamCallback(SStreamCallback callback) {
 420     if (__IsInit() == false) {
 421         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
 422     }
 423
 424     if (callback.onStream == NULL) {
 425         AUDIO_IO_LOGD("__mIsUsedSyncRead = true");
 426         __mIsUsedSyncRead = true;
 427     } else {
 428         AUDIO_IO_LOGD("__mIsUsedSyncRead = false");
 429         __mIsUsedSyncRead = false;
 430     }
 431
 432     CAudioIO::setStreamCallback(callback);
 433 }
 434
 435 size_t CAudioInput::read(void* buffer, size_t length) {
 436     if (__IsInit() == false || __IsReady() == false) {
 437         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 438                         "Did not initialize or prepare CAudioInput");
 439     }
 440     if (buffer == NULL) {
 441         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
 442                                "Parameters are NULL buffer:%p", buffer);
 443     }
 444     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
 445         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 446                         "Can't read if not in Running state");
 447     }
 448     /* Checks synchronous flag */
 449     if (__mIsUsedSyncRead == false) {
 450         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 451                         "Invalid operation of read() if receive stream callback");
 452     }
 453
 454     int ret = 0;
 455
 456     try {
 457         internalLock();
 458         if (mIsInterrupted) {
 459             THROW_ERROR_MSG(CAudioError::EError::ERROR_POLICY_BLOCKED, "audio-io is interrupted");
 460         }
 461
 462         // If another thread did call unprepare, do not read
 463         if (mpPulseAudioClient == NULL)
 464             THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 465                             "Did not initialize CPulseAudioClient");
 466
 467         // Block until read done
 468         ret = mpPulseAudioClient->read(buffer, length);
 469
 470         internalUnlock();
 471         sched_yield();
 472     } catch (CAudioError& e) {
 473         internalUnlock();
 474         throw;
 475     }
 476
 477     return ret;
 478 }
 479
 480 int CAudioInput::peek(const void** buffer, size_t* length) {
 481     if (__IsInit() == false || __IsReady() == false) {
 482         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 483                         "Did not initialize or prepare CAudioInput");
 484     }
 485
 486     if (buffer == NULL || length == NULL) {
 487         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
 488                                "Parameters are NULL buffer:%p, length:%p", buffer, length);
 489     }
 490
 491     /* Checks synchronous flag */
 492     if (__mIsUsedSyncRead == true) {
 493         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 494                         "Invalid operation of peek() if does not receive a stream callback");
 495     }
 496
 497     int ret = 0;
 498
 499     try {
 500         ret = mpPulseAudioClient->peek(buffer, length);
 501     } catch (CAudioError& e) {
 502         throw;
 503     }
 504
 505     return ret;
 506 }
 507
 508 int CAudioInput::drop() {
 509     if (__IsInit() == false || __IsReady() == false) {
 510         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 511                         "Did not initialize or prepare CAudioInput");
 512     }
 513
 514     /* Checks synchronous flag */
 515     if (__mIsUsedSyncRead == true) {
 516         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 517                         "Invalid operation of drop() if does not receive a stream callback");
 518     }
 519
 520     int ret = 0;
 521
 522     try {
 523         ret = mpPulseAudioClient->drop();
 524     } catch (CAudioError& e) {
 525         throw;
 526     }
 527
 528     return ret;
 529 }