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 0
  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("DEBUG(SignalDrivenThread() ):");
  47     m_processingSignal = 0;
  48     m_receivedSignal = 0;
  49 }
  50
  51 void SignalDrivenThread::Start(const char* name,
  52                             int32_t priority, size_t stack)
  53 {
  54     ALOGV("DEBUG(SignalDrivenThread::Start() ):");
  55     run(name, priority, stack);
  56 }
  57 SignalDrivenThread::SignalDrivenThread(const char* name,
  58                             int32_t priority, size_t stack)
  59     :Thread(false)
  60 {
  61     ALOGV("DEBUG(SignalDrivenThread( , , )):");
  62     m_processingSignal = 0;
  63     m_receivedSignal = 0;
  64     run(name, priority, stack);
  65     return;
  66 }
  67
  68 SignalDrivenThread::~SignalDrivenThread()
  69 {
  70     ALOGV("DEBUG(%s):", __FUNCTION__);
  71     return;
  72 }
  73
  74 status_t SignalDrivenThread::SetSignal(uint32_t signal)
  75 {
  76     ALOGV("DEBUG(%s):Setting Signal (%x)", __FUNCTION__, signal);
  77
  78     Mutex::Autolock lock(m_signalMutex);
  79     ALOGV("DEBUG(%s):Signal Set     (%x) - prev(%x)", __FUNCTION__, signal, m_receivedSignal);
  80     m_receivedSignal |= signal;
  81     m_threadCondition.signal();
  82     return NO_ERROR;
  83 }
  84
  85 uint32_t SignalDrivenThread::GetProcessingSignal()
  86 {
  87     ALOGV("DEBUG(%s): Signal (%x)", __FUNCTION__, m_processingSignal);
  88
  89     return m_processingSignal;
  90 }
  91
  92 /*
  93 void SignalDrivenThread::ClearProcessingSignal(uint32_t signal)
  94 {
  95     ALOGV("DEBUG(%s):Clearing Signal (%x) from (%x)", __func__, signal, m_processingSignal);
  96
  97     m_processingSignal &= ~(signal);
  98     return;
  99 }
 100 */
 101
 102 status_t SignalDrivenThread::readyToRun()
 103 {
 104     ALOGV("DEBUG(%s):", __func__);
 105     return readyToRunInternal();
 106 }
 107
 108
 109 bool SignalDrivenThread::threadLoop()
 110 {
 111     {
 112         Mutex::Autolock lock(m_signalMutex);
 113         ALOGV("DEBUG(%s):Waiting Signal", __FUNCTION__);
 114         while (!m_receivedSignal)
 115         {
 116             m_threadCondition.wait(m_signalMutex);
 117         }
 118         m_processingSignal = m_receivedSignal;
 119         m_receivedSignal = 0;
 120     }
 121     ALOGV("DEBUG(%s):Got Signal (%x)", __FUNCTION__, m_processingSignal);
 122
 123     if (m_processingSignal & SIGNAL_THREAD_TERMINATE)
 124     {
 125         ALOGV("DEBUG(%s):Thread Terminating", __FUNCTION__);
 126         return (false);
 127     }
 128     else if (m_processingSignal & SIGNAL_THREAD_PAUSE)
 129     {
 130         ALOGV("DEBUG(%s):Thread Paused", __FUNCTION__);
 131         return (true);
 132     }
 133
 134     threadFunctionInternal();
 135     return true;
 136 }
 137
 138
 139 }; // namespace android