Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 241cf835 authored by Ana Krulec's avatar Ana Krulec
Browse files

SF: Move DispSyncSource into it's own file. 

This change is part of go/surface-flinger-scheduler

Test: No added tests for now.

Change-Id: I527b523ed262653a3e0e602a9a499d5074b99a10
parent f4c8f386

services/surfaceflinger/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -128,6 +128,7 @@ filegroup { 
        "RenderEngine/Surface.cpp",

        "RenderEngine/Texture.cpp",

        "Scheduler/DispSync.cpp",

        "Scheduler/DispSyncSource.cpp",

        "Scheduler/EventControlThread.cpp",

        "Scheduler/EventThread.cpp",

        "Scheduler/MessageQueue.cpp",

services/surfaceflinger/Scheduler/DispSyncSource.cpp

0 → 100644
+106 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include "DispSyncSource.h"



#include <utils/Mutex.h>

#include <utils/Trace.h>



#include "DispSync.h"

#include "EventThread.h"



namespace android {



DispSyncSource::DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,

                               const char* name)

      : mName(name),

        mValue(0),

        mTraceVsync(traceVsync),

        mVsyncOnLabel(String8::format("VsyncOn-%s", name)),

        mVsyncEventLabel(String8::format("VSYNC-%s", name)),

        mDispSync(dispSync),

        mCallbackMutex(),

        mVsyncMutex(),

        mPhaseOffset(phaseOffset),

        mEnabled(false) {}



void DispSyncSource::setVSyncEnabled(bool enable) {

    Mutex::Autolock lock(mVsyncMutex);

    if (enable) {

        status_t err = mDispSync->addEventListener(mName, mPhaseOffset,

                                                   static_cast<DispSync::Callback*>(this));

        if (err != NO_ERROR) {

            ALOGE("error registering vsync callback: %s (%d)", strerror(-err), err);

        }

        // ATRACE_INT(mVsyncOnLabel.string(), 1);

    } else {

        status_t err = mDispSync->removeEventListener(static_cast<DispSync::Callback*>(this));

        if (err != NO_ERROR) {

            ALOGE("error unregistering vsync callback: %s (%d)", strerror(-err), err);

        }

        // ATRACE_INT(mVsyncOnLabel.string(), 0);

    }

    mEnabled = enable;

}



void DispSyncSource::setCallback(VSyncSource::Callback* callback) {

    Mutex::Autolock lock(mCallbackMutex);

    mCallback = callback;

}



void DispSyncSource::setPhaseOffset(nsecs_t phaseOffset) {

    Mutex::Autolock lock(mVsyncMutex);



    // Normalize phaseOffset to [0, period)

    auto period = mDispSync->getPeriod();

    phaseOffset %= period;

    if (phaseOffset < 0) {

        // If we're here, then phaseOffset is in (-period, 0). After this

        // operation, it will be in (0, period)

        phaseOffset += period;

    }

    mPhaseOffset = phaseOffset;



    // If we're not enabled, we don't need to mess with the listeners

    if (!mEnabled) {

        return;

    }



    status_t err =

            mDispSync->changePhaseOffset(static_cast<DispSync::Callback*>(this), mPhaseOffset);

    if (err != NO_ERROR) {

        ALOGE("error changing vsync offset: %s (%d)", strerror(-err), err);

    }

}



void DispSyncSource::onDispSyncEvent(nsecs_t when) {

    VSyncSource::Callback* callback;

    {

        Mutex::Autolock lock(mCallbackMutex);

        callback = mCallback;



        if (mTraceVsync) {

            mValue = (mValue + 1) % 2;

            ATRACE_INT(mVsyncEventLabel.string(), mValue);

        }

    }



    if (callback != nullptr) {

        callback->onVSyncEvent(when);

    }

}



} // namespace android
 
 No newline at end of file

services/surfaceflinger/Scheduler/DispSyncSource.h

0 → 100644
+59 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#pragma once



#include <utils/Mutex.h>

#include <utils/String8.h>



#include "DispSync.h"

#include "EventThread.h"



namespace android {



class DispSyncSource final : public VSyncSource, private DispSync::Callback {

public:

    DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync, const char* name);



    ~DispSyncSource() override = default;



    // The following methods are implementation of VSyncSource.

    void setVSyncEnabled(bool enable) override;

    void setCallback(VSyncSource::Callback* callback) override;

    void setPhaseOffset(nsecs_t phaseOffset) override;



private:

    // The following method is the implementation of the DispSync::Callback.

