Add hostgraphics classes required for ImageReader

cc_library_host_static {

    name: "libhostgraphics",

    cflags: [

        "-Wno-unused-parameter",

    ],

    srcs: [

        ":libui_host_common",

        "Fence.cpp",

        "HostBufferQueue.cpp",

        "PublicFormat.cpp",

    ],

    include_dirs: [

/*

 * Copyright (C) 2019 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 <ui/Fence.h>

namespace android {

const sp<Fence> Fence::NO_FENCE = sp<Fence>(new Fence);

} // namespace android

 No newline at end of file

/*

 * Copyright (C) 2019 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 <gui/BufferQueue.h>

namespace android {

class HostBufferQueue : public IGraphicBufferProducer, public IGraphicBufferConsumer {

public:

    HostBufferQueue() : mWidth(0), mHeight(0) { }

    virtual status_t setConsumerIsProtected(bool isProtected) { return OK; }

    virtual status_t detachBuffer(int slot) { return OK; }

    virtual status_t getReleasedBuffers(uint64_t* slotMask) { return OK; }

    virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h) {

        mWidth = w;

        mHeight = h;

        mBuffer = sp<GraphicBuffer>(new GraphicBuffer(mWidth, mHeight));

        return OK;

    }

    virtual status_t setDefaultBufferFormat(PixelFormat defaultFormat) { return OK; }

    virtual status_t setDefaultBufferDataSpace(android_dataspace defaultDataSpace) { return OK; }

    virtual status_t discardFreeBuffers() { return OK; }

    virtual status_t acquireBuffer(BufferItem* buffer, nsecs_t presentWhen,

                                       uint64_t maxFrameNumber = 0) {

        buffer->mGraphicBuffer = mBuffer;

        buffer->mSlot = 0;

        return OK;

    }

    virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers) { return OK; }

    virtual status_t setConsumerUsageBits(uint64_t usage) { return OK; }

private:

    sp<GraphicBuffer> mBuffer;

    uint32_t mWidth;

    uint32_t mHeight;

};

void BufferQueue::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,

        sp<IGraphicBufferConsumer>* outConsumer) {

    sp<HostBufferQueue> obj(new HostBufferQueue());

    *outProducer = obj;

    *outConsumer = obj;

}

} // namespace android

/*

 * Copyright (C) 2019 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 <ui/PublicFormat.h>

namespace android {

android_dataspace mapPublicFormatToHalDataspace(PublicFormat f) {

    return static_cast<android_dataspace>(0);

}

int mapPublicFormatToHalFormat(PublicFormat f) {

    return static_cast<int>(f);

}

PublicFormat mapHalFormatDataspaceToPublicFormat(int format, android_dataspace dataSpace) {

    return static_cast<PublicFormat>(format);

}

} // namespace android

 No newline at end of file

/*

 * Copyright (C) 2019 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_GUI_BUFFERITEM_H

#define ANDROID_GUI_BUFFERITEM_H

#include <ui/Fence.h>

#include <ui/Rect.h>

#include <system/graphics.h>

#include <utils/StrongPointer.h>

namespace android {

class Fence;

class GraphicBuffer;

// The only thing we need here for layoutlib is mGraphicBuffer. The rest of the fields are added

// just to satisfy the calls from the android_media_ImageReader.h

class BufferItem {

public:

    enum { INVALID_BUFFER_SLOT = -1 };

    BufferItem() : mGraphicBuffer(nullptr), mFence(Fence::NO_FENCE) {}

    ~BufferItem() {}

    sp<GraphicBuffer> mGraphicBuffer;

    sp<Fence> mFence;

    Rect mCrop;

    uint32_t mTransform;

    uint32_t mScalingMode;

    int64_t mTimestamp;

    android_dataspace mDataSpace;

    uint64_t mFrameNumber;

    int mSlot;

    bool mTransformToDisplayInverse;

};

}

#endif // ANDROID_GUI_BUFFERITEM_H