HWComposer.cpp revision dc5b485f74edf2d2f31c62054eb6c180421a3ade 
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    virtual int getAndResetReleaseFenceFd() {
350        // not supported on VERSION_03
351        return -1;
352    }
353    virtual void setAcquireFenceFd(int fenceFd) {
354        if (fenceFd != -1) {
355            ALOGE("HWC 0.x can't handle acquire fences");
356            close(fenceFd);
357        }
358    }
359
360    virtual void setDefaultState() {
361        getLayer()->compositionType = HWC_FRAMEBUFFER;
362        getLayer()->hints = 0;
363        getLayer()->flags = HWC_SKIP_LAYER;
364        getLayer()->transform = 0;
365        getLayer()->blending = HWC_BLENDING_NONE;
366        getLayer()->visibleRegionScreen.numRects = 0;
367        getLayer()->visibleRegionScreen.rects = NULL;
368    }
369    virtual void setSkip(bool skip) {
370        if (skip) {
371            getLayer()->flags |= HWC_SKIP_LAYER;
372        } else {
373            getLayer()->flags &= ~HWC_SKIP_LAYER;
374        }
375    }
376    virtual void setBlending(uint32_t blending) {
377        getLayer()->blending = blending;
378    }
379    virtual void setTransform(uint32_t transform) {
380        getLayer()->transform = transform;
381    }
382    virtual void setFrame(const Rect& frame) {
383        reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame;
384    }
385    virtual void setCrop(const Rect& crop) {
386        reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop;
387    }
388    virtual void setVisibleRegionScreen(const Region& reg) {
389        getLayer()->visibleRegionScreen.rects =
390                reinterpret_cast<hwc_rect_t const *>(
391                        reg.getArray(&getLayer()->visibleRegionScreen.numRects));
392    }
393    virtual void setBuffer(const sp<GraphicBuffer>& buffer) {
394        if (buffer == 0 || buffer->handle == 0) {
395            getLayer()->compositionType = HWC_FRAMEBUFFER;
396            getLayer()->flags |= HWC_SKIP_LAYER;
397            getLayer()->handle = 0;
398        } else {
399            getLayer()->handle = buffer->handle;
400        }
401    }
402};
403// #endif // !HWC_REMOVE_DEPRECATED_VERSIONS
404
405/*
406 * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_1_0.
407 * This implements the HWCLayer side of HWCIterableLayer.
408 */
409class HWCLayerVersion1 : public Iterable<HWCLayerVersion1, hwc_layer_1_t> {
410public:
411    HWCLayerVersion1(hwc_layer_1_t* layer)
412        : Iterable<HWCLayerVersion1, hwc_layer_1_t>(layer) { }
413
414    virtual int32_t getCompositionType() const {
415        return getLayer()->compositionType;
416    }
417    virtual uint32_t getHints() const {
418        return getLayer()->hints;
419    }
420    virtual int getAndResetReleaseFenceFd() {
421        int fd = getLayer()->releaseFenceFd;
422        getLayer()->releaseFenceFd = -1;
423        return fd;
424    }
425    virtual void setAcquireFenceFd(int fenceFd) {
426        getLayer()->acquireFenceFd = fenceFd;
427    }
428
429    virtual void setDefaultState() {
430        getLayer()->compositionType = HWC_FRAMEBUFFER;
431        getLayer()->hints = 0;
432        getLayer()->flags = HWC_SKIP_LAYER;
433        getLayer()->transform = 0;
434        getLayer()->blending = HWC_BLENDING_NONE;
435        getLayer()->visibleRegionScreen.numRects = 0;
436        getLayer()->visibleRegionScreen.rects = NULL;
437        getLayer()->acquireFenceFd = -1;
438        getLayer()->releaseFenceFd = -1;
439    }
440    virtual void setSkip(bool skip) {
441        if (skip) {
442            getLayer()->flags |= HWC_SKIP_LAYER;
443        } else {
444            getLayer()->flags &= ~HWC_SKIP_LAYER;
445        }
446    }
447    virtual void setBlending(uint32_t blending) {
448        getLayer()->blending = blending;
449    }
450    virtual void setTransform(uint32_t transform) {
451        getLayer()->transform = transform;
452    }
453    virtual void setFrame(const Rect& frame) {
454        reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame;
455    }
456    virtual void setCrop(const Rect& crop) {
457        reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop;
458    }
459    virtual void setVisibleRegionScreen(const Region& reg) {
460        getLayer()->visibleRegionScreen.rects =
461                reinterpret_cast<hwc_rect_t const *>(
462                        reg.getArray(&getLayer()->visibleRegionScreen.numRects));
463    }
464    virtual void setBuffer(const sp<GraphicBuffer>& buffer) {
465        if (buffer == 0 || buffer->handle == 0) {
466            getLayer()->compositionType = HWC_FRAMEBUFFER;
467            getLayer()->flags |= HWC_SKIP_LAYER;
468            getLayer()->handle = 0;
469        } else {
470            getLayer()->handle = buffer->handle;
471        }
472    }
473};
474
475/*
476 * returns an iterator initialized at a given index in the layer list
477 */
478HWComposer::LayerListIterator HWComposer::getLayerIterator(size_t index) {
479    if (!mList || index > mList->numHwLayers) {
480        return LayerListIterator();
481    }
482    if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) {
483        return LayerListIterator(new HWCLayerVersion1(mList->hwLayers), index);
484    } else {
485        hwc_layer_list_t* list0 = (hwc_layer_list_t*)mList;
486        return LayerListIterator(new HWCLayerVersion0(list0->hwLayers), index);
487    }
488}
489
490/*
491 * returns an iterator on the beginning of the layer list
492 */
493HWComposer::LayerListIterator HWComposer::begin() {
494    return getLayerIterator(0);
495}
496
497/*
498 * returns an iterator on the end of the layer list
499 */
500HWComposer::LayerListIterator HWComposer::end() {
501    return getLayerIterator(getNumLayers());
502}
503
504
505
506void HWComposer::dump(String8& result, char* buffer, size_t SIZE,
507        const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const {
508    if (mHwc && mList) {
509        result.append("Hardware Composer state:\n");
510        result.appendFormat("  mDebugForceFakeVSync=%d\n",
511                mDebugForceFakeVSync);
512        result.appendFormat("  numHwLayers=%u, flags=%08x\n",
513                mList->numHwLayers, mList->flags);
514        result.append(
515                "   type   |  handle  |   hints  |   flags  | tr | blend |  format  |       source crop         |           frame           name \n"
516                "----------+----------+----------+----------+----+-------+----------+---------------------------+--------------------------------\n");
517        //      " ________ | ________ | ________ | ________ | __ | _____ | ________ | [_____,_____,_____,_____] | [_____,_____,_____,_____]
518        for (size_t i=0 ; i<mList->numHwLayers ; i++) {
519            hwc_layer_1_t l;
520            if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) {
521                l = mList->hwLayers[i];
522            } else {
523                hwc_layer_list_t* list0 = (hwc_layer_list_t*)mList;
524                *(hwc_layer_t*)&l = list0->hwLayers[i];
525                l.acquireFenceFd = l.releaseFenceFd = -1;
526            }
527            const sp<LayerBase> layer(visibleLayersSortedByZ[i]);
528            int32_t format = -1;
529            if (layer->getLayer() != NULL) {
530                const sp<GraphicBuffer>& buffer(layer->getLayer()->getActiveBuffer());
531                if (buffer != NULL) {
532                    format = buffer->getPixelFormat();
533                }
534            }
535            result.appendFormat(
536                    " %8s | %08x | %08x | %08x | %02x | %05x | %08x | [%5d,%5d,%5d,%5d] | [%5d,%5d,%5d,%5d] %s\n",
537                    l.compositionType ? "OVERLAY" : "FB",
538                    intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, format,
539                    l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom,
540                    l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
541                    layer->getName().string());
542        }
543    }
544    if (mHwc && hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_1) && mHwc->dump) {
545        mHwc->dump(mHwc, buffer, SIZE);
546        result.append(buffer);
547    }
548}
549
550// ---------------------------------------------------------------------------
551
552HWComposer::VSyncThread::VSyncThread(HWComposer& hwc)
553    : mHwc(hwc), mEnabled(false),
554      mNextFakeVSync(0),
555      mRefreshPeriod(hwc.mRefreshPeriod)
556{
557}
558
559void HWComposer::VSyncThread::setEnabled(bool enabled) {
560    Mutex::Autolock _l(mLock);
561    mEnabled = enabled;
562    mCondition.signal();
563}
564
565void HWComposer::VSyncThread::onFirstRef() {
566    run("VSyncThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
567}
568
569bool HWComposer::VSyncThread::threadLoop() {
570    { // scope for lock
571        Mutex::Autolock _l(mLock);
572        while (!mEnabled) {
573            mCondition.wait(mLock);
574        }
575    }
576
577    const nsecs_t period = mRefreshPeriod;
578    const nsecs_t now = systemTime(CLOCK_MONOTONIC);
579    nsecs_t next_vsync = mNextFakeVSync;
580    nsecs_t sleep = next_vsync - now;
581    if (sleep < 0) {
582        // we missed, find where the next vsync should be
583        sleep = (period - ((now - next_vsync) % period));
584        next_vsync = now + sleep;
585    }
586    mNextFakeVSync = next_vsync + period;
587
588    struct timespec spec;
589    spec.tv_sec  = next_vsync / 1000000000;
590    spec.tv_nsec = next_vsync % 1000000000;
591
592    int err;
593    do {
594        err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
595    } while (err<0 && errno == EINTR);
596
597    if (err == 0) {
598        mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
599    }
600
601    return true;
602}
603
604// ---------------------------------------------------------------------------
605}; // namespace android
606