android graphic(11)—底层初始化displays

http://blog.csdn.net/lewif/article/details/50817821

目录(?)[+]

• 初始化HWC
• surfaceflinger初始化displays

---

这里的底层不牵扯内核以下的分析，主要是内核亮屏后，HAL层以上各层是如何联系起来的，通过层层转交，将displays的信息从内核填充到上层。这里主要涉及framework中的HWComposer，surfaceflinger，HAL层的Hwcomposer，为了便于区分，framework层记为HWC，HAL层记为Hwc，HWC相当于是Hwc的wrapper。

初始化HWC

SurfaceFlinger::init()—>初始化HWC

 mHwc = new HWComposer(this,

            *static_cast<HWComposer::EventHandler *>(this));

HWComposer::HWComposer(

        constsp<SurfaceFlinger>& flinger,

       EventHandler& handler)

    :mFlinger(flinger),

      mFbDev(0), mHwc(0), mNumDisplays(1),

      mCBContext(new cb_context),

     mEventHandler(handler),

     mDebugForceFakeVSync(false)

{

    for (size_t i =0 ;i<MAX_HWC_DISPLAYS ; i++) {

        mLists[i] =0;

    }

 

    for (size_t i=0 ;i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) {

       mLastHwVSync[i] = 0;

        mVSyncCounts[i]= 0;

    }

 

    // Note: some devices may insist thatthe FB HAL be opened before HWC.

    int fberr =loadFbHalModule();

   loadHwcModule();

    //如果有Hwc，即HWComposer的hal层，则关闭fb

    if (mFbDev&& mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)){

        // close FB HAL if we don't needed it.

        // FIXME: this is temporary until we'renot forced to open FB HAL

        // before HWC.

       framebuffer_close(mFbDev);

        mFbDev =NULL;

    }

 

 

    // these display IDs are always reserved

    // NUM_BUILTIN_DISPLAYS 2

    for (size_t i=0 ;i<NUM_BUILTIN_DISPLAYS ; i++) {

       mAllocatedDisplayIDs.markBit(i);

    }

 

    if (mHwc) {

        ALOGI("Using %s version %u.%u",HWC_HARDWARE_COMPOSER,

              (hwcApiVersion(mHwc) >>24) & 0xff,

             (hwcApiVersion(mHwc) >> 16) & 0xff);

        //把HWC中，即framework中的回调函数注册到HAL中，用来在HAL中回调

        if(mHwc->registerProcs) {

           mCBContext->hwc = this;

           mCBContext->procs.invalidate = &hook_invalidate;

           mCBContext->procs.vsync = &hook_vsync;

            if(hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))

               mCBContext->procs.hotplug = &hook_hotplug;

            else

               mCBContext->procs.hotplug = NULL;

            memset(mCBContext->procs.zero,0,sizeof(mCBContext->procs.zero));

           mHwc->registerProcs(mHwc, &mCBContext->procs);

        }

 

        // don't need a vsync thread if we havea hardware composer

       needVSyncThread = false;

        // always turn vsync off when we start

       eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC,0);

 

        // the number of displays we actuallyhave depends on the

        // hw composer version

        // 1.3版本，已经支持虚拟display，3个

        if(hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {

            // 1.3 adds support for virtual displays

           mNumDisplays = MAX_HWC_DISPLAYS;

        } elseif(hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {

            // 1.1 adds support for multipledisplays

           mNumDisplays = NUM_BUILTIN_DISPLAYS;

        } else {

           mNumDisplays = 1;

        }

    }

    //fb已经关闭   

    if (mFbDev) {

 

    } elseif (mHwc) {

        // here we're guaranteed to have atleast HWC 1.1

        //HWC获取display信息的地方，填充mDisplayData[3]

        //DisplayData                    mDisplayData[MAX_HWC_DISPLAYS];

        for (size_t i =0 ;i<NUM_BUILTIN_DISPLAYS ; i++) {

           queryDisplayProperties(i);

        }

    }

    //vsync软件模拟线程

    if(needVSyncThread) {

        // we don't have VSYNC support, we needto fake it

       mVSyncThread = new VSyncThread(*this);

    }

}

//调用HAL层接口，获取屏幕的参数，HAL会和驱动打交道

//这样就相当于在上层把display的参数初始化了,

//主要填充DisplayData                    mDisplayData[MAX_HWC_DISPLAYS];

