1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
/*
// 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);
#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;
};
}
}
#endif /* VIRTUAL_DEVICE_H */
|
