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