status_t HWComposer::queryDisplayProperties(int disp) {

    int32_tvalues[NUM_DISPLAY_ATTRIBUTES -1];

    memset(values,0, sizeof(values));

    uint32_tconfig;

    size_tnumConfigs = 1;

    status_t err =mHwc->getDisplayConfigs(mHwc, disp, &config, &numConfigs);

 

 

    err =mHwc->getDisplayAttributes(mHwc, disp, config, DISPLAY_ATTRIBUTES, values);

 

 

    int32_t w = 0, h =0;

    for (size_t i =0; i <NUM_DISPLAY_ATTRIBUTES -1; i++) {

        switch(DISPLAY_ATTRIBUTES[i]) {

        caseHWC_DISPLAY_VSYNC_PERIOD:

           mDisplayData[disp].refresh = nsecs_t(values[i]);

            break;

        caseHWC_DISPLAY_WIDTH:

           mDisplayData[disp].width = values[i];

            break;

        caseHWC_DISPLAY_HEIGHT:

           mDisplayData[disp].height = values[i];

            break;

        caseHWC_DISPLAY_DPI_X:

           mDisplayData[disp].xdpi = values[i] /1000.0f;

            break;

        case HWC_DISPLAY_DPI_Y:

           mDisplayData[disp].ydpi = values[i] /1000.0f;

            break;

        default:

           ALOG_ASSERT(false,"unknown display attribute[%d]%#x",

                   i, DISPLAY_ATTRIBUTES[i]);

            break;

        }

    }

 

    // FIXME: what should we set the formatto?

   mDisplayData[disp].format = HAL_PIXEL_FORMAT_RGBA_8888;

   mDisplayData[disp].connected = true;

    if(mDisplayData[disp].xdpi ==0.0f || mDisplayData[disp].ydpi ==0.0f) {

        float dpi = getDefaultDensity(h);

       mDisplayData[disp].xdpi = dpi;

       mDisplayData[disp].ydpi = dpi;

    }

    return NO_ERROR;

}

surfaceflinger初始化displays

SurfaceFlinger::init()—>

 // initialize ournon-virtual displays

 // 初始化物理屏幕，NUM_BUILTIN_DISPLAY_TYPES2

 // 目前除了默认屏幕，还支持一个hdmi的物理屏幕

    for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {

        DisplayDevice::DisplayTypetype((DisplayDevice::DisplayType)i);

        // set-upthe displays that are already connected

        // 屏幕是否连接，即HWC中已经成功获取到这个屏幕的信息

        if(mHwc->isConnected(i) ||type==DisplayDevice::DISPLAY_PRIMARY) {

            // All non-virtual displays are currently consideredsecure.

            bool isSecure = true;

           // 创建显示器在surface flinger中的代表，newBBinder，

           // 将newBBinder和DisplayDeviceState保存在mCurrentState.displays中

            createBuiltinDisplayLocked(type);

            //取出上面的BBinder

            wp<IBinder> token = mBuiltinDisplays[i];

 

       //新建BufferQueue，FramebufferSurface，DisplayDevice

            sp<BufferQueue> bq = newBufferQueue(newGraphicBufferAlloc());

            sp<FramebufferSurface> fbs = newFramebufferSurface(*mHwc, i, bq);

            sp<DisplayDevice> hw = newDisplayDevice(this,

                    type, allocateHwcDisplayId(type),isSecure, token,

                    fbs, bq,

                    mEGLConfig);

            if (i > DisplayDevice::DISPLAY_PRIMARY) {

                // FIXME: currently we don't get blank/unblank requests

                // for displays other than the maindisplay, so we always

                // assume a connected display isunblanked.

                ALOGD("marking display %d as acquired/unblanked",i);

                hw->acquireScreen();

            }

        // DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> >mDisplays;

           mDisplays.add(token, hw);

        }

    }

boolHWComposer::isConnected(int disp)const {

    returnmDisplayData[disp].connected;

}

    struct State {

        LayerVectorlayersSortedByZ;

       DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>displays;

    };

 

    structDisplayDeviceState {

       DisplayDeviceState();

       DisplayDeviceState(DisplayDevice::DisplayTypetype);

        boolisValid() const { returntype >=0; }

        boolisMainDisplay() const { returntype ==DisplayDevice::DISPLAY_PRIMARY; }

        boolisVirtualDisplay() const {returntype >=DisplayDevice::DISPLAY_VIRTUAL; }

       DisplayDevice::DisplayType type;

        sp<IGraphicBufferProducer>surface;

        uint32_tlayerStack;

        Rectviewport;

        Rect frame;

        uint8_torientation;

        String8displayName;

        boolisSecure;

    };

 

voidSurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayTypetype) {

   ALOGW_IF(mBuiltinDisplays[type],

            "Overwriting display token fordisplay type %d",type);

    //sp<IBinder> mBuiltinDisplays[2];就是new BBinder，

   mBuiltinDisplays[type] =new BBinder();

   DisplayDeviceState info(type);

    // All non-virtual displays arecurrently considered secure.

    //非virtual display都是secure的

    info.isSecure =true;

    // State mCurrentState;

   mCurrentState.displays.add(mBuiltinDisplays[type],info);

}

SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayTypetype)

    : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0) {

    viewport.makeInvalid();

    frame.makeInvalid();

}

通过上面的步骤，主要填充了HWComposer的mDisplayDate[3]、surface flinger的mCurrentState.displays(token,DisplayDeviceState)，mDisplays(token,DisplayDevice)，mBuiltinDisplays[2]（BBinder），

    // initializeour drawing state

    mDrawingState =mCurrentState;

    // set initial conditions (e.g. unblankdefault device)

    initializeDisplays();