    virtual void onDispSyncEvent(nsecs_t when);



    const char* const mName;



    int mValue;



    const bool mTraceVsync;

    const String8 mVsyncOnLabel;

    const String8 mVsyncEventLabel;



    DispSync* mDispSync;



    Mutex mCallbackMutex; // Protects the following

    VSyncSource::Callback* mCallback = nullptr;



    Mutex mVsyncMutex; // Protects the following

    nsecs_t mPhaseOffset;

    bool mEnabled;

};



} // namespace android
 
 No newline at end of file

services/surfaceflinger/SurfaceFlinger.cpp

+1 −106
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ 
#include "Effects/Daltonizer.h"

#include "RenderEngine/RenderEngine.h"

#include "Scheduler/DispSync.h"

#include "Scheduler/DispSyncSource.h"

#include "Scheduler/EventControlThread.h"

#include "Scheduler/EventThread.h"
@@ -564,112 +565,6 @@ void SurfaceFlinger::deleteTextureAsync(uint32_t texture) { 
    postMessageAsync(new LambdaMessage([=] { getRenderEngine().deleteTextures(1, &texture); }));

}



class DispSyncSource final : public VSyncSource, private DispSync::Callback {

public:

    DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,

        const char* name) :

            mName(name),

            mValue(0),

            mTraceVsync(traceVsync),

            mVsyncOnLabel(String8::format("VsyncOn-%s", name)),

            mVsyncEventLabel(String8::format("VSYNC-%s", name)),

            mDispSync(dispSync),

            mCallbackMutex(),

            mVsyncMutex(),

            mPhaseOffset(phaseOffset),

            mEnabled(false) {}



    ~DispSyncSource() override = default;



    void setVSyncEnabled(bool enable) override {

        Mutex::Autolock lock(mVsyncMutex);

        if (enable) {

            status_t err = mDispSync->addEventListener(mName, mPhaseOffset,

                    static_cast<DispSync::Callback*>(this));

            if (err != NO_ERROR) {

                ALOGE("error registering vsync callback: %s (%d)",

                        strerror(-err), err);

            }

            //ATRACE_INT(mVsyncOnLabel.string(), 1);

        } else {

            status_t err = mDispSync->removeEventListener(

                    static_cast<DispSync::Callback*>(this));

            if (err != NO_ERROR) {

                ALOGE("error unregistering vsync callback: %s (%d)",

                        strerror(-err), err);

            }

            //ATRACE_INT(mVsyncOnLabel.string(), 0);

        }

        mEnabled = enable;

    }



    void setCallback(VSyncSource::Callback* callback) override{

        Mutex::Autolock lock(mCallbackMutex);

        mCallback = callback;

    }



    void setPhaseOffset(nsecs_t phaseOffset) override {

        Mutex::Autolock lock(mVsyncMutex);



        // Normalize phaseOffset to [0, period)

        auto period = mDispSync->getPeriod();

        phaseOffset %= period;

        if (phaseOffset < 0) {

            // If we're here, then phaseOffset is in (-period, 0). After this

            // operation, it will be in (0, period)

            phaseOffset += period;

        }

        mPhaseOffset = phaseOffset;



        // If we're not enabled, we don't need to mess with the listeners

        if (!mEnabled) {

            return;

        }



        status_t err = mDispSync->changePhaseOffset(static_cast<DispSync::Callback*>(this),

                mPhaseOffset);

        if (err != NO_ERROR) {

            ALOGE("error changing vsync offset: %s (%d)",

                    strerror(-err), err);

        }

    }



private:

    virtual void onDispSyncEvent(nsecs_t when) {

        VSyncSource::Callback* callback;

        {

            Mutex::Autolock lock(mCallbackMutex);

            callback = mCallback;



            if (mTraceVsync) {

                mValue = (mValue + 1) % 2;

                ATRACE_INT(mVsyncEventLabel.string(), mValue);

            }

        }



        if (callback != nullptr) {

            callback->onVSyncEvent(when);

        }

    }



    const char* const mName;



    int mValue;



    const bool mTraceVsync;

    const String8 mVsyncOnLabel;

    const String8 mVsyncEventLabel;



    DispSync* mDispSync;



    Mutex mCallbackMutex; // Protects the following

    VSyncSource::Callback* mCallback = nullptr;



    Mutex mVsyncMutex; // Protects the following

    nsecs_t mPhaseOffset;

    bool mEnabled;

};



class InjectVSyncSource final : public VSyncSource {

public:

    InjectVSyncSource() = default;