Merge "Remove experimental HWC virtual display support" into jb-mr2-dev

    SurfaceFlingerConsumer.cpp \

    SurfaceTextureLayer.cpp \

    Transform.cpp \

    DisplayHardware/BufferQueueInterposer.cpp \

    DisplayHardware/FramebufferSurface.cpp \

    DisplayHardware/HWComposer.cpp \

    DisplayHardware/PowerHAL.cpp \

/*

 * Copyright 2013 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.

 */

#undef LOG_TAG

#define LOG_TAG "BQInterposer"

//#define LOG_NDEBUG 0

#include "BufferQueueInterposer.h"

// ---------------------------------------------------------------------------

namespace android {

// ---------------------------------------------------------------------------

#define BQI_LOGV(x, ...) ALOGV("[%s] "x, mName.string(), ##__VA_ARGS__)

#define BQI_LOGD(x, ...) ALOGD("[%s] "x, mName.string(), ##__VA_ARGS__)

#define BQI_LOGI(x, ...) ALOGI("[%s] "x, mName.string(), ##__VA_ARGS__)

#define BQI_LOGW(x, ...) ALOGW("[%s] "x, mName.string(), ##__VA_ARGS__)

#define BQI_LOGE(x, ...) ALOGE("[%s] "x, mName.string(), ##__VA_ARGS__)

// Get an ID that's unique within this process.

static int32_t createProcessUniqueId() {

    static volatile int32_t globalCounter = 0;

    return android_atomic_inc(&globalCounter);

}

BufferQueueInterposer::BufferQueueInterposer(

        const sp<IGraphicBufferProducer>& sink, const String8& name)

:   mSink(sink),

    mName(name),

