Home | History | Annotate | Download | only in libcamera2 
      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 (at) samsung.com)
     23  * \date      2012/05/31
     24  *
     25  * <b>Revision History: </b>
     26  * - 2012/05/31 : Sungjoong Kang(sj3.kang (at) samsung.com) \n
     27  *   Initial Release
     28  *
     29  * - 2012/07/10 : Sungjoong Kang(sj3.kang (at) 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
    156