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