    mAcquired(false)

{

    BQI_LOGV("BufferQueueInterposer sink=%p", sink.get());

}

BufferQueueInterposer::~BufferQueueInterposer() {

    Mutex::Autolock lock(mMutex);

    flushQueuedBuffersLocked();

    BQI_LOGV("~BufferQueueInterposer");

}

status_t BufferQueueInterposer::requestBuffer(int slot,

        sp<GraphicBuffer>* outBuf) {

    BQI_LOGV("requestBuffer slot=%d", slot);

    Mutex::Autolock lock(mMutex);

    if (size_t(slot) >= mBuffers.size()) {

        size_t size = mBuffers.size();

        mBuffers.insertAt(size, size - slot + 1);

    }

    sp<GraphicBuffer>& buf = mBuffers.editItemAt(slot);

    status_t result = mSink->requestBuffer(slot, &buf);

    *outBuf = buf;

    return result;

}

status_t BufferQueueInterposer::setBufferCount(int bufferCount) {

    BQI_LOGV("setBufferCount count=%d", bufferCount);

    Mutex::Autolock lock(mMutex);

    bufferCount += 1;

    status_t result = flushQueuedBuffersLocked();

    if (result != NO_ERROR)

        return result;

    result = mSink->setBufferCount(bufferCount);

    if (result != NO_ERROR)

        return result;

    for (size_t i = 0; i < mBuffers.size(); i++)

        mBuffers.editItemAt(i).clear();

    ssize_t n = mBuffers.resize(bufferCount);

    result = (n < 0) ? n : result;

    return result;

}

status_t BufferQueueInterposer::dequeueBuffer(int* slot, sp<Fence>* fence,

            uint32_t w, uint32_t h, uint32_t format, uint32_t usage) {

    BQI_LOGV("dequeueBuffer %ux%u fmt=%u usage=%#x", w, h, format, usage);

    return mSink->dequeueBuffer(slot, fence, w, h, format, usage);

}

status_t BufferQueueInterposer::queueBuffer(int slot,

            const QueueBufferInput& input, QueueBufferOutput* output) {

    BQI_LOGV("queueBuffer slot=%d", slot);

    Mutex::Autolock lock(mMutex);

    mQueue.push(QueuedBuffer(slot, input));

    *output = mQueueBufferOutput;

    return NO_ERROR;

}

void BufferQueueInterposer::cancelBuffer(int slot, const sp<Fence>& fence) {

    BQI_LOGV("cancelBuffer slot=%d", slot);

    mSink->cancelBuffer(slot, fence);

}

int BufferQueueInterposer::query(int what, int* value) {

    BQI_LOGV("query what=%d", what);

    return mSink->query(what, value);

}

status_t BufferQueueInterposer::setSynchronousMode(bool enabled) {

    BQI_LOGV("setSynchronousMode %s", enabled ? "true" : "false");

    return mSink->setSynchronousMode(enabled);

}

status_t BufferQueueInterposer::connect(int api, QueueBufferOutput* output) {

    BQI_LOGV("connect api=%d", api);

    Mutex::Autolock lock(mMutex);

    status_t result = mSink->connect(api, &mQueueBufferOutput);

    if (result == NO_ERROR) {

        *output = mQueueBufferOutput;

    }

    return result;

}

status_t BufferQueueInterposer::disconnect(int api) {

    BQI_LOGV("disconnect: api=%d", api);

    Mutex::Autolock lock(mMutex);

    flushQueuedBuffersLocked();

    return mSink->disconnect(api);

}

status_t BufferQueueInterposer::pullEmptyBuffer() {

    status_t result;

    int slot;

    sp<Fence> fence;

    result = dequeueBuffer(&slot, &fence, 0, 0, 0, 0);

    if (result == IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {

        sp<GraphicBuffer> buffer;

        result = requestBuffer(slot, &buffer);

    } else if (result != NO_ERROR) {

        return result;

    }

    uint32_t w, h, transformHint, numPendingBuffers;

    mQueueBufferOutput.deflate(&w, &h, &transformHint, &numPendingBuffers);

    IGraphicBufferProducer::QueueBufferInput qbi(0, Rect(w, h),

            NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, fence);

    IGraphicBufferProducer::QueueBufferOutput qbo;

    result = queueBuffer(slot, qbi, &qbo);

    if (result != NO_ERROR)

        return result;

    return NO_ERROR;

}

status_t BufferQueueInterposer::acquireBuffer(sp<GraphicBuffer>* buf,

        sp<Fence>* fence) {

    Mutex::Autolock lock(mMutex);

    if (mQueue.empty()) {

        BQI_LOGV("acquireBuffer: no buffers available");

        return NO_BUFFER_AVAILABLE;

    }

    if (mAcquired) {

        BQI_LOGE("acquireBuffer: buffer already acquired");

        return BUFFER_ALREADY_ACQUIRED;

    }

    BQI_LOGV("acquireBuffer: acquiring slot %d", mQueue[0].slot);

    *buf = mBuffers[mQueue[0].slot];

    *fence = mQueue[0].fence;

    mAcquired = true;

    return NO_ERROR;

}

status_t BufferQueueInterposer::releaseBuffer(const sp<Fence>& fence) {

    Mutex::Autolock lock(mMutex);

    if (!mAcquired) {

        BQI_LOGE("releaseBuffer: releasing a non-acquired buffer");

        return BUFFER_NOT_ACQUIRED;

    }

    BQI_LOGV("releaseBuffer: releasing slot %d to sink", mQueue[0].slot);

    const QueuedBuffer& b = mQueue[0];

    status_t result = mSink->queueBuffer(b.slot,

            QueueBufferInput(b.timestamp, b.crop, b.scalingMode,

                b.transform, b.fence),

            &mQueueBufferOutput);

    mQueue.removeAt(0);

    mAcquired = false;

    return result;

}

status_t BufferQueueInterposer::flushQueuedBuffersLocked() {

    if (mAcquired) {

        BQI_LOGE("flushQueuedBuffersLocked: buffer acquired, can't flush");

        return INVALID_OPERATION;

    }

    status_t result = NO_ERROR;

    for (size_t i = 0; i < mQueue.size(); i++) {

        const QueuedBuffer& b = mQueue[i];

        BQI_LOGV("flushing queued slot %d to sink", b.slot);

        status_t err = mSink->queueBuffer(b.slot,

                QueueBufferInput(b.timestamp, b.crop, b.scalingMode,

                    b.transform, b.fence),

                &mQueueBufferOutput);

        if (err != NO_ERROR && result == NO_ERROR) // latch first error

            result = err;

    }

    mQueue.clear();

    return result;

}

// ---------------------------------------------------------------------------

} // namespace android

// ---------------------------------------------------------------------------

/*

 * Copyright 2013 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.

 */

#ifndef ANDROID_SF_BUFFERQUEUEINTERPOSER_H

#define ANDROID_SF_BUFFERQUEUEINTERPOSER_H

#include <gui/IGraphicBufferProducer.h>

#include <utils/Mutex.h>

#include <utils/Vector.h>

// ---------------------------------------------------------------------------

namespace android {

// ---------------------------------------------------------------------------

// BufferQueueInterposers introduce an extra stage between a buffer producer

// (the source) and a buffer consumer (the sink), which communicate via the

// IGraphicBufferProducer interface. It is designed to be as transparent as

// possible to both endpoints, so that they can work the same whether an

// interposer is present or not.

//

// When the interpose is present, the source queues buffers to the

// IGraphicBufferProducer implemented by BufferQueueInterposer. A client of

// the BufferQueueInterposer can acquire each buffer in turn and read or

// modify it, releasing the buffer when finished. When the buffer is released,

// the BufferQueueInterposer queues it to the original IGraphicBufferProducer

// interface representing the sink.

//

// A BufferQueueInterposer can be used to do additional rendering to a buffer

// before it is consumed -- essentially pipelining two producers. As an

// example, SurfaceFlinger uses this to implement mixed GLES and HWC

// compositing to the same buffer for virtual displays. If it used two separate

// buffer queues, then in GLES-only or mixed GLES+HWC compositing, the HWC

// would have to copy the GLES output buffer to the HWC output buffer, using

// more bandwidth than having HWC do additional composition "in place" on the

// GLES output buffer.

//

// The goal for this class is to be usable in a variety of situations and be

// part of libgui. But both the interface and implementation need some

// iteration before then, so for now it should only be used by

// VirtualDisplaySurface, which is why it's currently in SurfaceFlinger.

//

// Some of the problems that still need to be solved are:

//

// - Refactor the interposer interface along with BufferQueue and ConsumerBase,

//   so that there is a common interface for the consumer end of a queue. The

//   existing interfaces have some problems when the implementation isn't the

//   final consumer.

//

// - The client of the interposer may need one or more buffers in addition to

//   those used by the source and sink. IGraphicBufferProducer will probably

//   need to change to allow the producer to specify how many buffers it needs

//   to dequeue at a time, and then the interposer can add its requirements to

//   those of the source.

//

// - Abandoning, disconnecting, and connecting need to pass through somehow.

//   There needs to be a way to tell the interposer client to release its

//   buffer immediately so it can be queued/released, e.g. when the source

//   calls disconnect().

//

// - Right now the source->BQI queue is synchronous even if the BQI->sink queue

//   is asynchronous. Need to figure out how asynchronous should behave and

//   implement that.

class BufferQueueInterposer : public BnGraphicBufferProducer {

public:

