|
|
/* |
|
|
// Copyright (c) 2014 Intel Corporation |
|
|
// |
|
|
// 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 VIRTUAL_DEVICE_H |
|
|
#define VIRTUAL_DEVICE_H |
|
|
|
|
|
#include <IDisplayDevice.h> |
|
|
#include <SimpleThread.h> |
|
|
#include <IVideoPayloadManager.h> |
|
|
#include <utils/Condition.h> |
|
|
#include <utils/Mutex.h> |
|
|
#include <utils/Vector.h> |
|
|
#include <utils/List.h> |
|
|
#ifdef INTEL_WIDI |
|
|
#include "IFrameServer.h" |
|
|
#endif |
|
|
#include <va/va.h> |
|
|
#include <va/va_vpp.h> |
|
|
|
|
|
namespace android { |
|
|
namespace intel { |
|
|
|
|
|
class Hwcomposer; |
|
|
class DisplayPlaneManager; |
|
|
class IVideoPayloadManager; |
|
|
class SoftVsyncObserver; |
|
|
|
|
|
#ifdef INTEL_WIDI |
|
|
class VirtualDevice : public IDisplayDevice, public BnFrameServer { |
|
|
#else |
|
|
class VirtualDevice : public IDisplayDevice, public RefBase{ |
|
|
#endif |
|
|
protected: |
|
|
class VAMappedHandle; |
|
|
class VAMappedHandleObject; |
|
|
struct CachedBuffer : public android::RefBase { |
|
|
CachedBuffer(BufferManager *mgr, buffer_handle_t handle); |
|
|
~CachedBuffer(); |
|
|
BufferManager *manager; |
|
|
BufferMapper *mapper; |
|
|
VAMappedHandle *vaMappedHandle; |
|
|
buffer_handle_t cachedKhandle; |
|
|
}; |
|
|
struct HeldDecoderBuffer : public android::RefBase { |
|
|
HeldDecoderBuffer(const sp<VirtualDevice>& vd, const android::sp<CachedBuffer>& cachedBuffer); |
|
|
virtual ~HeldDecoderBuffer(); |
|
|
android::sp<VirtualDevice> vd; |
|
|
android::sp<CachedBuffer> cachedBuffer; |
|
|
}; |
|
|
#ifdef INTEL_WIDI |
|
|
struct Configuration { |
|
|
sp<IFrameTypeChangeListener> typeChangeListener; |
|
|
sp<IFrameListener> frameListener; |
|
|
FrameProcessingPolicy policy; |
|
|
bool frameServerActive; |
|
|
bool extendedModeEnabled; |
|
|
bool forceNotifyFrameType; |
|
|
bool forceNotifyBufferInfo; |
|
|
}; |
|
|
#endif |
|
|
class BufferList { |
|
|
public: |
|
|
BufferList(VirtualDevice& vd, const char* name, uint32_t limit, uint32_t format, uint32_t usage); |
|
|
buffer_handle_t get(uint32_t width, uint32_t height, sp<RefBase>* heldBuffer); |
|
|
void clear(); |
|
|
private: |
|
|
struct HeldBuffer; |
|
|
VirtualDevice& mVd; |
|
|
const char* mName; |
|
|
android::List<buffer_handle_t> mAvailableBuffers; |
|
|
const uint32_t mLimit; |
|
|
const uint32_t mFormat; |
|
|
const uint32_t mUsage; |
|
|
uint32_t mBuffersToCreate; |
|
|
uint32_t mWidth; |
|
|
uint32_t mHeight; |
|
|
}; |
|
|
struct Task; |
|
|
struct RenderTask; |
|
|
struct ComposeTask; |
|
|
struct EnableVspTask; |
|
|
struct DisableVspTask; |
|
|
struct BlitTask; |
|
|
struct FrameTypeChangedTask; |
|
|
struct BufferInfoChangedTask; |
|
|
struct OnFrameReadyTask; |
|
|
|
|
|
Mutex mConfigLock; |
|
|
#ifdef INTEL_WIDI |
|
|
Configuration mCurrentConfig; |
|
|
Configuration mNextConfig; |
|
|
#endif |
|
|
ssize_t mRgbLayer; |
|
|
ssize_t mYuvLayer; |
|
|
bool mProtectedMode; |
|
|
|
|
|
buffer_handle_t mExtLastKhandle; |
|
|
int64_t mExtLastTimestamp; |
|
|
|
|
|
int64_t mRenderTimestamp; |
|
|
|
|
|
Mutex mTaskLock; // for task queue and buffer lists |
|
|
BufferList mCscBuffers; |
|
|
BufferList mRgbUpscaleBuffers; |
|
|
DECLARE_THREAD(WidiBlitThread, VirtualDevice); |
|
|
Condition mRequestQueued; |
|
|
Condition mRequestDequeued; |
|
|
Vector< sp<Task> > mTasks; |
|
|
|
|
|
// fence info |
|
|
int mSyncTimelineFd; |
|
|
unsigned mNextSyncPoint; |
|
|
bool mExpectAcquireFences; |
|
|
#ifdef INTEL_WIDI |
|
|
FrameInfo mLastInputFrameInfo; |
|
|
FrameInfo mLastOutputFrameInfo; |
|
|
#endif |
|
|
int32_t mVideoFramerate; |
|
|
|
|
|
android::KeyedVector<buffer_handle_t, android::sp<CachedBuffer> > mMappedBufferCache; |
|
|
android::Mutex mHeldBuffersLock; |
|
|
android::KeyedVector<buffer_handle_t, android::sp<android::RefBase> > mHeldBuffers; |
|
|
|
|
|
// VSP |
|
|
bool mVspInUse; |
|
|
bool mVspEnabled; |
|
|
uint32_t mVspWidth; |
|
|
uint32_t mVspHeight; |
|
|
VADisplay va_dpy; |
|
|
VAConfigID va_config; |
|
|
VAContextID va_context; |
|
|
VASurfaceID va_blank_yuv_in; |
|
|
VASurfaceID va_blank_rgb_in; |
|
|
android::KeyedVector<buffer_handle_t, android::sp<VAMappedHandleObject> > mVaMapCache; |
|
|
|
|
|
bool mVspUpscale; |
|
|
bool mDebugVspClear; |
|
|
bool mDebugVspDump; |
|
|
uint32_t mDebugCounter; |
|
|
|
|
|
private: |
|
|
android::sp<CachedBuffer> getMappedBuffer(buffer_handle_t handle); |
|
|
|
|
|
bool sendToWidi(hwc_display_contents_1_t *display); |
|
|
bool queueCompose(hwc_display_contents_1_t *display); |
|
|
bool queueColorConvert(hwc_display_contents_1_t *display); |
|
|
#ifdef INTEL_WIDI |
|
|
bool handleExtendedMode(hwc_display_contents_1_t *display); |
|
|
|
|
|
void queueFrameTypeInfo(const FrameInfo& inputFrameInfo); |
|
|
void queueBufferInfo(const FrameInfo& outputFrameInfo); |
|
|
#endif |
|
|
void colorSwap(buffer_handle_t src, buffer_handle_t dest, uint32_t pixelCount); |
|
|
void vspPrepare(uint32_t width, uint32_t height); |
|
|
void vspEnable(uint32_t width, uint32_t height); |
|
|
void vspDisable(); |
|
|
void vspCompose(VASurfaceID videoIn, VASurfaceID rgbIn, VASurfaceID videoOut, |
|
|
const VARectangle* surface_region, const VARectangle* output_region); |
|
|
|
|
|
bool getFrameOfSize(uint32_t width, uint32_t height, const IVideoPayloadManager::MetaData& metadata, IVideoPayloadManager::Buffer& info); |
|
|
void setMaxDecodeResolution(uint32_t width, uint32_t height); |
|
|
|
|
|
public: |
|
|
VirtualDevice(Hwcomposer& hwc); |
|
|
virtual ~VirtualDevice(); |
|
|
bool isFrameServerActive() const; |
|
|
|
|
|
public: |
|
|
virtual bool prePrepare(hwc_display_contents_1_t *display); |
|
|
virtual bool prepare(hwc_display_contents_1_t *display); |
|
|
virtual bool commit(hwc_display_contents_1_t *display, |
|
|
IDisplayContext *context); |
|
|
|
|
|
virtual bool vsyncControl(bool enabled); |
|
|
virtual bool blank(bool blank); |
|
|
virtual bool getDisplaySize(int *width, int *height); |
|
|
virtual bool getDisplayConfigs(uint32_t *configs, |
|
|
size_t *numConfigs); |
|
|
virtual bool getDisplayAttributes(uint32_t config, |
|
|
const uint32_t *attributes, |
|
|
int32_t *values); |
|
|
virtual bool compositionComplete(); |
|
|
virtual bool initialize(); |
|
|
virtual void deinitialize(); |
|
|
virtual bool isConnected() const; |
|
|
virtual const char* getName() const; |
|
|
virtual int getType() const; |
|
|
virtual void onVsync(int64_t timestamp); |
|
|
virtual void dump(Dump& d); |
|
|
virtual uint32_t getFpsDivider(); |
|
|
#ifdef INTEL_WIDI |
|
|
// IFrameServer methods |
|
|
virtual android::status_t start(sp<IFrameTypeChangeListener> frameTypeChangeListener); |
|
|
virtual android::status_t stop(bool isConnected); |
|
|
/* TODO: 64-bit - this handle of size 32-bit is a problem for 64-bit */ |
|
|
virtual android::status_t notifyBufferReturned(int handle); |
|
|
virtual android::status_t setResolution(const FrameProcessingPolicy& policy, android::sp<IFrameListener> listener); |
|
|
#endif |
|
|
virtual bool setPowerMode(int mode); |
|
|
virtual int getActiveConfig(); |
|
|
virtual bool setActiveConfig(int index); |
|
|
|
|
|
protected: |
|
|
bool mInitialized; |
|
|
Hwcomposer& mHwc; |
|
|
IVideoPayloadManager *mPayloadManager; |
|
|
SoftVsyncObserver *mVsyncObserver; |
|
|
uint32_t mOrigContentWidth; |
|
|
uint32_t mOrigContentHeight; |
|
|
bool mFirstVideoFrame; |
|
|
bool mLastConnectionStatus; |
|
|
uint32_t mCachedBufferCapcity; |
|
|
uint32_t mDecWidth; |
|
|
uint32_t mDecHeight; |
|
|
bool mIsForceCloneMode; |
|
|
uint32_t mFpsDivider; |
|
|
}; |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
#endif /* VIRTUAL_DEVICE_H */
|
|
|
|
