1/*
2 * Copyright (C) 2011 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 ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19#include <stdint.h>
20#include <sys/types.h>
21
22#include <cutils/compiler.h>
23
24#include <gui/BitTube.h>
25#include <gui/IDisplayEventConnection.h>
26#include <gui/DisplayEventReceiver.h>
27
28#include <utils/Errors.h>
29#include <utils/String8.h>
30#include <utils/Trace.h>
31
32#include "EventThread.h"
33#include "SurfaceFlinger.h"
34
35// ---------------------------------------------------------------------------
36namespace android {
37// ---------------------------------------------------------------------------
38// time to wait between VSYNC requests before sending a VSYNC OFF power hint: 40msec.
39const long vsyncHintOffDelay = 40000000;
40
41static void vsyncOffCallback(union sigval val) {
42    EventThread *ev = (EventThread *)val.sival_ptr;
43    ev->sendVsyncHintOff();
44    return;
45}
46
47EventThread::EventThread(const sp<VSyncSource>& src, SurfaceFlinger& flinger)
48    : mVSyncSource(src),
49      mFlinger(flinger),
50      mUseSoftwareVSync(false),
51      mVsyncEnabled(false),
52      mDebugVsyncEnabled(false),
53      mVsyncHintSent(false) {
54
55    for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
56        mVSyncEvent[i].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
57        mVSyncEvent[i].header.id = 0;
58        mVSyncEvent[i].header.timestamp = 0;
59        mVSyncEvent[i].vsync.count =  0;
60    }
61    struct sigevent se;
62    se.sigev_notify = SIGEV_THREAD;
63    se.sigev_value.sival_ptr = this;
64    se.sigev_notify_function = vsyncOffCallback;
65    se.sigev_notify_attributes = NULL;
66    timer_create(CLOCK_MONOTONIC, &se, &mTimerId);
67}
68
69void EventThread::sendVsyncHintOff() {
70    Mutex::Autolock _l(mLock);
71    mPowerHAL.vsyncHint(false);
72    mVsyncHintSent = false;
73}
74
75void EventThread::setPhaseOffset(nsecs_t phaseOffset) {
76    Mutex::Autolock _l(mLock);
77    mVSyncSource->setPhaseOffset(phaseOffset);
78}
79
80void EventThread::sendVsyncHintOnLocked() {
81    struct itimerspec ts;
82    if(!mVsyncHintSent) {
83        mPowerHAL.vsyncHint(true);
84        mVsyncHintSent = true;
85    }
86    ts.it_value.tv_sec = 0;
87    ts.it_value.tv_nsec = vsyncHintOffDelay;
88    ts.it_interval.tv_sec = 0;
89    ts.it_interval.tv_nsec = 0;
90    timer_settime(mTimerId, 0, &ts, NULL);
91}
92
93void EventThread::onFirstRef() {
94    run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
95}
96
97sp<EventThread::Connection> EventThread::createEventConnection() const {
98    return new Connection(const_cast<EventThread*>(this));
99}
100
101status_t EventThread::registerDisplayEventConnection(
102        const sp<EventThread::Connection>& connection) {
103    Mutex::Autolock _l(mLock);
104    mDisplayEventConnections.add(connection);
105    mCondition.broadcast();
106    return NO_ERROR;
107}
108
109void EventThread::removeDisplayEventConnection(
110        const wp<EventThread::Connection>& connection) {
111    Mutex::Autolock _l(mLock);
112    mDisplayEventConnections.remove(connection);
113}
114
115void EventThread::setVsyncRate(uint32_t count,
116        const sp<EventThread::Connection>& connection) {
117    if (int32_t(count) >= 0) { // server must protect against bad params
118        Mutex::Autolock _l(mLock);
119        const int32_t new_count = (count == 0) ? -1 : count;
120        if (connection->count != new_count) {
121            connection->count = new_count;
122            mCondition.broadcast();
123        }
124    }
125}
126
127void EventThread::requestNextVsync(
128        const sp<EventThread::Connection>& connection) {
129    Mutex::Autolock _l(mLock);
130
131    mFlinger.resyncWithRateLimit();
132
133    if (connection->count < 0) {
134        connection->count = 0;
135        mCondition.broadcast();
136    }
137}
138
139void EventThread::onScreenReleased() {
140    Mutex::Autolock _l(mLock);
141    if (!mUseSoftwareVSync) {
142        // disable reliance on h/w vsync
143        mUseSoftwareVSync = true;
144        mCondition.broadcast();
145    }
146}
147
148void EventThread::onScreenAcquired() {
149    Mutex::Autolock _l(mLock);
150    if (mUseSoftwareVSync) {
151        // resume use of h/w vsync
152        mUseSoftwareVSync = false;
153        mCondition.broadcast();
154    }
155}
156
157void EventThread::onVSyncEvent(nsecs_t timestamp) {
158    Mutex::Autolock _l(mLock);
159    mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
160    mVSyncEvent[0].header.id = 0;
161    mVSyncEvent[0].header.timestamp = timestamp;
162    mVSyncEvent[0].vsync.count++;
163    mCondition.broadcast();
164}
165
166void EventThread::onHotplugReceived(int type, bool connected) {
167    ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES,
168            "received hotplug event for an invalid display (id=%d)", type);
169
170    Mutex::Autolock _l(mLock);
171    if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
172        DisplayEventReceiver::Event event;
173        event.header.type = DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG;
174        event.header.id = type;
175        event.header.timestamp = systemTime();
176        event.hotplug.connected = connected;
177        mPendingEvents.add(event);
178        mCondition.broadcast();
179    }
180}
181
182bool EventThread::threadLoop() {
183    DisplayEventReceiver::Event event;
184    Vector< sp<EventThread::Connection> > signalConnections;
185    signalConnections = waitForEvent(&event);
186
187    // dispatch events to listeners...
188    const size_t count = signalConnections.size();
189    for (size_t i=0 ; i<count ; i++) {
190        const sp<Connection>& conn(signalConnections[i]);
191        // now see if we still need to report this event
192        status_t err = conn->postEvent(event);
193        if (err == -EAGAIN || err == -EWOULDBLOCK) {
194            // The destination doesn't accept events anymore, it's probably
195            // full. For now, we just drop the events on the floor.
196            // FIXME: Note that some events cannot be dropped and would have
197            // to be re-sent later.
198            // Right-now we don't have the ability to do this.
199            ALOGW("EventThread: dropping event (%08x) for connection %p",
200                    event.header.type, conn.get());
201        } else if (err < 0) {
202            // handle any other error on the pipe as fatal. the only
203            // reasonable thing to do is to clean-up this connection.
204            // The most common error we'll get here is -EPIPE.
205            removeDisplayEventConnection(signalConnections[i]);
206        }
207    }
208    return true;
209}
210
211// This will return when (1) a vsync event has been received, and (2) there was
212// at least one connection interested in receiving it when we started waiting.
213Vector< sp<EventThread::Connection> > EventThread::waitForEvent(
214        DisplayEventReceiver::Event* event)
215{
216    Mutex::Autolock _l(mLock);
217    Vector< sp<EventThread::Connection> > signalConnections;
218
219    do {
220        bool eventPending = false;
221        bool waitForVSync = false;
222
223        size_t vsyncCount = 0;
224        nsecs_t timestamp = 0;
225        for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
226            timestamp = mVSyncEvent[i].header.timestamp;
227            if (timestamp) {
228                // we have a vsync event to dispatch
229                *event = mVSyncEvent[i];
230                mVSyncEvent[i].header.timestamp = 0;
231                vsyncCount = mVSyncEvent[i].vsync.count;
232                break;
233            }
234        }
235
236        if (!timestamp) {
237            // no vsync event, see if there are some other event
238            eventPending = !mPendingEvents.isEmpty();
239            if (eventPending) {
240                // we have some other event to dispatch
241                *event = mPendingEvents[0];
242                mPendingEvents.removeAt(0);
243            }
244        }
245
246        // find out connections waiting for events
247        size_t count = mDisplayEventConnections.size();
248        for (size_t i=0 ; i<count ; i++) {
249            sp<Connection> connection(mDisplayEventConnections[i].promote());
250            if (connection != NULL) {
251                bool added = false;
252                if (connection->count >= 0) {
253                    // we need vsync events because at least
254                    // one connection is waiting for it
255                    waitForVSync = true;
256                    if (timestamp) {
257                        // we consume the event only if it's time
258                        // (ie: we received a vsync event)
259                        if (connection->count == 0) {
260                            // fired this time around
261                            connection->count = -1;
262                            signalConnections.add(connection);
263                            added = true;
264                        } else if (connection->count == 1 ||
265                                (vsyncCount % connection->count) == 0) {
266                            // continuous event, and time to report it
267                            signalConnections.add(connection);
268                            added = true;
269                        }
270                    }
271                }
272
273                if (eventPending && !timestamp && !added) {
274                    // we don't have a vsync event to process
275                    // (timestamp==0), but we have some pending
276                    // messages.
277                    signalConnections.add(connection);
278                }
279            } else {
280                // we couldn't promote this reference, the connection has
281                // died, so clean-up!
282                mDisplayEventConnections.removeAt(i);
283                --i; --count;
284            }
285        }
286
287        // Here we figure out if we need to enable or disable vsyncs
288        if (timestamp && !waitForVSync) {
289            // we received a VSYNC but we have no clients
290            // don't report it, and disable VSYNC events
291            disableVSyncLocked();
292        } else if (!timestamp && waitForVSync) {
293            // we have at least one client, so we want vsync enabled
294            // (TODO: this function is called right after we finish
295            // notifying clients of a vsync, so this call will be made
296            // at the vsync rate, e.g. 60fps.  If we can accurately
297            // track the current state we could avoid making this call
298            // so often.)
299            enableVSyncLocked();
300        }
301
302        // note: !timestamp implies signalConnections.isEmpty(), because we
303        // don't populate signalConnections if there's no vsync pending
304        if (!timestamp && !eventPending) {
305            // wait for something to happen
306            if (waitForVSync) {
307                // This is where we spend most of our time, waiting
308                // for vsync events and new client registrations.
309                //
310                // If the screen is off, we can't use h/w vsync, so we
311                // use a 16ms timeout instead.  It doesn't need to be
312                // precise, we just need to keep feeding our clients.
313                //
314                // We don't want to stall if there's a driver bug, so we
315                // use a (long) timeout when waiting for h/w vsync, and
316                // generate fake events when necessary.
317                bool softwareSync = mUseSoftwareVSync;
318                nsecs_t timeout = softwareSync ? ms2ns(16) : ms2ns(1000);
319                if (mCondition.waitRelative(mLock, timeout) == TIMED_OUT) {
320                    if (!softwareSync) {
321                        ALOGW("Timed out waiting for hw vsync; faking it");
322                    }
323                    // FIXME: how do we decide which display id the fake
324                    // vsync came from ?
325                    mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
326                    mVSyncEvent[0].header.id = DisplayDevice::DISPLAY_PRIMARY;
327                    mVSyncEvent[0].header.timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
328                    mVSyncEvent[0].vsync.count++;
329                }
330            } else {
331                // Nobody is interested in vsync, so we just want to sleep.
332                // h/w vsync should be disabled, so this will wait until we
333                // get a new connection, or an existing connection becomes
334                // interested in receiving vsync again.
335                mCondition.wait(mLock);
336            }
337        }
338    } while (signalConnections.isEmpty());
339
340    // here we're guaranteed to have a timestamp and some connections to signal
341    // (The connections might have dropped out of mDisplayEventConnections
342    // while we were asleep, but we'll still have strong references to them.)
343    return signalConnections;
344}
345
346void EventThread::enableVSyncLocked() {
347    if (!mUseSoftwareVSync) {
348        // never enable h/w VSYNC when screen is off
349        if (!mVsyncEnabled) {
350            mVsyncEnabled = true;
351            mVSyncSource->setCallback(static_cast<VSyncSource::Callback*>(this));
352            mVSyncSource->setVSyncEnabled(true);
353        }
354    }
355    mDebugVsyncEnabled = true;
356    sendVsyncHintOnLocked();
357}
358
359void EventThread::disableVSyncLocked() {
360    if (mVsyncEnabled) {
361        mVsyncEnabled = false;
362        mVSyncSource->setVSyncEnabled(false);
363        mDebugVsyncEnabled = false;
364    }
365}
366
367void EventThread::dump(String8& result) const {
368    Mutex::Autolock _l(mLock);
369    result.appendFormat("VSYNC state: %s\n",
370            mDebugVsyncEnabled?"enabled":"disabled");
371    result.appendFormat("  soft-vsync: %s\n",
372            mUseSoftwareVSync?"enabled":"disabled");
373    result.appendFormat("  numListeners=%zu,\n  events-delivered: %u\n",
374            mDisplayEventConnections.size(),
375            mVSyncEvent[DisplayDevice::DISPLAY_PRIMARY].vsync.count);
376    for (size_t i=0 ; i<mDisplayEventConnections.size() ; i++) {
377        sp<Connection> connection =
378                mDisplayEventConnections.itemAt(i).promote();
379        result.appendFormat("    %p: count=%d\n",
380                connection.get(), connection!=NULL ? connection->count : 0);
381    }
382}
383
384// ---------------------------------------------------------------------------
385
386EventThread::Connection::Connection(
387        const sp<EventThread>& eventThread)
388    : count(-1), mEventThread(eventThread), mChannel(new BitTube())
389{
390}
391
392EventThread::Connection::~Connection() {
393    // do nothing here -- clean-up will happen automatically
394    // when the main thread wakes up
395}
396
397void EventThread::Connection::onFirstRef() {
398    // NOTE: mEventThread doesn't hold a strong reference on us
399    mEventThread->registerDisplayEventConnection(this);
400}
401
402sp<BitTube> EventThread::Connection::getDataChannel() const {
403    return mChannel;
404}
405
406void EventThread::Connection::setVsyncRate(uint32_t count) {
407    mEventThread->setVsyncRate(count, this);
408}
409
410void EventThread::Connection::requestNextVsync() {
411    mEventThread->requestNextVsync(this);
412}
413
414status_t EventThread::Connection::postEvent(
415        const DisplayEventReceiver::Event& event) {
416    ssize_t size = DisplayEventReceiver::sendEvents(mChannel, &event, 1);
417    return size < 0 ? status_t(size) : status_t(NO_ERROR);
418}
419
420// ---------------------------------------------------------------------------
421
422}; // namespace android
423