    BufferQueueInterposer(const sp<IGraphicBufferProducer>& sink,

            const String8& name);

    //

    // IGraphicBufferProducer interface

    //

    virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* outBuf);

    virtual status_t setBufferCount(int bufferCount);

    virtual status_t dequeueBuffer(int* slot, sp<Fence>* fence,

            uint32_t w, uint32_t h, uint32_t format, uint32_t usage);

    virtual status_t queueBuffer(int slot,

            const QueueBufferInput& input, QueueBufferOutput* output);

    virtual void cancelBuffer(int slot, const sp<Fence>& fence);

    virtual int query(int what, int* value);

    virtual status_t setSynchronousMode(bool enabled);

    virtual status_t connect(int api, QueueBufferOutput* output);

    virtual status_t disconnect(int api);

    //

    // Interposer interface

    //

    enum {

        NO_BUFFER_AVAILABLE = 2,    // matches BufferQueue

        BUFFER_NOT_ACQUIRED,

        BUFFER_ALREADY_ACQUIRED,

    };

    // Acquire the oldest queued buffer. If no buffers are pending, returns

    // NO_BUFFER_AVAILABLE. If a buffer is currently acquired, returns

    // BUFFER_ALREADY_ACQUIRED.

    status_t acquireBuffer(sp<GraphicBuffer>* buf, sp<Fence>* fence);

    // Release the currently acquired buffer, queueing it to the sink. If the

    // current buffer hasn't been acquired, returns BUFFER_NOT_ACQUIRED.

    status_t releaseBuffer(const sp<Fence>& fence);

    // pullEmptyBuffer dequeues a buffer from the sink, then immediately

    // queues it to the interposer. This makes a buffer available for the

    // client to acquire even if the source hasn't queued one.

    status_t pullEmptyBuffer();

private:

    struct QueuedBuffer {

        QueuedBuffer(): slot(-1) {}

        QueuedBuffer(int slot, const QueueBufferInput& qbi): slot(slot) {

            qbi.deflate(&timestamp, &crop, &scalingMode, &transform, &fence);

        }

        int slot;

        int64_t timestamp;

        Rect crop;

        int scalingMode;

        uint32_t transform;

        sp<Fence> fence;

    };

    virtual ~BufferQueueInterposer();

    status_t flushQueuedBuffersLocked();

    const sp<IGraphicBufferProducer> mSink;

    String8 mName;

    Mutex mMutex;

    Vector<sp<GraphicBuffer> > mBuffers;

    Vector<QueuedBuffer> mQueue;

    bool mAcquired;

    QueueBufferOutput mQueueBufferOutput;

};

// ---------------------------------------------------------------------------

} // namespace android

// ---------------------------------------------------------------------------

#endif // ANDROID_SF_BUFFERQUEUEINTERPOSER_H

