libcamera2/SignalDrivenThread.cpp

   1 /*
   2 **
   3 ** Copyright 2008, The Android Open Source Project
   4 ** Copyright 2012, Samsung Electronics Co. LTD
   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 /*!
  20  * \file      SignalDrivenThread.cpp
  21  * \brief     source file for general thread ( for camera hal2 implementation )
  22  * \author    Sungjoong Kang(sj3.kang@samsung.com)
  23  * \date      2012/05/31
  24  *
  25  * <b>Revision History: </b>
  26  * - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
  27  *   Initial Release
  28  *
  29  * - 2012/07/10 : Sungjoong Kang(sj3.kang@samsung.com) \n
  30  *   2nd Release
  31  *
  32  */
  33
  34 //#define LOG_NDEBUG 1
  35 #define LOG_TAG "SignalDrivenThread"
  36 #include <utils/Log.h>
  37
  38 #include "SignalDrivenThread.h"
  39
  40 namespace android {
  41
  42
  43 SignalDrivenThread::SignalDrivenThread()
  44     :Thread(false)
  45 {
  46     ALOGV("(SignalDrivenThread() ):");
  47     m_processingSignal = 0;
  48     m_receivedSignal = 0;
  49     m_pendingSignal = 0;
  50     m_isTerminated = false;
  51 }
  52
  53 void SignalDrivenThread::Start(const char* name,
  54                             int32_t priority, size_t stack)
  55 {
  56     ALOGV("DEBUG(SignalDrivenThread::Start() ):");
  57     run(name, priority, stack);
  58 }
  59 SignalDrivenThread::SignalDrivenThread(const char* name,
  60                             int32_t priority, size_t stack)
  61     :Thread(false)
  62 {
  63     ALOGV("DEBUG(SignalDrivenThread( , , )):");
  64     m_processingSignal = 0;
  65     m_receivedSignal = 0;
  66     m_pendingSignal = 0;
  67     m_isTerminated = false;
  68     run(name, priority, stack);
  69     return;
  70 }
  71
  72 SignalDrivenThread::~SignalDrivenThread()
  73 {
  74     ALOGD("DEBUG(%s):", __func__);
  75     return;
  76 }
  77
  78 status_t SignalDrivenThread::SetSignal(uint32_t signal)
  79 {
  80     ALOGV("DEBUG(%s):Setting Signal (%x)", __FUNCTION__, signal);
  81
  82     Mutex::Autolock lock(m_signalMutex);
  83     ALOGV("DEBUG(%s):Signal Set     (%x) - prev(%x)", __FUNCTION__, signal, m_receivedSignal);
  84     if (m_receivedSignal & signal) {
  85         m_pendingSignal |= signal;
  86     } else {
  87         m_receivedSignal |= signal;
  88     }
  89     m_threadCondition.signal();
  90     return NO_ERROR;
  91 }
  92
  93 uint32_t SignalDrivenThread::GetProcessingSignal()
  94 {
  95     ALOGV("DEBUG(%s): Signal (%x)", __FUNCTION__, m_processingSignal);
  96
  97     Mutex::Autolock lock(m_signalMutex);
  98     return m_processingSignal;
  99 }
 100
 101 bool SignalDrivenThread::IsTerminated()
 102 {
 103     Mutex::Autolock lock(m_signalMutex);
 104     return m_isTerminated;
 105 }
 106
 107 status_t SignalDrivenThread::readyToRun()
 108 {
 109     ALOGV("DEBUG(%s):", __func__);
 110     return readyToRunInternal();
 111 }
 112
 113 status_t SignalDrivenThread::readyToRunInternal()
 114 {
 115     ALOGV("DEBUG(%s):", __func__);
 116     return NO_ERROR;
 117 }
 118
 119 bool SignalDrivenThread::threadLoop()
 120 {
 121     {
 122         Mutex::Autolock lock(m_signalMutex);
 123         ALOGV("DEBUG(%s):Waiting Signal", __FUNCTION__);
 124         while (!m_receivedSignal)
 125         {
 126             m_threadCondition.wait(m_signalMutex);
 127         }
 128         m_processingSignal = m_receivedSignal;
 129         m_receivedSignal = m_pendingSignal;
 130         m_pendingSignal = 0;
 131     }
 132     ALOGV("DEBUG(%s):Got Signal (%x)", __FUNCTION__, m_processingSignal);
 133
 134     if (m_processingSignal & SIGNAL_THREAD_TERMINATE)
 135     {
 136         ALOGD("(%s): Thread Terminating by SIGNAL", __func__);
 137         Mutex::Autolock lock(m_signalMutex);
 138         m_isTerminated = true;
 139         return (false);
 140     }
 141     else if (m_processingSignal & SIGNAL_THREAD_PAUSE)
 142     {
 143         ALOGV("DEBUG(%s):Thread Paused", __func__);
 144         return (true);
 145     }
 146
 147     if (m_isTerminated)
 148         m_isTerminated = false;
 149
 150     threadFunctionInternal();
 151     return true;
 152 }
 153
 154
 155 }; // namespace android