The Tor Browser: comparison widget/gonk/nativewindow/GonkNativeWindowICS.h

--1:000000000000
+:3a213eb30a0b
+/*
+* Copyright (C) 2010 The Android Open Source Project
+* Copyright (C) 2012 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_ICS_H
+#define NATIVEWINDOW_GONKNATIVEWINDOW_ICS_H
+#include <stdint.h>
+#include <sys/types.h>
+#include <gui/ISurfaceTexture.h>
+#include <ui/egl/android_natives.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/Rect.h>
+#include <utils/Errors.h>
+#include <utils/RefBase.h>
+#include <utils/String8.h>
+#include <utils/threads.h>
+#include "CameraCommon.h"
+#include "GrallocImages.h"
+#include "mozilla/layers/LayersSurfaces.h"
+#include "mozilla/layers/TextureClient.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;
+};
+class GonkNativeWindow : public BnSurfaceTexture
+{
+friend class GonkNativeWindowClient;
+typedef mozilla::layers::TextureClient TextureClient;
+public:
+enum { MIN_UNDEQUEUED_BUFFERS = 2 };
+enum { MIN_BUFFER_SLOTS = MIN_UNDEQUEUED_BUFFERS };
+enum { NUM_BUFFER_SLOTS = 32 };
+enum { NO_CONNECTED_API = 0 };
+enum { NATIVE_WINDOW_SET_BUFFERS_SIZE = 0x10000000 };
+GonkNativeWindow();
+~GonkNativeWindow(); // this class cannot be overloaded
+// Get next frame from the queue and mark it as RENDERING, caller
+// owns the returned buffer.
+mozilla::TemporaryRef<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);
+// setBufferCount updates the number of available buffer slots.  After
+// calling this all buffer slots are owned by the GonkNativeWindow object
+// (i.e. they are not owned by the client).
+virtual status_t setBufferCount(int bufferCount);
+// requestBuffer requests a new buffer for the given index.
+virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* buf);
+// dequeueBuffer gets the next buffer slot index for the client to use. If a
+// buffer slot is available then that slot index is written to the location
+// pointed to by the buf argument and a status of OK is returned.  If no
+// slot is available then a status of -EBUSY is returned and buf is
+// unmodified.
+virtual status_t dequeueBuffer(int *buf, uint32_t width, uint32_t height,
+uint32_t format, uint32_t usage);
+// queueBuffer returns a filled buffer to the GonkNativeWindow. In addition,
+// a timestamp must be provided for the buffer. The timestamp is in
+// nanoseconds, and must be monotonically increasing. Its other semantics
+// (zero point, etc) are client-dependent and should be documented by the
+// client.
+virtual status_t queueBuffer(int buf, int64_t timestamp,
+uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform);
+virtual void cancelBuffer(int buf);
+virtual status_t setCrop(const Rect& reg);
+virtual status_t setTransform(uint32_t transform);
+virtual status_t setScalingMode(int mode);
+virtual int query(int what, int* value);
+// Qcom specific function
+virtual int performQcomOperation(int operation, int arg1, int arg2, int arg3) {
+return OK;
+}
+// GonkNativeWindow do not implement the function and always works in
+// synchronous mode.
+virtual status_t setSynchronousMode(bool enabled);
+// connect attempts to connect a client API to the GonkNativeWindow.
+//
+// This method will fail if the connect was previously called on the
+// GonkNativeWindow and no corresponding disconnect call was made.
+virtual status_t connect(int api,
+uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform);
+// disconnect attempts to disconnect a client API from the GonkNativeWindow.
+// This method will fail if the the GonkNativeWindow is not currently
+// connected to the specified client API.
+virtual status_t disconnect(int api);
+void setNewFrameCallback(GonkNativeWindowNewFrameCallback* aCallback);
+// setDefaultBufferSize is used to set the size of buffers returned by
+// requestBuffers when a with and height of zero is requested.
+// A call to setDefaultBufferSize() may trigger requestBuffers() to
+// be called from the client.
+status_t setDefaultBufferSize(uint32_t width, uint32_t height);
+// abandon frees all the buffers and puts the GonkNativeWindow into the
+// 'abandoned' state.  Once put in this state the GonkNativeWindow can never
+// leave it.  When in the 'abandoned' state, all methods of the
+// ISurfaceTexture interface will fail with the NO_INIT error.
+//
+// Note that while calling this method causes all the buffers to be freed
+// from the perspective of the the GonkNativeWindow, if there are additional
+// references on the buffers (e.g. if a buffer is referenced by a client)
+// then those buffer will remain allocated.
+void abandon();
+mozilla::TemporaryRef<TextureClient> getTextureClientFromBuffer(ANativeWindowBuffer* buffer);
+static void RecycleCallback(TextureClient* client, void* closure);
+protected:
+// freeAllBuffersLocked frees the resources (both GraphicBuffer and
+// EGLImage) for all slots by removing them from the slots and appending
+// then to the freeList.  This must be called with mMutex locked.
+void freeAllBuffersLocked();
+// clearRenderingStateBuffersLocked clear the resources in RENDERING state;
+// But do not destroy the gralloc buffer. It is still in the video stream
+// awaiting rendering.
+// this must be called with mMutex locked.
+void clearRenderingStateBuffersLocked();
+private:
+void init();
+int getSlotFromBufferLocked(android_native_buffer_t* buffer) const;
+int getSlotFromTextureClientLocked(TextureClient* client) const;
+enum { INVALID_BUFFER_SLOT = -1 };
+struct BufferSlot {
+BufferSlot()
+: mBufferState(BufferSlot::FREE),
+mTimestamp(0),
+mFrameNumber(0){
+}
+// mGraphicBuffer points to the buffer allocated for this slot or is NULL
+// if no buffer has been allocated.
+sp<GraphicBuffer> mGraphicBuffer;
+// mTextureClient is a thin abstraction over remotely allocated GraphicBuffer.
+mozilla::RefPtr<TextureClient> mTextureClient;
+// BufferState represents the different states in which a buffer slot
+// can be.
+enum BufferState {
+// FREE indicates that the buffer is not currently being used and
+// will not be used in the future until it gets dequeued and
+// subsequently queued by the client.
+FREE = 0,
+// DEQUEUED indicates that the buffer has been dequeued by the
+// client, but has not yet been queued or canceled. The buffer is
+// considered 'owned' by the client, and the server should not use
+// it for anything.
+//
+// Note that when in synchronous-mode (mSynchronousMode == true),
+// the buffer that's currently attached to the texture may be
+// dequeued by the client.  That means that the current buffer can
+// be in either the DEQUEUED or QUEUED state.  In asynchronous mode,
+// however, the current buffer is always in the QUEUED state.
+DEQUEUED = 1,
+// QUEUED indicates that the buffer has been queued by the client,
+// and has not since been made available for the client to dequeue.
+// Attaching the buffer to the texture does NOT transition the
+// buffer away from the QUEUED state. However, in Synchronous mode
+// the current buffer may be dequeued by the client under some
+// circumstances. See the note about the current buffer in the
+// documentation for DEQUEUED.
+QUEUED = 2,
+// RENDERING indicates that the buffer has been sent to
+// the compositor, and has not yet available for the
+// client to dequeue. When the compositor has finished its
+// job, the buffer will be returned to FREE state.
+RENDERING = 3,
+};
+// mBufferState is the current state of this buffer slot.
+BufferState mBufferState;
+// mRequestBufferCalled is used for validating that the client did
+// call requestBuffer() when told to do so. Technically this is not
+// needed but useful for debugging and catching client bugs.
+bool mRequestBufferCalled;
+// mTimestamp is the current timestamp for this buffer slot. This gets
+// to set by queueBuffer each time this slot is queued.
+int64_t mTimestamp;
+// mFrameNumber is the number of the queued frame for this slot.
+uint64_t mFrameNumber;
+};
+// mSlots is the array of buffer slots that must be mirrored on the client
+// side. This allows buffer ownership to be transferred between the client
+// and server without sending a GraphicBuffer over binder. The entire array
+// is initialized to NULL at construction time, and buffers are allocated
+// for a slot when requestBuffer is called with that slot's index.
+BufferSlot mSlots[NUM_BUFFER_SLOTS];
+// mDequeueCondition condition used for dequeueBuffer in synchronous mode
+mutable Condition mDequeueCondition;
+// mAbandoned indicates that the GonkNativeWindow will no longer be used to
+// consume buffers pushed to it.
+// It is initialized to false, and set to true in the abandon method.  A
+// GonkNativeWindow that has been abandoned will return the NO_INIT error
+// from all control methods capable of returning an error.
+bool mAbandoned;
+// mTimestamp is the timestamp that will be used for the next buffer queue
+// operation. It defaults to NATIVE_WINDOW_TIMESTAMP_AUTO, which means that
+// a timestamp is auto-generated when queueBuffer is called.
+int64_t mTimestamp;
+// mDefaultWidth holds the default width of allocated buffers. It is used
+// in requestBuffers() if a width and height of zero is specified.
+uint32_t mDefaultWidth;
+// mDefaultHeight holds the default height of allocated buffers. It is used
+// in requestBuffers() if a width and height of zero is specified.
+uint32_t mDefaultHeight;
+// mPixelFormat holds the pixel format of allocated buffers. It is used
+// in requestBuffers() if a format of zero is specified.
+uint32_t mPixelFormat;
+// mBufferCount is the number of buffer slots that the client and server
+// must maintain. It defaults to MIN_BUFFER_SLOTS + 1 and can be changed
+// by calling setBufferCount or setBufferCountServer
+int mBufferCount;
+// mConnectedApi indicates the API that is currently connected to this
+// GonkNativeWindow.  It defaults to NO_CONNECTED_API (= 0), and gets updated
+// by the connect and disconnect methods.
+int mConnectedApi;
+// mQueue is a FIFO of queued buffers used in synchronous mode
+// GonkNativeWindow always works in synchronous mode
+typedef Vector<int> Fifo;
+Fifo mQueue;
+// mMutex is the mutex used to prevent concurrent access to the member
+// variables of GonkNativeWindow objects. It must be locked whenever the
+// member variables are accessed.
+mutable Mutex mMutex;
+// mFrameCounter is the free running counter, incremented for every buffer queued
+uint64_t mFrameCounter;
+GonkNativeWindowNewFrameCallback* mNewFrameCallback;
+};
+}; // namespace android
+#endif // NATIVEWINDOW_GONKNATIVEWINDOW_ICS_H

The Tor Browser / file comparison

comparison: widget/gonk/nativewindow/GonkNativeWindowICS.h

widget/gonk/nativewindow/GonkNativeWindowICS.h