voidSurfaceFlinger::initializeDisplays() {

    classMessageScreenInitialized : public MessageBase {

       SurfaceFlinger* flinger;

    public:

        MessageScreenInitialized(SurfaceFlinger*flinger) :flinger(flinger) { }

        virtualbool handler() {

           flinger->onInitializeDisplays();

            returntrue;

        }

    };

   sp<MessageBase> msg = new MessageScreenInitialized(this);

    postMessageAsync(msg);  // we may be called from main thread, use async message

}

void SurfaceFlinger::onInitializeDisplays() {

    // reset screenorientation and use primarylayer stack

    Vector<ComposerState>state;

   Vector<DisplayState> displays;

    //新建一个DisplayState

    DisplayState d;

    d.what =DisplayState::eDisplayProjectionChanged |

            DisplayState::eLayerStackChanged;

    //默认屏幕的token

    d.token =mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];

    //layerStack 为0，orientation为默认的eOrientationDefault

    d.layerStack =0;

    d.orientation =DisplayState::eOrientationDefault;

    d.frame.makeInvalid();

    d.viewport.makeInvalid();

    displays.add(d);

    //利用displays的信息，设置mCurrentState.displays的状态

   setTransactionState(state, displays,0);

   onScreenAcquired(getDefaultDisplayDevice());

 

    const nsecs_tperiod =

           getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);

   mAnimFrameTracker.setDisplayRefreshPeriod(period);

}

voidSurfaceFlinger::setTransactionState(

        constVector<ComposerState>& state,

        constVector<DisplayState>& displays,

        uint32_tflags)

{

    ATRACE_CALL();

    Mutex::Autolock_l(mStateLock);

    uint32_ttransactionFlags = 0;

 

 

 

    size_t count =displays.size();

    for (size_t i=0 ; i<count ;i++) {

        const DisplayState&s(displays[i]);

       transactionFlags |= setDisplayStateLocked(s);

    }

}

//根据DisplayState的信息更新mCurrentState.displays的信息

uint32_t SurfaceFlinger::setDisplayStateLocked(constDisplayState& s)

{

    ssize_t dpyIdx= mCurrentState.displays.indexOfKey(s.token);

    if (dpyIdx <0)

        return 0;

 

    uint32_t flags= 0;

   DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));

    if (disp.isValid()) {

        constuint32_t what = s.what;

        if (what& DisplayState::eSurfaceChanged) {

            if(disp.surface->asBinder()!= s.surface->asBinder()){

               disp.surface = s.surface;

                flags |= eDisplayTransactionNeeded;

            }

        }

        if (what& DisplayState::eLayerStackChanged) {

            if(disp.layerStack != s.layerStack) {

               disp.layerStack = s.layerStack;

               flags |= eDisplayTransactionNeeded;

            }

        }

        if (what& DisplayState::eDisplayProjectionChanged) {

            if(disp.orientation != s.orientation) {

               disp.orientation = s.orientation;

               flags |= eDisplayTransactionNeeded;

            }

            if(disp.frame != s.frame) {

               disp.frame = s.frame;

               flags |= eDisplayTransactionNeeded;

            }

            if(disp.viewport != s.viewport) {

               disp.viewport = s.viewport;

                flags |=eDisplayTransactionNeeded;

            }

        }

    }

    return flags;

}

    // returns the default Display

    //返回默认屏幕的DisplayDevice

    sp<constDisplayDevice> getDefaultDisplayDevice()const {

        return getDisplayDevice(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);

    }

 

   sp<DisplayDevice> getDisplayDevice(constwp<IBinder>& dpy) {

        returnmDisplays.valueFor(dpy);

    }

void SurfaceFlinger::onScreenAcquired(const sp<constDisplayDevice>& hw) {

    ALOGD("Screen acquired, type=%dflinger=%p", hw->getDisplayType(), this);

    if (hw->isScreenAcquired()){

        // this is expected, e.g. when powermanager wakes up during boot

        ALOGD(" screen was previouslyacquired");

        return;

    }

 

    hw->acquireScreen();

    int32_t type= hw->getDisplayType();

    if (type< DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {

        // built-in display, tell the HWC

       getHwComposer().acquire(type);

 

        if (type== DisplayDevice::DISPLAY_PRIMARY) {

            // FIXME: eventthread only knows aboutthe main display right now

           mEventThread->onScreenAcquired();

        //开启vsync开关

           resyncToHardwareVsync(true);

        }

    }

   mVisibleRegionsDirty =true;

   repaintEverything();

}

voidDisplayDevice::acquireScreen()const {

    mScreenAcquired= true;

}

//acquire就是调用Hwc HAL的blank函数，

status_t HWComposer::acquire(int disp) {

    LOG_FATAL_IF(disp >=VIRTUAL_DISPLAY_ID_BASE);

    if (mHwc) {

        return(status_t)mHwc->blank(mHwc,disp, 0);

    }

    return NO_ERROR;

}

通过上面的分析，在底层，即surfaceflinger、HWC、Hwc中已经填充了系统displays的基本信息，后续分析surfaceflinger之上是如何初始化和使用displays的，上下联系起来。