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         return;
 255     }
 256
 257     try {
 258         internalLock();
 259
 260         // Check to invalid AudioType
 261         CAudioInfo::EAudioType audioType = mAudioInfo.getAudioType();
 262         if (audioType < CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA || audioType >= CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA) {
 263             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
 264                                    "The audioType is invalid [type:%d]", static_cast<int>(audioType));
 265         }
 266
 267         if (mpAudioSessionHandler->getId() < 0) {  // Did not registerSound()
 268             // Check session to skip registration
 269             if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false) {
 270                 // Register ASM Listener
 271                 AUDIO_IO_LOGD("Register ASM Listener");
 272                 mpAudioSessionHandler->registerSound();
 273             }
 274         }
 275
 276         CAudioIO::setInternalStreamInfo();
 277
 278         // Init StreamSpec
 279         AUDIO_IO_LOGD("Set Stream Spec : CPulseStreamSpec::STREAM_LATENCY_INPUT_DEFAULT");
 280         CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT;
 281         CPulseStreamSpec spec(streamSpec, mAudioInfo);
 282
 283         // Create PulseAudio Handler
 284         mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_RECORD, spec, this);
 285
 286         // Initialize PulseAudio Handler
 287         mpPulseAudioClient->initialize();
 288
 289         if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false)
 290             mpAudioSessionHandler->updatePlaying();
 291
 292         internalUnlock();
 293
 294         // Do Prepare
 295         CAudioIO::prepare();
 296     } catch (CAudioError& e) {
 297         internalUnlock();
 298         throw;
 299     } catch (const std::bad_alloc&) {
 300         internalUnlock();
 301         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
 302     }
 303 }
 304
 305 void CAudioInput::unprepare() {
 306     if (__IsInit() == false) {
 307         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 308                         "Did not initialize CAudioInput");
 309     }
 310
 311     if (__IsReady() == false) {
 312         AUDIO_IO_LOGD("Already unprepared");
 313         return;
 314     }
 315
 316     try {
 317         CAudioIO::unprepare();
 318
 319         internalLock();
 320
 321         SAFE_FINALIZE(mpPulseAudioClient);
 322         SAFE_DELETE(mpPulseAudioClient);
 323
 324         internalUnlock();
 325
 326         if (mpAudioSessionHandler->getId() >= 0) {
 327             if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false)
 328                 mpAudioSessionHandler->updateStop();
 329
 330             if (mpAudioSessionHandler->isSkipSession() ==  false)
 331                 mpAudioSessionHandler->unregisterSound();
 332         }
 333
 334         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
 335     } catch (CAudioError& e) {
 336         internalUnlock();
 337         throw;
 338     }
 339 }
 340
 341 void CAudioInput::pause() {
 342     if (__IsInit() == false || __IsReady() == false) {
 343         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 344                         "Did not initialize or prepare CAudioInput");
 345     }
 346
 347     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
 348         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE,
 349                         "Can't pause if not in Running state");
 350     }
 351
 352     if (mpPulseAudioClient->isInThread() == true) {
 353         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_OPERATION, "Can't pause in thread");
 354     }
 355
 356     try {
 357         CAudioIO::pause();
 358
 359         internalLock();
 360
 361         /* Updates ASM to STOP */
 362         if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false) {
 363             mpAudioSessionHandler->updateStop();
 364         }
 365
 366         internalUnlock();
 367
 368         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
 369     } catch (CAudioError& e) {
 370         internalUnlock();
 371         throw;
 372     }
 373 }
 374
 375 void CAudioInput::resume() {
 376     if (__IsInit() == false || __IsReady() == false) {
 377         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 378                         "Did not initialize or prepare CAudioInput");
 379     }
 380
 381     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED) {
 382         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE,
 383                         "Can't resume if not in Paused state");
 384     }
 385
 386     if (mpPulseAudioClient->isInThread() == true) {
 387         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_OPERATION, "Can't resume in thread");
 388     }
 389
 390     try {
 391         internalLock();
 392
 393         if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSession() == false)
 394             mpAudioSessionHandler->updatePlaying();
 395
 396         internalUnlock();
 397
 398         CAudioIO::resume();
 399
 400         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
 401     } catch (CAudioError& e) {
 402         internalUnlock();
 403         throw;
 404     }
 405 }
 406
 407 void CAudioInput::drain() {
 408     THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "Did not support drain of CAudioInput");
 409 }
 410
 411 void CAudioInput::flush() {
 412     if (__IsInit() == false || __IsReady() == false) {
 413         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 414                         "Did not initialize or prepare CAudioInput");
 415     }
 416
 417     try {
 418         CAudioIO::flush();
 419     } catch (CAudioError& e) {
 420         throw;
 421     }
 422 }
 423
 424 int CAudioInput::getBufferSize() {
 425     if (__IsInit() == false) {
 426         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
 427     }
 428
 429     /* FIXME : return calculated size here to satisfy backward compatibility */
 430     return (mAudioInfo.getSampleRate() * DEFAULT_PERIOD_SIZE) / 1000 * mAudioInfo.getSampleSize();
 431 }
 432
 433 void CAudioInput::setStreamCallback(SStreamCallback callback) {
 434     if (__IsInit() == false) {
 435         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
 436     }
 437
 438     if (callback.onStream == NULL) {
 439         AUDIO_IO_LOGD("__mIsUsedSyncRead = true");
 440         __mIsUsedSyncRead = true;
 441     } else {
 442         AUDIO_IO_LOGD("__mIsUsedSyncRead = false");
 443         __mIsUsedSyncRead = false;
 444     }
 445
 446     CAudioIO::setStreamCallback(callback);
 447 }
 448
 449 size_t CAudioInput::read(void* buffer, size_t length) {
 450     if (__IsInit() == false || __IsReady() == false) {
 451         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 452                         "Did not initialize or prepare CAudioInput");
 453     }
 454     if (buffer == NULL) {
 455         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
 456                                "Parameters are NULL buffer:%p", buffer);
 457     }
 458     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
 459         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 460                         "Can't read if not in Running state");
 461     }
 462     /* Checks synchronous flag */
 463     if (__mIsUsedSyncRead == false) {
 464         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 465                         "Invalid operation of read() if receive stream callback");
 466     }
 467
 468     int ret = 0;
 469
 470     try {
 471         internalLock();
 472
 473         // If another thread did call unprepare, do not read
 474         if (mpPulseAudioClient == NULL)
 475             THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 476                             "Did not initialize CPulseAudioClient");
 477
 478         // Block until read done
 479         ret = mpPulseAudioClient->read(buffer, length);
 480
 481         internalUnlock();
 482         sched_yield();
 483     } catch (CAudioError& e) {
 484         internalUnlock();
 485         throw;
 486     }
 487
 488     return ret;
 489 }
 490
 491 int CAudioInput::peek(const void** buffer, size_t* length) {
 492     if (__IsInit() == false || __IsReady() == false) {
 493         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 494                         "Did not initialize or prepare CAudioInput");
 495     }
 496
 497     if (buffer == NULL || length == NULL) {
 498         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
 499                                "Parameters are NULL buffer:%p, length:%p", buffer, length);
 500     }
 501
 502     /* Checks synchronous flag */
 503     if (__mIsUsedSyncRead == true) {
 504         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 505                         "Invalid operation of peek() if does not receive a stream callback");
 506     }
 507
 508     int ret = 0;
 509
 510     try {
 511         ret = mpPulseAudioClient->peek(buffer, length);
 512     } catch (CAudioError& e) {
 513         throw;
 514     }
 515
 516     return ret;
 517 }
 518
 519 int CAudioInput::drop() {
 520     if (__IsInit() == false || __IsReady() == false) {
 521         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
 522                         "Did not initialize or prepare CAudioInput");
 523     }
 524
 525     /* Checks synchronous flag */
 526     if (__mIsUsedSyncRead == true) {
 527         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
 528                         "Invalid operation of drop() if does not receive a stream callback");
 529     }
 530
 531     int ret = 0;
 532
 533     try {
 534         ret = mpPulseAudioClient->drop();
 535     } catch (CAudioError& e) {
 536         throw;
 537     }
 538
 539     return ret;
 540 }