Add support for timestamps into SurfaceTexture.

    /**

     * Starts capturing and drawing preview frames to the screen.

     * Preview will not actually start until a surface is supplied with

     * {@link #setPreviewDisplay(SurfaceHolder)}.

     * Preview will not actually start until a surface is supplied

     * with {@link #setPreviewDisplay(SurfaceHolder)} or

     * {@link #setPreviewTexture(SurfaceTexture)}.

     *

     * <p>If {@link #setPreviewCallback(Camera.PreviewCallback)},

     * {@link #setOneShotPreviewCallback(Camera.PreviewCallback)}, or

    env->ReleaseFloatArrayElements(jmtx, mtx, 0);

}

static jlong SurfaceTexture_getTimestamp(JNIEnv* env, jobject thiz)

{

    sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));

    return surfaceTexture->getTimestamp();

}

// ----------------------------------------------------------------------------

const char* const kSurfaceTextureClassPathName = "android/graphics/SurfaceTexture";

    {"nativeFinalize",           "()V",   (void*)SurfaceTexture_finalize },

    {"nativeUpdateTexImage",     "()V",   (void*)SurfaceTexture_updateTexImage },

    {"nativeGetTransformMatrix", "([F)V", (void*)SurfaceTexture_getTransformMatrix },

    {"nativeGetTimestamp",       "()J",   (void*)SurfaceTexture_getTimestamp }

};

int register_android_graphics_SurfaceTexture(JNIEnv* env)

        nativeGetTransformMatrix(mtx);

    }

    /**

     * Retrieve the timestamp associated with the texture image set by the most recent call to

     * updateTexImage.

     *

     * This timestamp is in nanoseconds, and is guaranteed to be monotonically increasing. The

     * specific meaning and zero point of the timestamp depends on the source providing images to

     * the SurfaceTexture. Unless otherwise specified by the image source, timestamps cannot

     * generally be compared across SurfaceTexture instances, or across multiple program

     * invocations. It is mostly useful for determining time offsets between subsequent frames.

     * @hide

     */

    public long getTimestamp() {

        return nativeGetTimestamp();

    }

    protected void finalize() throws Throwable {

        try {

            nativeFinalize();

    private native void nativeInit(int texName, Object weakSelf);

    private native void nativeFinalize();

    private native void nativeGetTransformMatrix(float[] mtx);

    private native long nativeGetTimestamp();

    private native void nativeUpdateTexImage();

    /*

    // contents of the buffer associated with slot and transfers ownership of

    // that slot back to the server. It is not valid to call queueBuffer on a

    // slot that is not owned by the client or one for which a buffer associated

    // via requestBuffer.

    virtual status_t queueBuffer(int slot) = 0;

    // via requestBuffer. In addition, a timestamp must be provided by the

    // client for this buffer. The timestamp is measured in nanoseconds, and

    // must be monotonically increasing. Its other properties (zero point, etc)

    // are client-dependent, and should be documented by the client.

    virtual status_t queueBuffer(int slot, int64_t timestamp) = 0;

    // cancelBuffer indicates that the client does not wish to fill in the

    // buffer associated with slot and transfers ownership of the slot back to

    // unmodified.

    virtual status_t dequeueBuffer(int *buf);

    virtual status_t queueBuffer(int buf);

    // queueBuffer returns a filled buffer to the SurfaceTexture. 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);

    virtual void cancelBuffer(int buf);

    virtual status_t setCrop(const Rect& reg);

    virtual status_t setTransform(uint32_t transform);

    // functions.

    void getTransformMatrix(float mtx[16]);

    // getTimestamp retrieves the timestamp associated with the texture image

    // set by the most recent call to updateTexImage.

    //

    // The timestamp is in nanoseconds, and is monotonically increasing. Its

    // other semantics (zero point, etc) are source-dependent and should be

    // documented by the source.

    int64_t getTimestamp();

    // setFrameAvailableListener sets the listener object that will be notified

    // when a new frame becomes available.

    void setFrameAvailableListener(const sp<FrameAvailableListener>& l);

    // gets set to mLastQueuedTransform each time updateTexImage is called.

    uint32_t mCurrentTransform;

    // mCurrentTimestamp is the timestamp for the current texture. It

    // gets set to mLastQueuedTimestamp each time updateTexImage is called.

    int64_t mCurrentTimestamp;

    // mLastQueued is the buffer slot index of the most recently enqueued buffer.

    // At construction time it is initialized to INVALID_BUFFER_SLOT, and is

    // updated each time queueBuffer is called.

    // queueBuffer gets called.

    uint32_t mLastQueuedTransform;

    // mLastQueuedTimestamp is the timestamp for the buffer that was most

    // recently queued. This gets set by queueBuffer.

    int64_t mLastQueuedTimestamp;

    // mNextCrop is the crop rectangle that will be used for the next buffer

    // that gets queued. It is set by calling setCrop.

    Rect mNextCrop;