Home | History | Annotate | Download | only in drm_hwcomposer 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      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 #define LOG_TAG "hwc-drm-compositor-worker"
     18 
     19 #include "drmdisplaycompositor.h"
     20 #include "drmcompositorworker.h"
     21 #include "worker.h"
     22 
     23 #include <stdlib.h>
     24 
     25 #include <cutils/log.h>
     26 #include <hardware/hardware.h>
     27 
     28 namespace android {
     29 
     30 static const int64_t kSquashWait = 500000000LL;
     31 
     32 DrmCompositorWorker::DrmCompositorWorker(DrmDisplayCompositor *compositor)
     33     : Worker("drm-compositor", HAL_PRIORITY_URGENT_DISPLAY),
     34       compositor_(compositor) {
     35 }
     36 
     37 DrmCompositorWorker::~DrmCompositorWorker() {
     38 }
     39 
     40 int DrmCompositorWorker::Init() {
     41   return InitWorker();
     42 }
     43 
     44 void DrmCompositorWorker::Routine() {
     45   int ret;
     46   if (!compositor_->HaveQueuedComposites()) {
     47     ret = Lock();
     48     if (ret) {
     49       ALOGE("Failed to lock worker, %d", ret);
     50       return;
     51     }
     52 
     53     // Only use a timeout if we didn't do a SquashAll last time. This will
     54     // prevent wait_ret == -ETIMEDOUT which would trigger a SquashAll and be a
     55     // pointless drain on resources.
     56     int wait_ret = did_squash_all_ ? WaitForSignalOrExitLocked()
     57                                    : WaitForSignalOrExitLocked(kSquashWait);
     58 
     59     ret = Unlock();
     60     if (ret) {
     61       ALOGE("Failed to unlock worker, %d", ret);
     62       return;
     63     }
     64 
     65     switch (wait_ret) {
     66       case 0:
     67         break;
     68       case -EINTR:
     69         return;
     70       case -ETIMEDOUT:
     71         ret = compositor_->SquashAll();
     72         if (ret)
     73           ALOGE("Failed to squash all %d", ret);
     74         did_squash_all_ = true;
     75         return;
     76       default:
     77         ALOGE("Failed to wait for signal, %d", wait_ret);
     78         return;
     79     }
     80   }
     81 
     82   ret = compositor_->Composite();
     83   if (ret)
     84     ALOGE("Failed to composite! %d", ret);
     85   did_squash_all_ = false;
     86 }
     87 }
     88