1 /*
2 * Copyright 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // #define LOG_NDEBUG 0
18 #include "VirtualDisplaySurface.h"
19 #include "HWComposer.h"
20
21 #include <gui/BufferItem.h>
22 #include <gui/IProducerListener.h>
23
24 // ---------------------------------------------------------------------------
25 namespace android {
26 // ---------------------------------------------------------------------------
27
28 #if defined(FORCE_HWC_COPY_FOR_VIRTUAL_DISPLAYS)
29 static const bool sForceHwcCopy = true;
30 #else
31 static const bool sForceHwcCopy = false;
32 #endif
33
34 #define VDS_LOGE(msg, ...) ALOGE("[%s] " msg, \
35 mDisplayName.string(), ##__VA_ARGS__)
36 #define VDS_LOGW_IF(cond, msg, ...) ALOGW_IF(cond, "[%s] " msg, \
37 mDisplayName.string(), ##__VA_ARGS__)
38 #define VDS_LOGV(msg, ...) ALOGV("[%s] " msg, \
39 mDisplayName.string(), ##__VA_ARGS__)
40
dbgCompositionTypeStr(DisplaySurface::CompositionType type)41 static const char* dbgCompositionTypeStr(DisplaySurface::CompositionType type) {
42 switch (type) {
43 case DisplaySurface::COMPOSITION_UNKNOWN: return "UNKNOWN";
44 case DisplaySurface::COMPOSITION_GLES: return "GLES";
45 case DisplaySurface::COMPOSITION_HWC: return "HWC";
46 case DisplaySurface::COMPOSITION_MIXED: return "MIXED";
47 default: return "<INVALID>";
48 }
49 }
50
VirtualDisplaySurface(HWComposer & hwc,int32_t dispId,const sp<IGraphicBufferProducer> & sink,const sp<IGraphicBufferProducer> & bqProducer,const sp<IGraphicBufferConsumer> & bqConsumer,const String8 & name)51 VirtualDisplaySurface::VirtualDisplaySurface(HWComposer& hwc, int32_t dispId,
52 const sp<IGraphicBufferProducer>& sink,
53 const sp<IGraphicBufferProducer>& bqProducer,
54 const sp<IGraphicBufferConsumer>& bqConsumer,
55 const String8& name)
56 : ConsumerBase(bqConsumer),
57 mHwc(hwc),
58 mDisplayId(dispId),
59 mDisplayName(name),
60 mSource{},
61 mDefaultOutputFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
62 mOutputFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
63 mOutputUsage(GRALLOC_USAGE_HW_COMPOSER),
64 mProducerSlotSource(0),
65 mProducerBuffers(),
66 mQueueBufferOutput(),
67 mSinkBufferWidth(0),
68 mSinkBufferHeight(0),
69 mCompositionType(COMPOSITION_UNKNOWN),
70 mFbFence(Fence::NO_FENCE),
71 mOutputFence(Fence::NO_FENCE),
72 mFbProducerSlot(BufferQueue::INVALID_BUFFER_SLOT),
73 mOutputProducerSlot(BufferQueue::INVALID_BUFFER_SLOT),
74 mDbgState(DBG_STATE_IDLE),
75 mDbgLastCompositionType(COMPOSITION_UNKNOWN),
76 mMustRecompose(false)
77 {
78 mSource[SOURCE_SINK] = sink;
79 mSource[SOURCE_SCRATCH] = bqProducer;
80
81 resetPerFrameState();
82
83 int sinkWidth, sinkHeight;
84 sink->query(NATIVE_WINDOW_WIDTH, &sinkWidth);
85 sink->query(NATIVE_WINDOW_HEIGHT, &sinkHeight);
86 mSinkBufferWidth = sinkWidth;
87 mSinkBufferHeight = sinkHeight;
88
89 // Pick the buffer format to request from the sink when not rendering to it
90 // with GLES. If the consumer needs CPU access, use the default format
91 // set by the consumer. Otherwise allow gralloc to decide the format based
92 // on usage bits.
93 int sinkUsage;
94 sink->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS, &sinkUsage);
95 if (sinkUsage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
96 int sinkFormat;
97 sink->query(NATIVE_WINDOW_FORMAT, &sinkFormat);
98 mDefaultOutputFormat = sinkFormat;
99 } else {
100 mDefaultOutputFormat = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
101 }
102 mOutputFormat = mDefaultOutputFormat;
103
104 ConsumerBase::mName = String8::format("VDS: %s", mDisplayName.string());
105 mConsumer->setConsumerName(ConsumerBase::mName);
106 mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_COMPOSER);
107 mConsumer->setDefaultBufferSize(sinkWidth, sinkHeight);
108 sink->setAsyncMode(true);
109 IGraphicBufferProducer::QueueBufferOutput output;
110 mSource[SOURCE_SCRATCH]->connect(NULL, NATIVE_WINDOW_API_EGL, false, &output);
111 }
112
~VirtualDisplaySurface()113 VirtualDisplaySurface::~VirtualDisplaySurface() {
114 mSource[SOURCE_SCRATCH]->disconnect(NATIVE_WINDOW_API_EGL);
115 }
116
beginFrame(bool mustRecompose)117 status_t VirtualDisplaySurface::beginFrame(bool mustRecompose) {
118 if (mDisplayId < 0)
119 return NO_ERROR;
120
121 mMustRecompose = mustRecompose;
122
123 VDS_LOGW_IF(mDbgState != DBG_STATE_IDLE,
124 "Unexpected beginFrame() in %s state", dbgStateStr());
125 mDbgState = DBG_STATE_BEGUN;
126
127 return refreshOutputBuffer();
128 }
129
prepareFrame(CompositionType compositionType)130 status_t VirtualDisplaySurface::prepareFrame(CompositionType compositionType) {
131 if (mDisplayId < 0)
132 return NO_ERROR;
133
134 VDS_LOGW_IF(mDbgState != DBG_STATE_BEGUN,
135 "Unexpected prepareFrame() in %s state", dbgStateStr());
136 mDbgState = DBG_STATE_PREPARED;
137
138 mCompositionType = compositionType;
139 if (sForceHwcCopy && mCompositionType == COMPOSITION_GLES) {
140 // Some hardware can do RGB->YUV conversion more efficiently in hardware
141 // controlled by HWC than in hardware controlled by the video encoder.
142 // Forcing GLES-composed frames to go through an extra copy by the HWC
143 // allows the format conversion to happen there, rather than passing RGB
144 // directly to the consumer.
145 //
146 // On the other hand, when the consumer prefers RGB or can consume RGB
147 // inexpensively, this forces an unnecessary copy.
148 mCompositionType = COMPOSITION_MIXED;
149 }
150
151 if (mCompositionType != mDbgLastCompositionType) {
152 VDS_LOGV("prepareFrame: composition type changed to %s",
153 dbgCompositionTypeStr(mCompositionType));
154 mDbgLastCompositionType = mCompositionType;
155 }
156
157 if (mCompositionType != COMPOSITION_GLES &&
158 (mOutputFormat != mDefaultOutputFormat ||
159 mOutputUsage != GRALLOC_USAGE_HW_COMPOSER)) {
160 // We must have just switched from GLES-only to MIXED or HWC
161 // composition. Stop using the format and usage requested by the GLES
162 // driver; they may be suboptimal when HWC is writing to the output
163 // buffer. For example, if the output is going to a video encoder, and
164 // HWC can write directly to YUV, some hardware can skip a
165 // memory-to-memory RGB-to-YUV conversion step.
166 //
167 // If we just switched *to* GLES-only mode, we'll change the
168 // format/usage and get a new buffer when the GLES driver calls
169 // dequeueBuffer().
170 mOutputFormat = mDefaultOutputFormat;
171 mOutputUsage = GRALLOC_USAGE_HW_COMPOSER;
172 refreshOutputBuffer();
173 }
174
175 return NO_ERROR;
176 }
177
178 #ifndef USE_HWC2
compositionComplete()179 status_t VirtualDisplaySurface::compositionComplete() {
180 return NO_ERROR;
181 }
182 #endif
183
advanceFrame()184 status_t VirtualDisplaySurface::advanceFrame() {
185 if (mDisplayId < 0)
186 return NO_ERROR;
187
188 if (mCompositionType == COMPOSITION_HWC) {
189 VDS_LOGW_IF(mDbgState != DBG_STATE_PREPARED,
190 "Unexpected advanceFrame() in %s state on HWC frame",
191 dbgStateStr());
192 } else {
193 VDS_LOGW_IF(mDbgState != DBG_STATE_GLES_DONE,
194 "Unexpected advanceFrame() in %s state on GLES/MIXED frame",
195 dbgStateStr());
196 }
197 mDbgState = DBG_STATE_HWC;
198
199 if (mOutputProducerSlot < 0 ||
200 (mCompositionType != COMPOSITION_HWC && mFbProducerSlot < 0)) {
201 // Last chance bailout if something bad happened earlier. For example,
202 // in a GLES configuration, if the sink disappears then dequeueBuffer
203 // will fail, the GLES driver won't queue a buffer, but SurfaceFlinger
204 // will soldier on. So we end up here without a buffer. There should
205 // be lots of scary messages in the log just before this.
206 VDS_LOGE("advanceFrame: no buffer, bailing out");
207 return NO_MEMORY;
208 }
209
210 sp<GraphicBuffer> fbBuffer = mFbProducerSlot >= 0 ?
211 mProducerBuffers[mFbProducerSlot] : sp<GraphicBuffer>(NULL);
212 sp<GraphicBuffer> outBuffer = mProducerBuffers[mOutputProducerSlot];
213 VDS_LOGV("advanceFrame: fb=%d(%p) out=%d(%p)",
214 mFbProducerSlot, fbBuffer.get(),
215 mOutputProducerSlot, outBuffer.get());
216
217 // At this point we know the output buffer acquire fence,
218 // so update HWC state with it.
219 mHwc.setOutputBuffer(mDisplayId, mOutputFence, outBuffer);
220
221 status_t result = NO_ERROR;
222 if (fbBuffer != NULL) {
223 #ifdef USE_HWC2
224 // TODO: Correctly propagate the dataspace from GL composition
225 result = mHwc.setClientTarget(mDisplayId, mFbFence, fbBuffer,
226 HAL_DATASPACE_UNKNOWN);
227 #else
228 result = mHwc.fbPost(mDisplayId, mFbFence, fbBuffer);
229 #endif
230 }
231
232 return result;
233 }
234
onFrameCommitted()235 void VirtualDisplaySurface::onFrameCommitted() {
236 if (mDisplayId < 0)
237 return;
238
239 VDS_LOGW_IF(mDbgState != DBG_STATE_HWC,
240 "Unexpected onFrameCommitted() in %s state", dbgStateStr());
241 mDbgState = DBG_STATE_IDLE;
242
243 #ifdef USE_HWC2
244 sp<Fence> retireFence = mHwc.getRetireFence(mDisplayId);
245 #else
246 sp<Fence> fbFence = mHwc.getAndResetReleaseFence(mDisplayId);
247 #endif
248 if (mCompositionType == COMPOSITION_MIXED && mFbProducerSlot >= 0) {
249 // release the scratch buffer back to the pool
250 Mutex::Autolock lock(mMutex);
251 int sslot = mapProducer2SourceSlot(SOURCE_SCRATCH, mFbProducerSlot);
252 VDS_LOGV("onFrameCommitted: release scratch sslot=%d", sslot);
253 #ifdef USE_HWC2
254 addReleaseFenceLocked(sslot, mProducerBuffers[mFbProducerSlot],
255 retireFence);
256 #else
257 addReleaseFenceLocked(sslot, mProducerBuffers[mFbProducerSlot], fbFence);
258 #endif
259 releaseBufferLocked(sslot, mProducerBuffers[mFbProducerSlot],
260 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
261 }
262
263 if (mOutputProducerSlot >= 0) {
264 int sslot = mapProducer2SourceSlot(SOURCE_SINK, mOutputProducerSlot);
265 QueueBufferOutput qbo;
266 #ifndef USE_HWC2
267 sp<Fence> outFence = mHwc.getLastRetireFence(mDisplayId);
268 #endif
269 VDS_LOGV("onFrameCommitted: queue sink sslot=%d", sslot);
270 if (mMustRecompose) {
271 status_t result = mSource[SOURCE_SINK]->queueBuffer(sslot,
272 QueueBufferInput(
273 systemTime(), false /* isAutoTimestamp */,
274 HAL_DATASPACE_UNKNOWN,
275 Rect(mSinkBufferWidth, mSinkBufferHeight),
276 NATIVE_WINDOW_SCALING_MODE_FREEZE, 0 /* transform */,
277 #ifdef USE_HWC2
278 retireFence),
279 #else
280 outFence),
281 #endif
282 &qbo);
283 if (result == NO_ERROR) {
284 updateQueueBufferOutput(qbo);
285 }
286 } else {
287 // If the surface hadn't actually been updated, then we only went
288 // through the motions of updating the display to keep our state
289 // machine happy. We cancel the buffer to avoid triggering another
290 // re-composition and causing an infinite loop.
291 #ifdef USE_HWC2
292 mSource[SOURCE_SINK]->cancelBuffer(sslot, retireFence);
293 #else
294 mSource[SOURCE_SINK]->cancelBuffer(sslot, outFence);
295 #endif
296 }
297 }
298
299 resetPerFrameState();
300 }
301
dumpAsString(String8 &) const302 void VirtualDisplaySurface::dumpAsString(String8& /* result */) const {
303 }
304
resizeBuffers(const uint32_t w,const uint32_t h)305 void VirtualDisplaySurface::resizeBuffers(const uint32_t w, const uint32_t h) {
306 uint32_t tmpW, tmpH, transformHint, numPendingBuffers;
307 uint64_t nextFrameNumber;
308 mQueueBufferOutput.deflate(&tmpW, &tmpH, &transformHint, &numPendingBuffers,
309 &nextFrameNumber);
310 mQueueBufferOutput.inflate(w, h, transformHint, numPendingBuffers,
311 nextFrameNumber);
312
313 mSinkBufferWidth = w;
314 mSinkBufferHeight = h;
315 }
316
getClientTargetAcquireFence() const317 const sp<Fence>& VirtualDisplaySurface::getClientTargetAcquireFence() const {
318 return mFbFence;
319 }
320
requestBuffer(int pslot,sp<GraphicBuffer> * outBuf)321 status_t VirtualDisplaySurface::requestBuffer(int pslot,
322 sp<GraphicBuffer>* outBuf) {
323 if (mDisplayId < 0)
324 return mSource[SOURCE_SINK]->requestBuffer(pslot, outBuf);
325
326 VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
327 "Unexpected requestBuffer pslot=%d in %s state",
328 pslot, dbgStateStr());
329
330 *outBuf = mProducerBuffers[pslot];
331 return NO_ERROR;
332 }
333
setMaxDequeuedBufferCount(int maxDequeuedBuffers)334 status_t VirtualDisplaySurface::setMaxDequeuedBufferCount(
335 int maxDequeuedBuffers) {
336 return mSource[SOURCE_SINK]->setMaxDequeuedBufferCount(maxDequeuedBuffers);
337 }
338
setAsyncMode(bool async)339 status_t VirtualDisplaySurface::setAsyncMode(bool async) {
340 return mSource[SOURCE_SINK]->setAsyncMode(async);
341 }
342
dequeueBuffer(Source source,PixelFormat format,uint32_t usage,int * sslot,sp<Fence> * fence)343 status_t VirtualDisplaySurface::dequeueBuffer(Source source,
344 PixelFormat format, uint32_t usage, int* sslot, sp<Fence>* fence) {
345 LOG_FATAL_IF(mDisplayId < 0, "mDisplayId=%d but should not be < 0.", mDisplayId);
346
347 status_t result = mSource[source]->dequeueBuffer(sslot, fence,
348 mSinkBufferWidth, mSinkBufferHeight, format, usage);
349 if (result < 0)
350 return result;
351 int pslot = mapSource2ProducerSlot(source, *sslot);
352 VDS_LOGV("dequeueBuffer(%s): sslot=%d pslot=%d result=%d",
353 dbgSourceStr(source), *sslot, pslot, result);
354 uint64_t sourceBit = static_cast<uint64_t>(source) << pslot;
355
356 if ((mProducerSlotSource & (1ULL << pslot)) != sourceBit) {
357 // This slot was previously dequeued from the other source; must
358 // re-request the buffer.
359 result |= BUFFER_NEEDS_REALLOCATION;
360 mProducerSlotSource &= ~(1ULL << pslot);
361 mProducerSlotSource |= sourceBit;
362 }
363
364 if (result & RELEASE_ALL_BUFFERS) {
365 for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
366 if ((mProducerSlotSource & (1ULL << i)) == sourceBit)
367 mProducerBuffers[i].clear();
368 }
369 }
370 if (result & BUFFER_NEEDS_REALLOCATION) {
371 result = mSource[source]->requestBuffer(*sslot, &mProducerBuffers[pslot]);
372 if (result < 0) {
373 mProducerBuffers[pslot].clear();
374 mSource[source]->cancelBuffer(*sslot, *fence);
375 return result;
376 }
377 VDS_LOGV("dequeueBuffer(%s): buffers[%d]=%p fmt=%d usage=%#x",
378 dbgSourceStr(source), pslot, mProducerBuffers[pslot].get(),
379 mProducerBuffers[pslot]->getPixelFormat(),
380 mProducerBuffers[pslot]->getUsage());
381 }
382
383 return result;
384 }
385
dequeueBuffer(int * pslot,sp<Fence> * fence,uint32_t w,uint32_t h,PixelFormat format,uint32_t usage)386 status_t VirtualDisplaySurface::dequeueBuffer(int* pslot, sp<Fence>* fence,
387 uint32_t w, uint32_t h, PixelFormat format, uint32_t usage) {
388 if (mDisplayId < 0)
389 return mSource[SOURCE_SINK]->dequeueBuffer(pslot, fence, w, h, format, usage);
390
391 VDS_LOGW_IF(mDbgState != DBG_STATE_PREPARED,
392 "Unexpected dequeueBuffer() in %s state", dbgStateStr());
393 mDbgState = DBG_STATE_GLES;
394
395 VDS_LOGV("dequeueBuffer %dx%d fmt=%d usage=%#x", w, h, format, usage);
396
397 status_t result = NO_ERROR;
398 Source source = fbSourceForCompositionType(mCompositionType);
399
400 if (source == SOURCE_SINK) {
401
402 if (mOutputProducerSlot < 0) {
403 // Last chance bailout if something bad happened earlier. For example,
404 // in a GLES configuration, if the sink disappears then dequeueBuffer
405 // will fail, the GLES driver won't queue a buffer, but SurfaceFlinger
406 // will soldier on. So we end up here without a buffer. There should
407 // be lots of scary messages in the log just before this.
408 VDS_LOGE("dequeueBuffer: no buffer, bailing out");
409 return NO_MEMORY;
410 }
411
412 // We already dequeued the output buffer. If the GLES driver wants
413 // something incompatible, we have to cancel and get a new one. This
414 // will mean that HWC will see a different output buffer between
415 // prepare and set, but since we're in GLES-only mode already it
416 // shouldn't matter.
417
418 usage |= GRALLOC_USAGE_HW_COMPOSER;
419 const sp<GraphicBuffer>& buf = mProducerBuffers[mOutputProducerSlot];
420 if ((usage & ~buf->getUsage()) != 0 ||
421 (format != 0 && format != buf->getPixelFormat()) ||
422 (w != 0 && w != mSinkBufferWidth) ||
423 (h != 0 && h != mSinkBufferHeight)) {
424 VDS_LOGV("dequeueBuffer: dequeueing new output buffer: "
425 "want %dx%d fmt=%d use=%#x, "
426 "have %dx%d fmt=%d use=%#x",
427 w, h, format, usage,
428 mSinkBufferWidth, mSinkBufferHeight,
429 buf->getPixelFormat(), buf->getUsage());
430 mOutputFormat = format;
431 mOutputUsage = usage;
432 result = refreshOutputBuffer();
433 if (result < 0)
434 return result;
435 }
436 }
437
438 if (source == SOURCE_SINK) {
439 *pslot = mOutputProducerSlot;
440 *fence = mOutputFence;
441 } else {
442 int sslot;
443 result = dequeueBuffer(source, format, usage, &sslot, fence);
444 if (result >= 0) {
445 *pslot = mapSource2ProducerSlot(source, sslot);
446 }
447 }
448 return result;
449 }
450
detachBuffer(int)451 status_t VirtualDisplaySurface::detachBuffer(int /* slot */) {
452 VDS_LOGE("detachBuffer is not available for VirtualDisplaySurface");
453 return INVALID_OPERATION;
454 }
455
detachNextBuffer(sp<GraphicBuffer> *,sp<Fence> *)456 status_t VirtualDisplaySurface::detachNextBuffer(
457 sp<GraphicBuffer>* /* outBuffer */, sp<Fence>* /* outFence */) {
458 VDS_LOGE("detachNextBuffer is not available for VirtualDisplaySurface");
459 return INVALID_OPERATION;
460 }
461
attachBuffer(int *,const sp<GraphicBuffer> &)462 status_t VirtualDisplaySurface::attachBuffer(int* /* outSlot */,
463 const sp<GraphicBuffer>& /* buffer */) {
464 VDS_LOGE("attachBuffer is not available for VirtualDisplaySurface");
465 return INVALID_OPERATION;
466 }
467
queueBuffer(int pslot,const QueueBufferInput & input,QueueBufferOutput * output)468 status_t VirtualDisplaySurface::queueBuffer(int pslot,
469 const QueueBufferInput& input, QueueBufferOutput* output) {
470 if (mDisplayId < 0)
471 return mSource[SOURCE_SINK]->queueBuffer(pslot, input, output);
472
473 VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
474 "Unexpected queueBuffer(pslot=%d) in %s state", pslot,
475 dbgStateStr());
476 mDbgState = DBG_STATE_GLES_DONE;
477
478 VDS_LOGV("queueBuffer pslot=%d", pslot);
479
480 status_t result;
481 if (mCompositionType == COMPOSITION_MIXED) {
482 // Queue the buffer back into the scratch pool
483 QueueBufferOutput scratchQBO;
484 int sslot = mapProducer2SourceSlot(SOURCE_SCRATCH, pslot);
485 result = mSource[SOURCE_SCRATCH]->queueBuffer(sslot, input, &scratchQBO);
486 if (result != NO_ERROR)
487 return result;
488
489 // Now acquire the buffer from the scratch pool -- should be the same
490 // slot and fence as we just queued.
491 Mutex::Autolock lock(mMutex);
492 BufferItem item;
493 result = acquireBufferLocked(&item, 0);
494 if (result != NO_ERROR)
495 return result;
496 VDS_LOGW_IF(item.mSlot != sslot,
497 "queueBuffer: acquired sslot %d from SCRATCH after queueing sslot %d",
498 item.mSlot, sslot);
499 mFbProducerSlot = mapSource2ProducerSlot(SOURCE_SCRATCH, item.mSlot);
500 mFbFence = mSlots[item.mSlot].mFence;
501
502 } else {
503 LOG_FATAL_IF(mCompositionType != COMPOSITION_GLES,
504 "Unexpected queueBuffer in state %s for compositionType %s",
505 dbgStateStr(), dbgCompositionTypeStr(mCompositionType));
506
507 // Extract the GLES release fence for HWC to acquire
508 int64_t timestamp;
509 bool isAutoTimestamp;
510 android_dataspace dataSpace;
511 Rect crop;
512 int scalingMode;
513 uint32_t transform;
514 input.deflate(×tamp, &isAutoTimestamp, &dataSpace, &crop,
515 &scalingMode, &transform, &mFbFence);
516
517 mFbProducerSlot = pslot;
518 mOutputFence = mFbFence;
519 }
520
521 *output = mQueueBufferOutput;
522 return NO_ERROR;
523 }
524
cancelBuffer(int pslot,const sp<Fence> & fence)525 status_t VirtualDisplaySurface::cancelBuffer(int pslot,
526 const sp<Fence>& fence) {
527 if (mDisplayId < 0)
528 return mSource[SOURCE_SINK]->cancelBuffer(mapProducer2SourceSlot(SOURCE_SINK, pslot), fence);
529
530 VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
531 "Unexpected cancelBuffer(pslot=%d) in %s state", pslot,
532 dbgStateStr());
533 VDS_LOGV("cancelBuffer pslot=%d", pslot);
534 Source source = fbSourceForCompositionType(mCompositionType);
535 return mSource[source]->cancelBuffer(
536 mapProducer2SourceSlot(source, pslot), fence);
537 }
538
query(int what,int * value)539 int VirtualDisplaySurface::query(int what, int* value) {
540 switch (what) {
541 case NATIVE_WINDOW_WIDTH:
542 *value = mSinkBufferWidth;
543 break;
544 case NATIVE_WINDOW_HEIGHT:
545 *value = mSinkBufferHeight;
546 break;
547 default:
548 return mSource[SOURCE_SINK]->query(what, value);
549 }
550 return NO_ERROR;
551 }
552
connect(const sp<IProducerListener> & listener,int api,bool producerControlledByApp,QueueBufferOutput * output)553 status_t VirtualDisplaySurface::connect(const sp<IProducerListener>& listener,
554 int api, bool producerControlledByApp,
555 QueueBufferOutput* output) {
556 QueueBufferOutput qbo;
557 status_t result = mSource[SOURCE_SINK]->connect(listener, api,
558 producerControlledByApp, &qbo);
559 if (result == NO_ERROR) {
560 updateQueueBufferOutput(qbo);
561 *output = mQueueBufferOutput;
562 }
563 return result;
564 }
565
disconnect(int api)566 status_t VirtualDisplaySurface::disconnect(int api) {
567 return mSource[SOURCE_SINK]->disconnect(api);
568 }
569
setSidebandStream(const sp<NativeHandle> &)570 status_t VirtualDisplaySurface::setSidebandStream(const sp<NativeHandle>& /*stream*/) {
571 return INVALID_OPERATION;
572 }
573
allocateBuffers(uint32_t,uint32_t,PixelFormat,uint32_t)574 void VirtualDisplaySurface::allocateBuffers(uint32_t /* width */,
575 uint32_t /* height */, PixelFormat /* format */, uint32_t /* usage */) {
576 // TODO: Should we actually allocate buffers for a virtual display?
577 }
578
allowAllocation(bool)579 status_t VirtualDisplaySurface::allowAllocation(bool /* allow */) {
580 return INVALID_OPERATION;
581 }
582
setGenerationNumber(uint32_t)583 status_t VirtualDisplaySurface::setGenerationNumber(uint32_t /* generation */) {
584 ALOGE("setGenerationNumber not supported on VirtualDisplaySurface");
585 return INVALID_OPERATION;
586 }
587
getConsumerName() const588 String8 VirtualDisplaySurface::getConsumerName() const {
589 return String8("VirtualDisplaySurface");
590 }
591
setSharedBufferMode(bool)592 status_t VirtualDisplaySurface::setSharedBufferMode(bool /*sharedBufferMode*/) {
593 ALOGE("setSharedBufferMode not supported on VirtualDisplaySurface");
594 return INVALID_OPERATION;
595 }
596
setAutoRefresh(bool)597 status_t VirtualDisplaySurface::setAutoRefresh(bool /*autoRefresh*/) {
598 ALOGE("setAutoRefresh not supported on VirtualDisplaySurface");
599 return INVALID_OPERATION;
600 }
601
setDequeueTimeout(nsecs_t)602 status_t VirtualDisplaySurface::setDequeueTimeout(nsecs_t /* timeout */) {
603 ALOGE("setDequeueTimeout not supported on VirtualDisplaySurface");
604 return INVALID_OPERATION;
605 }
606
getLastQueuedBuffer(sp<GraphicBuffer> *,sp<Fence> *,float[16])607 status_t VirtualDisplaySurface::getLastQueuedBuffer(
608 sp<GraphicBuffer>* /*outBuffer*/, sp<Fence>* /*outFence*/,
609 float[16] /* outTransformMatrix*/) {
610 ALOGE("getLastQueuedBuffer not supported on VirtualDisplaySurface");
611 return INVALID_OPERATION;
612 }
613
getUniqueId(uint64_t *) const614 status_t VirtualDisplaySurface::getUniqueId(uint64_t* /*outId*/) const {
615 ALOGE("getUniqueId not supported on VirtualDisplaySurface");
616 return INVALID_OPERATION;
617 }
618
updateQueueBufferOutput(const QueueBufferOutput & qbo)619 void VirtualDisplaySurface::updateQueueBufferOutput(
620 const QueueBufferOutput& qbo) {
621 uint32_t w, h, transformHint, numPendingBuffers;
622 uint64_t nextFrameNumber;
623 qbo.deflate(&w, &h, &transformHint, &numPendingBuffers, &nextFrameNumber);
624 mQueueBufferOutput.inflate(w, h, 0, numPendingBuffers, nextFrameNumber);
625 }
626
resetPerFrameState()627 void VirtualDisplaySurface::resetPerFrameState() {
628 mCompositionType = COMPOSITION_UNKNOWN;
629 mFbFence = Fence::NO_FENCE;
630 mOutputFence = Fence::NO_FENCE;
631 mOutputProducerSlot = -1;
632 mFbProducerSlot = -1;
633 }
634
refreshOutputBuffer()635 status_t VirtualDisplaySurface::refreshOutputBuffer() {
636 if (mOutputProducerSlot >= 0) {
637 mSource[SOURCE_SINK]->cancelBuffer(
638 mapProducer2SourceSlot(SOURCE_SINK, mOutputProducerSlot),
639 mOutputFence);
640 }
641
642 int sslot;
643 status_t result = dequeueBuffer(SOURCE_SINK, mOutputFormat, mOutputUsage,
644 &sslot, &mOutputFence);
645 if (result < 0)
646 return result;
647 mOutputProducerSlot = mapSource2ProducerSlot(SOURCE_SINK, sslot);
648
649 // On GLES-only frames, we don't have the right output buffer acquire fence
650 // until after GLES calls queueBuffer(). So here we just set the buffer
651 // (for use in HWC prepare) but not the fence; we'll call this again with
652 // the proper fence once we have it.
653 result = mHwc.setOutputBuffer(mDisplayId, Fence::NO_FENCE,
654 mProducerBuffers[mOutputProducerSlot]);
655
656 return result;
657 }
658
659 // This slot mapping function is its own inverse, so two copies are unnecessary.
660 // Both are kept to make the intent clear where the function is called, and for
661 // the (unlikely) chance that we switch to a different mapping function.
mapSource2ProducerSlot(Source source,int sslot)662 int VirtualDisplaySurface::mapSource2ProducerSlot(Source source, int sslot) {
663 if (source == SOURCE_SCRATCH) {
664 return BufferQueue::NUM_BUFFER_SLOTS - sslot - 1;
665 } else {
666 return sslot;
667 }
668 }
mapProducer2SourceSlot(Source source,int pslot)669 int VirtualDisplaySurface::mapProducer2SourceSlot(Source source, int pslot) {
670 return mapSource2ProducerSlot(source, pslot);
671 }
672
673 VirtualDisplaySurface::Source
fbSourceForCompositionType(CompositionType type)674 VirtualDisplaySurface::fbSourceForCompositionType(CompositionType type) {
675 return type == COMPOSITION_MIXED ? SOURCE_SCRATCH : SOURCE_SINK;
676 }
677
dbgStateStr() const678 const char* VirtualDisplaySurface::dbgStateStr() const {
679 switch (mDbgState) {
680 case DBG_STATE_IDLE: return "IDLE";
681 case DBG_STATE_PREPARED: return "PREPARED";
682 case DBG_STATE_GLES: return "GLES";
683 case DBG_STATE_GLES_DONE: return "GLES_DONE";
684 case DBG_STATE_HWC: return "HWC";
685 default: return "INVALID";
686 }
687 }
688
dbgSourceStr(Source s)689 const char* VirtualDisplaySurface::dbgSourceStr(Source s) {
690 switch (s) {
691 case SOURCE_SINK: return "SINK";
692 case SOURCE_SCRATCH: return "SCRATCH";
693 default: return "INVALID";
694 }
695 }
696
697 // ---------------------------------------------------------------------------
698 } // namespace android
699 // ---------------------------------------------------------------------------
700