← Back to branch summary

~xnox/ubuntu/trusty/gcc-arm-linux-androideabi/dima

« back to all changes in this revision

Viewing changes to android/frameworks/native/include/gui/SurfaceTextureClient.h

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs
  • Date: 2013-07-05 10:12:24 UTC
  • Revision ID: package-import@ubuntu.com-20130705101224-6qo3e8jbz8p31aa1
Tags: upstream-0.20130705.1
Import upstream version 0.20130705.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
android/frameworks/native/include/gui/SurfaceTextureClient.h
 
1
/*
 
2
 * Copyright (C) 2010 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
#ifndef ANDROID_GUI_SURFACETEXTURECLIENT_H
 
18
#define ANDROID_GUI_SURFACETEXTURECLIENT_H
 
19
 
 
20
#include <gui/ISurfaceTexture.h>
 
21
#include <gui/SurfaceTexture.h>
 
22
#include <gui/BufferQueue.h>
 
23
 
 
24
#include <ui/ANativeObjectBase.h>
 
25
#include <ui/Region.h>
 
26
 
 
27
#include <utils/RefBase.h>
 
28
#include <utils/threads.h>
 
29
#include <utils/KeyedVector.h>
 
30
 
 
31
struct ANativeWindow_Buffer;
 
32
 
 
33
namespace android {
 
34
 
 
35
class Surface;
 
36
 
 
37
class SurfaceTextureClient
 
38
    : public ANativeObjectBase<ANativeWindow, SurfaceTextureClient, RefBase>
 
39
{
 
40
public:
 
41
 
 
42
    SurfaceTextureClient(const sp<ISurfaceTexture>& surfaceTexture);
 
43
 
 
44
    // SurfaceTextureClient is overloaded to assist in refactoring ST and BQ.
 
45
    // SurfaceTexture is no longer an ISurfaceTexture, so client code
 
46
    // calling the original constructor will fail. Thus this convenience method
 
47
    // passes in the surfaceTexture's bufferQueue to the init method.
 
48
    SurfaceTextureClient(const sp<SurfaceTexture>& surfaceTexture);
 
49
 
 
50
    sp<ISurfaceTexture> getISurfaceTexture() const;
 
51
 
 
52
protected:
 
53
    SurfaceTextureClient();
 
54
    virtual ~SurfaceTextureClient();
 
55
    void setISurfaceTexture(const sp<ISurfaceTexture>& surfaceTexture);
 
56
 
 
57
private:
 
58
    // can't be copied
 
59
    SurfaceTextureClient& operator = (const SurfaceTextureClient& rhs);
 
60
    SurfaceTextureClient(const SurfaceTextureClient& rhs);
 
61
    void init();
 
62
 
 
63
    // ANativeWindow hooks
 
64
    static int hook_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer);
 
65
    static int hook_dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer);
 
66
    static int hook_lockBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer);
 
67
    static int hook_perform(ANativeWindow* window, int operation, ...);
 
68
    static int hook_query(const ANativeWindow* window, int what, int* value);
 
69
    static int hook_queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer);
 
70
    static int hook_setSwapInterval(ANativeWindow* window, int interval);
 
71
 
 
72
    int dispatchConnect(va_list args);
 
73
    int dispatchDisconnect(va_list args);
 
74
    int dispatchSetBufferCount(va_list args);
 
75
    int dispatchSetBuffersGeometry(va_list args);
 
76
    int dispatchSetBuffersDimensions(va_list args);
 
77
    int dispatchSetBuffersUserDimensions(va_list args);
 
78
    int dispatchSetBuffersFormat(va_list args);
 
79
    int dispatchSetScalingMode(va_list args);
 
80
    int dispatchSetBuffersTransform(va_list args);
 
81
    int dispatchSetBuffersTimestamp(va_list args);
 
82
    int dispatchSetCrop(va_list args);
 
83
    int dispatchSetPostTransformCrop(va_list args);
 
84
    int dispatchSetUsage(va_list args);
 
85
    int dispatchLock(va_list args);
 
86
    int dispatchUnlockAndPost(va_list args);
 
87
 
 
88
protected:
 
89
    virtual int cancelBuffer(ANativeWindowBuffer* buffer);
 
90
    virtual int dequeueBuffer(ANativeWindowBuffer** buffer);
 
91
    virtual int lockBuffer(ANativeWindowBuffer* buffer);
 
92
    virtual int perform(int operation, va_list args);
 
93
    virtual int query(int what, int* value) const;
 
94
    virtual int queueBuffer(ANativeWindowBuffer* buffer);
 
95
    virtual int setSwapInterval(int interval);
 
96
 
 
97
    virtual int connect(int api);
 
98
    virtual int disconnect(int api);
 
99
    virtual int setBufferCount(int bufferCount);
 
100
    virtual int setBuffersDimensions(int w, int h);
 
101
    virtual int setBuffersUserDimensions(int w, int h);
 
102
    virtual int setBuffersFormat(int format);
 
103
    virtual int setScalingMode(int mode);
 
104
    virtual int setBuffersTransform(int transform);
 
105
    virtual int setBuffersTimestamp(int64_t timestamp);
 
106
    virtual int setCrop(Rect const* rect);
 
107
    virtual int setUsage(uint32_t reqUsage);
 
108
    virtual int lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds);
 
109
    virtual int unlockAndPost();
 
110
 
 
111
    enum { NUM_BUFFER_SLOTS = BufferQueue::NUM_BUFFER_SLOTS };
 
112
    enum { DEFAULT_FORMAT = PIXEL_FORMAT_RGBA_8888 };
 
113
 
 
114
private:
 
115
    void freeAllBuffers();
 
116
    int getSlotFromBufferLocked(android_native_buffer_t* buffer) const;
 
117
 
 
118
    struct BufferSlot {
 
119
        sp<GraphicBuffer> buffer;
 
120
        Region dirtyRegion;
 
121
    };
 
122
 
 
123
    // mSurfaceTexture is the interface to the surface texture server. All
 
124
    // operations on the surface texture client ultimately translate into
 
125
    // interactions with the server using this interface.
 
126
    sp<ISurfaceTexture> mSurfaceTexture;
 
127
 
 
128
    // mSlots stores the buffers that have been allocated for each buffer slot.
 
129
    // It is initialized to null pointers, and gets filled in with the result of
 
130
    // ISurfaceTexture::requestBuffer when the client dequeues a buffer from a
 
131
    // slot that has not yet been used. The buffer allocated to a slot will also
 
132
    // be replaced if the requested buffer usage or geometry differs from that
 
133
    // of the buffer allocated to a slot.
 
134
    BufferSlot mSlots[NUM_BUFFER_SLOTS];
 
135
 
 
136
    // mReqWidth is the buffer width that will be requested at the next dequeue
 
137
    // operation. It is initialized to 1.
 
138
    uint32_t mReqWidth;
 
139
 
 
140
    // mReqHeight is the buffer height that will be requested at the next
 
141
    // dequeue operation. It is initialized to 1.
 
142
    uint32_t mReqHeight;
 
143
 
 
144
    // mReqFormat is the buffer pixel format that will be requested at the next
 
145
    // deuque operation. It is initialized to PIXEL_FORMAT_RGBA_8888.
 
146
    uint32_t mReqFormat;
 
147
 
 
148
    // mReqUsage is the set of buffer usage flags that will be requested
 
149
    // at the next deuque operation. It is initialized to 0.
 
150
    uint32_t mReqUsage;
 
151
 
 
152
    // mTimestamp is the timestamp that will be used for the next buffer queue
 
153
    // operation. It defaults to NATIVE_WINDOW_TIMESTAMP_AUTO, which means that
 
154
    // a timestamp is auto-generated when queueBuffer is called.
 
155
    int64_t mTimestamp;
 
156
 
 
157
    // mCrop is the crop rectangle that will be used for the next buffer
 
158
    // that gets queued. It is set by calling setCrop.
 
159
    Rect mCrop;
 
160
 
 
161
    // mScalingMode is the scaling mode that will be used for the next
 
162
    // buffers that get queued. It is set by calling setScalingMode.
 
163
    int mScalingMode;
 
164
 
 
165
    // mTransform is the transform identifier that will be used for the next
 
166
    // buffer that gets queued. It is set by calling setTransform.
 
167
    uint32_t mTransform;
 
168
 
 
169
     // mDefaultWidth is default width of the buffers, regardless of the
 
170
     // native_window_set_buffers_dimensions call.
 
171
     uint32_t mDefaultWidth;
 
172
 
 
173
     // mDefaultHeight is default height of the buffers, regardless of the
 
174
     // native_window_set_buffers_dimensions call.
 
175
     uint32_t mDefaultHeight;
 
176
 
 
177
     // mUserWidth, if non-zero, is an application-specified override
 
178
     // of mDefaultWidth.  This is lower priority than the width set by
 
179
     // native_window_set_buffers_dimensions.
 
180
     uint32_t mUserWidth;
 
181
 
 
182
     // mUserHeight, if non-zero, is an application-specified override
 
183
     // of mDefaultHeight.  This is lower priority than the height set
 
184
     // by native_window_set_buffers_dimensions.
 
185
     uint32_t mUserHeight;
 
186
 
 
187
    // mTransformHint is the transform probably applied to buffers of this
 
188
    // window. this is only a hint, actual transform may differ.
 
189
    uint32_t mTransformHint;
 
190
 
 
191
    // mConsumerRunningBehind whether the consumer is running more than
 
192
    // one buffer behind the producer.
 
193
    mutable bool mConsumerRunningBehind;
 
194
 
 
195
    // mMutex is the mutex used to prevent concurrent access to the member
 
196
    // variables of SurfaceTexture objects. It must be locked whenever the
 
197
    // member variables are accessed.
 
198
    mutable Mutex mMutex;
 
199
 
 
200
    // must be used from the lock/unlock thread
 
201
    sp<GraphicBuffer>           mLockedBuffer;
 
202
    sp<GraphicBuffer>           mPostedBuffer;
 
203
    bool                        mConnectedToCpu;
 
204
 
 
205
    // must be accessed from lock/unlock thread only
 
206
    Region mDirtyRegion;
 
207
};
 
208
 
 
209
}; // namespace android
 
210
 
 
211
#endif  // ANDROID_GUI_SURFACETEXTURECLIENT_H