HWComposer.cpp revision 5880cc573823148237eac9ab7bc586b8e4eb7160 
1/*
2 * Copyright (C) 2010 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// Uncomment this to remove support for HWC_DEVICE_API_VERSION_0_3 and older
20// #define HWC_REMOVE_DEPRECATED_VERSIONS 1
21
22#include <stdint.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <sys/types.h>
27
28#include <utils/Errors.h>
29#include <utils/String8.h>
30#include <utils/Thread.h>
31#include <utils/Trace.h>
32#include <utils/Vector.h>
33
34#include <hardware/hardware.h>
35#include <hardware/hwcomposer.h>
36
37#include <cutils/log.h>
38#include <cutils/properties.h>
39
40#include <EGL/egl.h>
41
42#include "LayerBase.h"
43#include "HWComposer.h"
44#include "SurfaceFlinger.h"
45
46namespace android {
47
48// ---------------------------------------------------------------------------
49// Support for HWC_DEVICE_API_VERSION_0_3 and older:
50// Since v0.3 is deprecated and support will be dropped soon, as much as
51// possible the code is written to target v1.0. When using a v0.3 HWC, we
52// allocate v0.3 structures, but assign them to v1.0 pointers. Fields that
53// exist in both versions are located at the same offset, so in most cases we
54// can just use the v1.0 pointer without branches or casts.
55
56#if HWC_REMOVE_DEPRECATED_VERSIONS
57// We need complete types with to satisfy semantic checks, even though the
58// code paths that use these won't get executed at runtime (and will likely be
59// dead-code-eliminated). When we remove the code to support v0.3 we can remove
60// these as well.
61typedef hwc_layer_1_t hwc_layer_t;
62typedef hwc_layer_list_1_t hwc_layer_list_t;
63typedef hwc_composer_device_1_t hwc_composer_device_t;
64#endif
65
66// This function assumes we've already rejected HWC's with lower-than-required
67// versions. Don't use it for the initial "does HWC meet requirements" check!
68static bool hwcHasVersion(const hwc_composer_device_1_t* hwc, uint32_t version) {
69    if (HWC_REMOVE_DEPRECATED_VERSIONS &&
70            version <= HWC_DEVICE_API_VERSION_1_0) {
71        return true;
72    } else {
73        return hwc->common.version >= version;
74    }
75}
76
77static size_t sizeofHwcLayerList(const hwc_composer_device_1_t* hwc,
78        size_t numLayers) {
79    if (hwcHasVersion(hwc, HWC_DEVICE_API_VERSION_1_0)) {
80        return sizeof(hwc_layer_list_1_t) + numLayers*sizeof(hwc_layer_1_t);
81    } else {
82        return sizeof(hwc_layer_list_t) + numLayers*sizeof(hwc_layer_t);
83    }
84}
85
86// ---------------------------------------------------------------------------
87
88struct HWComposer::cb_context {
89    struct callbacks : public hwc_procs_t {
90        // these are here to facilitate the transition when adding
91        // new callbacks (an implementation can check for NULL before
92        // calling a new callback).
93        void (*zero[4])(void);
94    };
95    callbacks procs;
96    HWComposer* hwc;
97};
98
99// ---------------------------------------------------------------------------
100
101HWComposer::HWComposer(
102        const sp<SurfaceFlinger>& flinger,
103        EventHandler& handler,
104        nsecs_t refreshPeriod)
105    : mFlinger(flinger),
106      mModule(0), mHwc(0), mList(0), mCapacity(0),
107      mNumOVLayers(0), mNumFBLayers(0),
108      mDpy(EGL_NO_DISPLAY), mSur(EGL_NO_SURFACE),
109      mCBContext(new cb_context),
110      mEventHandler(handler),
111      mRefreshPeriod(refreshPeriod),
112      mVSyncCount(0), mDebugForceFakeVSync(false)
113{
114    char value[PROPERTY_VALUE_MAX];
115    property_get("debug.sf.no_hw_vsync", value, "0");
116    mDebugForceFakeVSync = atoi(value);
117
118    bool needVSyncThread = false;
119    int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &mModule);
120    ALOGW_IF(err, "%s module not found", HWC_HARDWARE_MODULE_ID);
121    if (err == 0) {
122        err = hwc_open_1(mModule, &mHwc);
123        ALOGE_IF(err, "%s device failed to initialize (%s)",
124                HWC_HARDWARE_COMPOSER, strerror(-err));
125        if (err == 0) {
126            if (HWC_REMOVE_DEPRECATED_VERSIONS &&
127                    mHwc->common.version < HWC_DEVICE_API_VERSION_1_0) {
128                ALOGE("%s device version %#x too old, will not be used",
129                        HWC_HARDWARE_COMPOSER, mHwc->common.version);
130                hwc_close_1(mHwc);
131                mHwc = NULL;
132            }
133        }
134
135        if (mHwc) {
136            if (mHwc->registerProcs) {
137                mCBContext->hwc = this;
138                mCBContext->procs.invalidate = &hook_invalidate;
139                mCBContext->procs.vsync = &hook_vsync;
140                mHwc->registerProcs(mHwc, &mCBContext->procs);
141                memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));
142            }
143            if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_3)) {
144                if (mDebugForceFakeVSync) {
145                    // make sure to turn h/w vsync off in "fake vsync" mode
146                    mHwc->methods->eventControl(mHwc, HWC_EVENT_VSYNC, 0);
147                }
148            } else {
149                needVSyncThread = true;
150            }
151        }
152    } else {
153        needVSyncThread = true;
154    }
155
156    if (needVSyncThread) {
157        // we don't have VSYNC support, we need to fake it
158        mVSyncThread = new VSyncThread(*this);
159    }
160}
161
162HWComposer::~HWComposer() {
163    eventControl(EVENT_VSYNC, 0);
164    free(mList);
165    if (mVSyncThread != NULL) {
166        mVSyncThread->requestExitAndWait();
167    }
168    if (mHwc) {
169        hwc_close_1(mHwc);
170    }
171    delete mCBContext;
172}
173
174status_t HWComposer::initCheck() const {
175    return mHwc ? NO_ERROR : NO_INIT;
176}
177
178void HWComposer::hook_invalidate(struct hwc_procs* procs) {
179    reinterpret_cast<cb_context *>(procs)->hwc->invalidate();
180}
181
182void HWComposer::hook_vsync(struct hwc_procs* procs, int dpy, int64_t timestamp) {
183    reinterpret_cast<cb_context *>(procs)->hwc->vsync(dpy, timestamp);
184}
185
186void HWComposer::invalidate() {
187    mFlinger->repaintEverything();
188}
189
190void HWComposer::vsync(int dpy, int64_t timestamp) {
191    ATRACE_INT("VSYNC", ++mVSyncCount&1);
192    mEventHandler.onVSyncReceived(dpy, timestamp);
193}
194
195void HWComposer::eventControl(int event, int enabled) {
196    status_t err = NO_ERROR;
197    if (mHwc && mHwc->common.version >= HWC_DEVICE_API_VERSION_0_3) {
198        if (!mDebugForceFakeVSync) {
199            err = mHwc->methods->eventControl(mHwc, event, enabled);
200            // error here should not happen -- not sure what we should
201            // do if it does.
202            ALOGE_IF(err, "eventControl(%d, %d) failed %s",
203                    event, enabled, strerror(-err));
204        }
205    }
206
207    if (err == NO_ERROR && mVSyncThread != NULL) {
208        mVSyncThread->setEnabled(enabled);
209    }
210}
211
212void HWComposer::setFrameBuffer(EGLDisplay dpy, EGLSurface sur) {
213    mDpy = (hwc_display_t)dpy;
214    mSur = (hwc_surface_t)sur;
215}
216
217status_t HWComposer::createWorkList(size_t numLayers) {
218    if (mHwc) {
219        if (!mList || mCapacity < numLayers) {
220            free(mList);
221            size_t size = sizeofHwcLayerList(mHwc, numLayers);
222            mList = (hwc_layer_list_1_t*)malloc(size);
223            mCapacity = numLayers;
224        }
225        mList->flags = HWC_GEOMETRY_CHANGED;
226        mList->numHwLayers = numLayers;
227    }
228    return NO_ERROR;
229}
230
231status_t HWComposer::prepare() const {
232    int err = mHwc->prepare(mHwc, mList);
233    if (err == NO_ERROR) {
234        size_t numOVLayers = 0;
235        size_t numFBLayers = 0;
236        size_t count = mList->numHwLayers;
237        for (size_t i=0 ; i<count ; i++) {
238            hwc_layer_1_t* l = NULL;
239            if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) {
240                l = &mList->hwLayers[i];
241            } else {
242                // mList really has hwc_layer_list_t memory layout
243                hwc_layer_list_t* list = (hwc_layer_list_t*)mList;
244                hwc_layer_t* layer = &list->hwLayers[i];
245                l = (hwc_layer_1_t*)layer;
246            }
247            if (l->flags & HWC_SKIP_LAYER) {
248                l->compositionType = HWC_FRAMEBUFFER;
249            }
250            switch (l->compositionType) {
251                case HWC_OVERLAY:
252                    numOVLayers++;
253                    break;
254                case HWC_FRAMEBUFFER:
255                    numFBLayers++;
256                    break;
257            }
258        }
259        mNumOVLayers = numOVLayers;
260        mNumFBLayers = numFBLayers;
261    }
262    return (status_t)err;
263}
264
265size_t HWComposer::getLayerCount(int type) const {
266    switch (type) {
267        case HWC_OVERLAY:
268            return mNumOVLayers;
269        case HWC_FRAMEBUFFER:
270            return mNumFBLayers;
271    }
272    return 0;
273}
274
275status_t HWComposer::commit() const {
276    int err = mHwc->set(mHwc, mDpy, mSur, mList);
277    if (mList) {
278        mList->flags &= ~HWC_GEOMETRY_CHANGED;
279    }
280    return (status_t)err;
281}
282
283status_t HWComposer::release() const {
284    if (mHwc) {
285        if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_3)) {
286            mHwc->methods->eventControl(mHwc, HWC_EVENT_VSYNC, 0);
287        }
288        int err = mHwc->set(mHwc, NULL, NULL, NULL);
289        return (status_t)err;
290    }
291    return NO_ERROR;
292}
293
294status_t HWComposer::disable() {
295    if (mHwc) {
296        free(mList);
297        mList = NULL;
298        int err = mHwc->prepare(mHwc, NULL);
299        return (status_t)err;
300    }
301    return NO_ERROR;
302}
303
304size_t HWComposer::getNumLayers() const {
305    return mList ? mList->numHwLayers : 0;
306}
307
308/*
309 * Helper template to implement a concrete HWCLayer
310 * This holds the pointer to the concrete hwc layer type
311 * and implements the "iterable" side of HWCLayer.
312 */
313template<typename CONCRETE, typename HWCTYPE>
314class Iterable : public HWComposer::HWCLayer {
315protected:
316    HWCTYPE* const mLayerList;
317    HWCTYPE* mCurrentLayer;
318    Iterable(HWCTYPE* layer) : mLayerList(layer), mCurrentLayer(layer) { }
319    inline HWCTYPE const * getLayer() const { return mCurrentLayer; }
320    inline HWCTYPE* getLayer() { return mCurrentLayer; }
321    virtual ~Iterable() { }
322private:
323    // returns a copy of ourselves
324    virtual HWComposer::HWCLayer* dup() {
325        return new CONCRETE( static_cast<const CONCRETE&>(*this) );
326    }
327    virtual status_t setLayer(size_t index) {
328        mCurrentLayer = &mLayerList[index];
329        return NO_ERROR;
330    }
331};
332
333// #if !HWC_REMOVE_DEPRECATED_VERSIONS
334/*
335 * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_0_3
336 * This implements the HWCLayer side of HWCIterableLayer.
337 */
338class HWCLayerVersion0 : public Iterable<HWCLayerVersion0, hwc_layer_t> {
339public:
340    HWCLayerVersion0(hwc_layer_t* layer)
341        : Iterable<HWCLayerVersion0, hwc_layer_t>(layer) { }
342
343    virtual int32_t getCompositionType() const {
344        return getLayer()->compositionType;
345    }
346    virtual uint32_t getHints() const {
347        return getLayer()->hints;
348    }
349
350    virtual void setDefaultState() {
351        getLayer()->compositionType = HWC_FRAMEBUFFER;
352        getLayer()->hints = 0;
353        getLayer()->flags = HWC_SKIP_LAYER;
354        getLayer()->transform = 0;
355        getLayer()->blending = HWC_BLENDING_NONE;
356        getLayer()->visibleRegionScreen.numRects = 0;
357        getLayer()->visibleRegionScreen.rects = NULL;
358    }
359    virtual void setSkip(bool skip) {
360        if (skip) {
361            getLayer()->flags |= HWC_SKIP_LAYER;
362        } else {
363            getLayer()->flags &= ~HWC_SKIP_LAYER;
364        }
365    }
366    virtual void setBlending(uint32_t blending) {
367        getLayer()->blending = blending;
368    }
369    virtual void setTransform(uint32_t transform) {
370        getLayer()->transform = transform;
371    }
372    virtual void setFrame(const Rect& frame) {
373        reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame;
374    }
375    virtual void setCrop(const Rect& crop) {
376        reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop;
377    }
378    virtual void setVisibleRegionScreen(const Region& reg) {
379        getLayer()->visibleRegionScreen.rects =
380                reinterpret_cast<hwc_rect_t const *>(
381                        reg.getArray(&getLayer()->visibleRegionScreen.numRects));
382    }
383    virtual void setBuffer(const sp<GraphicBuffer>& buffer) {
384        if (buffer == 0 || buffer->handle == 0) {
385            getLayer()->compositionType = HWC_FRAMEBUFFER;
386            getLayer()->flags |= HWC_SKIP_LAYER;
387            getLayer()->handle = 0;
388        } else {
389            getLayer()->handle = buffer->handle;
390        }
391    }
392};
393// #endif // !HWC_REMOVE_DEPRECATED_VERSIONS
394
395/*
396 * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_1_0.
397 * This implements the HWCLayer side of HWCIterableLayer.
398 */
399class HWCLayerVersion1 : public Iterable<HWCLayerVersion1, hwc_layer_1_t> {
400public:
401    HWCLayerVersion1(hwc_layer_1_t* layer)
402        : Iterable<HWCLayerVersion1, hwc_layer_1_t>(layer) { }
403
404    virtual int32_t getCompositionType() const {
405        return getLayer()->compositionType;
406    }
407    virtual uint32_t getHints() const {
408        return getLayer()->hints;
409    }
410
411    virtual void setDefaultState() {
412        getLayer()->compositionType = HWC_FRAMEBUFFER;
413        getLayer()->hints = 0;
414        getLayer()->flags = HWC_SKIP_LAYER;
415        getLayer()->transform = 0;
416        getLayer()->blending = HWC_BLENDING_NONE;
417        getLayer()->visibleRegionScreen.numRects = 0;
418        getLayer()->visibleRegionScreen.rects = NULL;
419        getLayer()->acquireFenceFd = -1;
420        getLayer()->releaseFenceFd = -1;
421    }
422    virtual void setSkip(bool skip) {
423        if (skip) {
424            getLayer()->flags |= HWC_SKIP_LAYER;
425        } else {
426            getLayer()->flags &= ~HWC_SKIP_LAYER;
427        }
428    }
429    virtual void setBlending(uint32_t blending) {
430        getLayer()->blending = blending;
431    }
432    virtual void setTransform(uint32_t transform) {
433        getLayer()->transform = transform;
434    }
435    virtual void setFrame(const Rect& frame) {
436        reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame;
437    }
438    virtual void setCrop(const Rect& crop) {
439        reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop;
440    }
441    virtual void setVisibleRegionScreen(const Region& reg) {
442        getLayer()->visibleRegionScreen.rects =
443                reinterpret_cast<hwc_rect_t const *>(
444                        reg.getArray(&getLayer()->visibleRegionScreen.numRects));
445    }
446    virtual void setBuffer(const sp<GraphicBuffer>& buffer) {
447        if (buffer == 0 || buffer->handle == 0) {
448            getLayer()->compositionType = HWC_FRAMEBUFFER;
449            getLayer()->flags |= HWC_SKIP_LAYER;
450            getLayer()->handle = 0;
451        } else {
452            getLayer()->handle = buffer->handle;
453        }
454    }
455};
456
457/*
458 * returns an iterator initialized at a given index in the layer list
459 */
460HWComposer::LayerListIterator HWComposer::getLayerIterator(size_t index) {
461    if (!mList || index > mList->numHwLayers) {
462        return LayerListIterator();
463    }
464    if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) {
465        return LayerListIterator(new HWCLayerVersion1(mList->hwLayers), index);
466    } else {
467        hwc_layer_list_t* list0 = (hwc_layer_list_t*)mList;
468        return LayerListIterator(new HWCLayerVersion0(list0->hwLayers), index);
469    }
470}
471
472/*
473 * returns an iterator on the beginning of the layer list
474 */
475HWComposer::LayerListIterator HWComposer::begin() {
476    return getLayerIterator(0);
477}
478
479/*
480 * returns an iterator on the end of the layer list
481 */
482HWComposer::LayerListIterator HWComposer::end() {
483    return getLayerIterator(getNumLayers());
484}
485
486
487
488void HWComposer::dump(String8& result, char* buffer, size_t SIZE,
489        const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const {
490    if (mHwc && mList) {
491        result.append("Hardware Composer state:\n");
492        result.appendFormat("  mDebugForceFakeVSync=%d\n",
493                mDebugForceFakeVSync);
494        result.appendFormat("  numHwLayers=%u, flags=%08x\n",
495                mList->numHwLayers, mList->flags);
496        result.append(
497                "   type   |  handle  |   hints  |   flags  | tr | blend |  format  |       source crop         |           frame           name \n"
498                "----------+----------+----------+----------+----+-------+----------+---------------------------+--------------------------------\n");
499        //      " ________ | ________ | ________ | ________ | __ | _____ | ________ | [_____,_____,_____,_____] | [_____,_____,_____,_____]
500        for (size_t i=0 ; i<mList->numHwLayers ; i++) {
501            hwc_layer_1_t l;
502            if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) {
503                l = mList->hwLayers[i];
504            } else {
505                hwc_layer_list_t* list0 = (hwc_layer_list_t*)mList;
506                *(hwc_layer_t*)&l = list0->hwLayers[i];
507                l.acquireFenceFd = l.releaseFenceFd = -1;
508            }
509            const sp<LayerBase> layer(visibleLayersSortedByZ[i]);
510            int32_t format = -1;
511            if (layer->getLayer() != NULL) {
512                const sp<GraphicBuffer>& buffer(layer->getLayer()->getActiveBuffer());
513                if (buffer != NULL) {
514                    format = buffer->getPixelFormat();
515                }
516            }
517            result.appendFormat(
518                    " %8s | %08x | %08x | %08x | %02x | %05x | %08x | [%5d,%5d,%5d,%5d] | [%5d,%5d,%5d,%5d] %s\n",
519                    l.compositionType ? "OVERLAY" : "FB",
520                    intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, format,
521                    l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom,
522                    l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
523                    layer->getName().string());
524        }
525    }
526    if (mHwc && hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_1) && mHwc->dump) {
527        mHwc->dump(mHwc, buffer, SIZE);
528        result.append(buffer);
529    }
530}
531
532// ---------------------------------------------------------------------------
533
534HWComposer::VSyncThread::VSyncThread(HWComposer& hwc)
535    : mHwc(hwc), mEnabled(false),
536      mNextFakeVSync(0),
537      mRefreshPeriod(hwc.mRefreshPeriod)
538{
539}
540
541void HWComposer::VSyncThread::setEnabled(bool enabled) {
542    Mutex::Autolock _l(mLock);
543    mEnabled = enabled;
544    mCondition.signal();
545}
546
547void HWComposer::VSyncThread::onFirstRef() {
548    run("VSyncThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
549}
550
551bool HWComposer::VSyncThread::threadLoop() {
552    { // scope for lock
553        Mutex::Autolock _l(mLock);
554        while (!mEnabled) {
555            mCondition.wait(mLock);
556        }
557    }
558
559    const nsecs_t period = mRefreshPeriod;
560    const nsecs_t now = systemTime(CLOCK_MONOTONIC);
561    nsecs_t next_vsync = mNextFakeVSync;
562    nsecs_t sleep = next_vsync - now;
563    if (sleep < 0) {
564        // we missed, find where the next vsync should be
565        sleep = (period - ((now - next_vsync) % period));
566        next_vsync = now + sleep;
567    }
568    mNextFakeVSync = next_vsync + period;
569
570    struct timespec spec;
571    spec.tv_sec  = next_vsync / 1000000000;
572    spec.tv_nsec = next_vsync % 1000000000;
573
574    int err;
575    do {
576        err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
577    } while (err<0 && errno == EINTR);
578
579    if (err == 0) {
580        mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
581    }
582
583    return true;
584}
585
586// ---------------------------------------------------------------------------
587}; // namespace android
588