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
|
/*
* Copyright (C) 2012 The Android Open Source Project
* Copyright (C) 2014 Mozilla Foundation
*
* 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 NATIVEWINDOW_GONKNATIVEWINDOW_LL_H
#define NATIVEWINDOW_GONKNATIVEWINDOW_LL_H
#include <ui/GraphicBuffer.h>
#include <utils/String8.h>
#include <utils/Vector.h>
#include <utils/threads.h>
#include "GonkConsumerBaseLL.h"
#include "IGonkGraphicBufferConsumerLL.h"
namespace android {
// The user of GonkNativeWindow who wants to receive notification of
// new frames should implement this interface.
class GonkNativeWindowNewFrameCallback {
public:
virtual void OnNewFrame() = 0;
};
/**
* GonkNativeWindow is a GonkBufferQueue consumer endpoint that allows clients
* access to the whole BufferItem entry from GonkBufferQueue. Multiple buffers may
* be acquired at once, to be used concurrently by the client. This consumer can
* operate either in synchronous or asynchronous mode.
*/
class GonkNativeWindow: public GonkConsumerBase
{
typedef mozilla::layers::TextureClient TextureClient;
public:
typedef GonkConsumerBase::FrameAvailableListener FrameAvailableListener;
typedef GonkBufferQueue::BufferItem BufferItem;
enum { DEFAULT_MAX_BUFFERS = -1 };
enum { INVALID_BUFFER_SLOT = GonkBufferQueue::INVALID_BUFFER_SLOT };
enum { NO_BUFFER_AVAILABLE = GonkBufferQueue::NO_BUFFER_AVAILABLE };
// Create a new buffer item consumer. The consumerUsage parameter determines
// the consumer usage flags passed to the graphics allocator. The
// bufferCount parameter specifies how many buffers can be locked for user
// access at the same time.
// controlledByApp tells whether this consumer is controlled by the
// application.
GonkNativeWindow(const sp<IGonkGraphicBufferConsumer>& consumer,
int bufferCount = DEFAULT_MAX_BUFFERS);
GonkNativeWindow(const sp<IGonkGraphicBufferConsumer>& consumer,
uint32_t consumerUsage, int bufferCount = DEFAULT_MAX_BUFFERS,
bool controlledByApp = false);
virtual ~GonkNativeWindow();
// set the name of the GonkNativeWindow that will be used to identify it in
// log messages.
void setName(const String8& name);
// Gets the next graphics buffer from the producer, filling out the
// passed-in BufferItem structure. Returns NO_BUFFER_AVAILABLE if the queue
// of buffers is empty, and INVALID_OPERATION if the maximum number of
// buffers is already acquired.
//
// Only a fixed number of buffers can be acquired at a time, determined by
// the construction-time bufferCount parameter. If INVALID_OPERATION is
// returned by acquireBuffer, then old buffers must be returned to the
// queue by calling releaseBuffer before more buffers can be acquired.
//
// If waitForFence is true, and the acquired BufferItem has a valid fence object,
// acquireBuffer will wait on the fence with no timeout before returning.
status_t acquireBuffer(BufferItem *item, nsecs_t presentWhen,
bool waitForFence = true);
// Returns an acquired buffer to the queue, allowing it to be reused. Since
// only a fixed number of buffers may be acquired at a time, old buffers
// must be released by calling releaseBuffer to ensure new buffers can be
// acquired by acquireBuffer. Once a BufferItem is released, the caller must
// not access any members of the BufferItem, and should immediately remove
// all of its references to the BufferItem itself.
status_t releaseBuffer(const BufferItem &item,
const sp<Fence>& releaseFence = Fence::NO_FENCE);
// setDefaultBufferSize is used to set the size of buffers returned by
// requestBuffers when a with and height of zero is requested.
status_t setDefaultBufferSize(uint32_t w, uint32_t h);
// setDefaultBufferFormat allows the GonkBufferQueue to create
// GraphicBuffers of a defaultFormat if no format is specified
// in dequeueBuffer
status_t setDefaultBufferFormat(uint32_t defaultFormat);
// Get next frame from the queue, caller owns the returned buffer.
already_AddRefed<TextureClient> getCurrentBuffer();
// Return the buffer to the queue and mark it as FREE. After that
// the buffer is useable again for the decoder.
void returnBuffer(TextureClient* client);
already_AddRefed<TextureClient> getTextureClientFromBuffer(ANativeWindowBuffer* buffer);
void setNewFrameCallback(GonkNativeWindowNewFrameCallback* callback);
static void RecycleCallback(TextureClient* client, void* closure);
protected:
#if ANDROID_VERSION == 21
virtual void onFrameAvailable();
#else
virtual void onFrameAvailable(const ::android::BufferItem &item);
#endif
private:
GonkNativeWindowNewFrameCallback* mNewFrameCallback;
};
} // namespace android
#endif // NATIVEWINDOW_GONKNATIVEWINDOW_LL_H
|