namespace android {

// This is not a real HWC version. It's used for in-development features that

// haven't been committed to a specific real HWC version.

#define HWC_DEVICE_API_VERSION_1_EXP HARDWARE_DEVICE_API_VERSION_2(1, 0xFF, HWC_HEADER_VERSION)

#define MIN_HWC_HEADER_VERSION HWC_HEADER_VERSION

#define NUM_PHYSICAL_DISPLAYS HWC_NUM_DISPLAY_TYPES

        // the number of displays we actually have depends on the

        // hw composer version

        if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {

            // 1.2 adds support for virtual displays

        if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_EXP)) {

            // 1.?? adds support for virtual displays

            mNumDisplays = MAX_DISPLAYS;

        } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {

            // 1.1 adds support for multiple displays

        }

        mLists[i] = disp.list;

        if (mLists[i]) {

            if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {

            if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_EXP)) {

                mLists[i]->outbuf = NULL;

                mLists[i]->outbufAcquireFenceFd = -1;

            } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {

 */

#include "VirtualDisplaySurface.h"

#include "HWComposer.h"

#include <cutils/log.h>

#include <gui/IGraphicBufferProducer.h>

// ---------------------------------------------------------------------------

namespace android {

VirtualDisplaySurface::VirtualDisplaySurface(HWComposer& hwc, int32_t dispId,

        const sp<IGraphicBufferProducer>& sink, const String8& name)

:   mHwc(hwc),

    mDisplayId(dispId),

    mName(name)

:   mSink(sink)

{

    if (mDisplayId >= 0) {

        mInterposer = new BufferQueueInterposer(sink, name);

        mSourceProducer = mInterposer;

    } else {

        mSourceProducer = sink;

    }

    LOG_ALWAYS_FATAL_IF(dispId >= 0);

}

VirtualDisplaySurface::~VirtualDisplaySurface() {

    if (mAcquiredBuffer != NULL) {

        status_t result = mInterposer->releaseBuffer(Fence::NO_FENCE);

        ALOGE_IF(result != NO_ERROR, "VirtualDisplaySurface \"%s\": "

                "failed to release buffer: %d", mName.string(), result);

    }

}

sp<IGraphicBufferProducer> VirtualDisplaySurface::getIGraphicBufferProducer() const {

    return mSourceProducer;

    return mSink;

}

status_t VirtualDisplaySurface::compositionComplete() {

}

status_t VirtualDisplaySurface::advanceFrame() {

    if (mInterposer == NULL)

    return NO_ERROR;

    Mutex::Autolock lock(mMutex);

    status_t result = NO_ERROR;

    if (mAcquiredBuffer != NULL) {

        ALOGE("VirtualDisplaySurface \"%s\": "

                "advanceFrame called twice without onFrameCommitted",

                mName.string());

        return INVALID_OPERATION;

    }

    sp<Fence> fence;

    result = mInterposer->acquireBuffer(&mAcquiredBuffer, &fence);

    if (result == BufferQueueInterposer::NO_BUFFER_AVAILABLE) {

        result = mInterposer->pullEmptyBuffer();

        if (result != NO_ERROR)

            return result;

        result = mInterposer->acquireBuffer(&mAcquiredBuffer, &fence);

    }

    if (result != NO_ERROR)

        return result;

    result = mHwc.fbPost(mDisplayId, fence, mAcquiredBuffer);

    if (result == NO_ERROR) {

        result = mHwc.setOutputBuffer(mDisplayId, fence, mAcquiredBuffer);

    }

    return result;

}

void VirtualDisplaySurface::onFrameCommitted() {

    if (mInterposer == NULL)

        return;

    Mutex::Autolock lock(mMutex);

    if (mAcquiredBuffer != NULL) {

        // fbFence signals when reads from the framebuffer are finished

        // outFence signals when writes to the output buffer are finished

        // It's unlikely that there will be an implementation where fbFence

        // signals after outFence (in fact they'll typically be the same

        // sync_pt), but just to be pedantic we merge them so the sink will

        // be sure to wait until both are complete.

        sp<Fence> fbFence = mHwc.getAndResetReleaseFence(mDisplayId);

        sp<Fence> outFence = mHwc.getLastRetireFence(mDisplayId);

        sp<Fence> fence = Fence::merge(

                String8::format("HWC done: %.21s", mName.string()),

                fbFence, outFence);

        status_t result = mInterposer->releaseBuffer(fence);

        ALOGE_IF(result != NO_ERROR, "VirtualDisplaySurface \"%s\": "

                "failed to release buffer: %d", mName.string(), result);

        mAcquiredBuffer.clear();

    }

}

void VirtualDisplaySurface::dump(String8& result) const {