Camera3Stream.h revision be83fa713da45b1c751d33ad69ce0017ebe9f707
156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa/* 256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Copyright (C) 2013 The Android Open Source Project 356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Licensed under the Apache License, Version 2.0 (the "License"); 556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * you may not use this file except in compliance with the License. 656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * You may obtain a copy of the License at 756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * http://www.apache.org/licenses/LICENSE-2.0 956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 1056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Unless required by applicable law or agreed to in writing, software 1156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * distributed under the License is distributed on an "AS IS" BASIS, 1256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * See the License for the specific language governing permissions and 1456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * limitations under the License. 1556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 1656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 1756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#ifndef ANDROID_SERVERS_CAMERA3_STREAM_H 1856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#define ANDROID_SERVERS_CAMERA3_STREAM_H 1956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 2056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include <gui/Surface.h> 21210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner#include <utils/RefBase.h> 2256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include <utils/String8.h> 2356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include <utils/String16.h> 2456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include <utils/List.h> 2556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 2656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include "hardware/camera3.h" 2756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 2856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include "Camera3StreamBufferListener.h" 2956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa#include "Camera3StreamInterface.h" 3056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 3156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawanamespace android { 3256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 3356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawanamespace camera3 { 3456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 3556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa/** 3656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * A class for managing a single stream of input or output data from the camera 3756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * device. 3856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 3956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * The stream has an internal state machine to track whether it's 4056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * connected/configured/etc. 4156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 4256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * States: 4356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 4456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_ERROR: A serious error has occurred, stream is unusable. Outstanding 4556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * buffers may still be returned. 4656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 4756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONSTRUCTED: The stream is ready for configuration, but buffers cannot 4856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * be gotten yet. Not connected to any endpoint, no buffers are registered 4956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * with the HAL. 5056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 5156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_IN_CONFIG: Configuration has started, but not yet concluded. During this 5256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * time, the usage, max_buffers, and priv fields of camera3_stream returned by 5356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * startConfiguration() may be modified. 5456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 5556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_IN_RE_CONFIG: Configuration has started, and the stream has been 5656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * configured before. Need to track separately from IN_CONFIG to avoid 5756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * re-registering buffers with HAL. 5856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 5956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONFIGURED: Stream is configured, and has registered buffers with the 6056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * HAL (if necessary). The stream's getBuffer/returnBuffer work. The priv 6156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * pointer may still be modified. 6256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 6356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_PREPARING: The stream's buffers are being pre-allocated for use. On 6456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * older HALs, this is done as part of configuration, but in newer HALs 6556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * buffers may be allocated at time of first use. But some use cases require 6656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * buffer allocation upfront, to minmize disruption due to lengthy allocation 6756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * duration. In this state, only prepareNextBuffer() and cancelPrepare() 6856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * may be called. 6956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 7056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Transition table: 7156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 7256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * <none> => STATE_CONSTRUCTED: 7356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When constructed with valid arguments 7456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * <none> => STATE_ERROR: 7556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When constructed with invalid arguments 7656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONSTRUCTED => STATE_IN_CONFIG: 7756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When startConfiguration() is called 7856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_IN_CONFIG => STATE_CONFIGURED: 7956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When finishConfiguration() is called 8056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_IN_CONFIG => STATE_ERROR: 8156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When finishConfiguration() fails to allocate or register buffers. 8256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONFIGURED => STATE_IN_RE_CONFIG: * 8356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When startConfiguration() is called again, after making sure stream is 8456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * idle with waitUntilIdle(). 8556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_IN_RE_CONFIG => STATE_CONFIGURED: 8656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When finishConfiguration() is called. 8756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_IN_RE_CONFIG => STATE_ERROR: 8856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When finishConfiguration() fails to allocate or register buffers. 8956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONFIGURED => STATE_CONSTRUCTED: 9056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When disconnect() is called after making sure stream is idle with 9156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * waitUntilIdle(). 9256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONFIGURED => STATE_PREPARING: 9356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When startPrepare is called before the stream has a buffer 9456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * queued back into it for the first time. 9556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_PREPARING => STATE_CONFIGURED: 9656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When sufficient prepareNextBuffer calls have been made to allocate 9756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * all stream buffers, or cancelPrepare is called. 9856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * STATE_CONFIGURED => STATE_ABANDONED: 9956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * When the buffer queue of the stream is abandoned. 10056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 10156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Status Tracking: 10256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Each stream is tracked by StatusTracker as a separate component, 10356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * depending on the handed out buffer count. The state must be STATE_CONFIGURED 10456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * in order for the component to be marked. 10556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 10656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * It's marked in one of two ways: 10756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 10856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * - ACTIVE: One or more buffers have been handed out (with #getBuffer). 10956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * - IDLE: All buffers have been returned (with #returnBuffer), and their 11056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * respective release_fence(s) have been signaled. 11156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 11256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * A typical use case is output streams. When the HAL has any buffers 11356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * dequeued, the stream is marked ACTIVE. When the HAL returns all buffers 11456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * (e.g. if no capture requests are active), the stream is marked IDLE. 11556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * In this use case, the app consumer does not affect the component status. 11656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 11756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 11856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawaclass Camera3Stream : 11956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa protected camera3_stream, 12056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa public virtual Camera3StreamInterface, 12156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa public virtual RefBase { 12256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa public: 12356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 12456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa virtual ~Camera3Stream(); 12556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 12656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa static Camera3Stream* cast(camera3_stream *stream); 12756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa static const Camera3Stream* cast(const camera3_stream *stream); 12856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 12956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 13056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Get the stream's ID 13156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 13256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa int getId() const; 13356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 13456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 13556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Get the output stream set id. 13656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 13756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa int getStreamSetId() const; 13856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 13956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 140210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * Get the stream's dimensions and format 141210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner */ 142210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner uint32_t getWidth() const; 143210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner uint32_t getHeight() const; 144210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner int getFormat() const; 145210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner android_dataspace getDataSpace() const; 146210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner 147210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner camera3_stream* asHalStream() override { 148210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner return this; 149210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner } 150210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner 151210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner /** 152210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * Start the stream configuration process. Returns a handle to the stream's 153210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * information to be passed into the HAL device's configure_streams call. 154210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * 155210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * Until finishConfiguration() is called, no other methods on the stream may be 156210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * called. The usage and max_buffers fields of camera3_stream may be modified 157210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * between start/finishConfiguration, but may not be changed after that. 158210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * The priv field of camera3_stream may be modified at any time after 159210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * startConfiguration. 160210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * 161210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * Returns NULL in case of error starting configuration. 162210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner */ 163210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner camera3_stream* startConfiguration(); 164210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner 165210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner /** 166210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * Check if the stream is mid-configuration (start has been called, but not 167210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * finish). Used for lazy completion of configuration. 168210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner */ 169210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner bool isConfiguring() const; 170210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner 171210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner /** 17256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Completes the stream configuration process. The stream information 17356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * structure returned by startConfiguration() may no longer be modified 17456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * after this call, but can still be read until the destruction of the 17556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * stream. 17656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 17756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Returns: 17856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * OK on a successful configuration 17956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * NO_INIT in case of a serious error from the HAL device 18056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * NO_MEMORY in case of an error registering buffers 18156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * INVALID_OPERATION in case connecting to the consumer failed or consumer 18256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * doesn't exist yet. 18356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 18456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa status_t finishConfiguration(); 18556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 18656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 18756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Cancels the stream configuration process. This returns the stream to the 18856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * initial state, allowing it to be configured again later. 18956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * This is done if the HAL rejects the proposed combined stream configuration 19056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 19156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa status_t cancelConfiguration(); 19256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 19356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 19456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Determine whether the stream has already become in-use (has received 19556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * a valid filled buffer), which determines if a stream can still have 19656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * prepareNextBuffer called on it. 19756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 19856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa bool isUnpreparable(); 19956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 20056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 20156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Start stream preparation. May only be called in the CONFIGURED state, 20256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * when no valid buffers have yet been returned to this stream. Prepares 20356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * up to maxCount buffers, or the maximum number of buffers needed by the 20456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * pipeline if maxCount is ALLOCATE_PIPELINE_MAX. 20556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 20656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * If no prepartion is necessary, returns OK and does not transition to 20756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * PREPARING state. Otherwise, returns NOT_ENOUGH_DATA and transitions 20856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * to PREPARING. 20956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 21056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * This call performs no allocation, so is quick to call. 21156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 21256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Returns: 21356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * OK if no more buffers need to be preallocated 21456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * NOT_ENOUGH_DATA if calls to prepareNextBuffer are needed to finish 21556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * buffer pre-allocation, and transitions to the PREPARING state. 21656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * NO_INIT in case of a serious error from the HAL device 21756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * INVALID_OPERATION if called when not in CONFIGURED state, or a 21856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * valid buffer has already been returned to this stream. 21956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 22056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa status_t startPrepare(int maxCount); 22156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 22256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 22356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Check if the stream is mid-preparing. 22456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa */ 22556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa bool isPreparing() const; 22656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa 22756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa /** 22856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Continue stream buffer preparation by allocating the next 22956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * buffer for this stream. May only be called in the PREPARED state. 23056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 23156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Returns OK and transitions to the CONFIGURED state if all buffers 23256650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * are allocated after the call concludes. Otherwise returns NOT_ENOUGH_DATA. 23356650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 23456650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * This call allocates one buffer, which may take several milliseconds for 23556650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * large buffers. 23656650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * 23756650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * Returns: 23856650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * OK if no more buffers need to be preallocated, and transitions 23956650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * to the CONFIGURED state. 24056650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * NOT_ENOUGH_DATA if more calls to prepareNextBuffer are needed to finish 24156650608f09fc75f260c03e00456ef3d1e60c929Daisuke Miyakawa * buffer pre-allocation. 242210ebaab315e389ffc66278e28ecd6230e412b5fJay Shrauner * NO_INIT in case of a serious error from the HAL device 243 * INVALID_OPERATION if called when not in CONFIGURED state, or a 244 * valid buffer has already been returned to this stream. 245 */ 246 status_t prepareNextBuffer(); 247 248 /** 249 * Cancel stream preparation early. In case allocation needs to be 250 * stopped, this method transitions the stream back to the CONFIGURED state. 251 * Buffers that have been allocated with prepareNextBuffer remain that way, 252 * but a later use of prepareNextBuffer will require just as many 253 * calls as if the earlier prepare attempt had not existed. 254 * 255 * Returns: 256 * OK if cancellation succeeded, and transitions to the CONFIGURED state 257 * INVALID_OPERATION if not in the PREPARING state 258 * NO_INIT in case of a serious error from the HAL device 259 */ 260 status_t cancelPrepare(); 261 262 /** 263 * Tear down memory for this stream. This frees all unused gralloc buffers 264 * allocated for this stream, but leaves it ready for operation afterward. 265 * 266 * May only be called in the CONFIGURED state, and keeps the stream in 267 * the CONFIGURED state. 268 * 269 * Returns: 270 * OK if teardown succeeded. 271 * INVALID_OPERATION if not in the CONFIGURED state 272 * NO_INIT in case of a serious error from the HAL device 273 */ 274 status_t tearDown(); 275 276 /** 277 * Fill in the camera3_stream_buffer with the next valid buffer for this 278 * stream, to hand over to the HAL. 279 * 280 * Multiple surfaces could share the same HAL stream, but a request may 281 * be only for a subset of surfaces. In this case, the 282 * Camera3StreamInterface object needs the surface ID information to acquire 283 * buffers for those surfaces. 284 * 285 * This method may only be called once finishConfiguration has been called. 286 * For bidirectional streams, this method applies to the output-side 287 * buffers. 288 * 289 */ 290 status_t getBuffer(camera3_stream_buffer *buffer, 291 const std::vector<size_t>& surface_ids = std::vector<size_t>()); 292 293 /** 294 * Return a buffer to the stream after use by the HAL. 295 * 296 * This method may only be called for buffers provided by getBuffer(). 297 * For bidirectional streams, this method applies to the output-side buffers 298 */ 299 status_t returnBuffer(const camera3_stream_buffer &buffer, 300 nsecs_t timestamp); 301 302 /** 303 * Fill in the camera3_stream_buffer with the next valid buffer for this 304 * stream, to hand over to the HAL. 305 * 306 * This method may only be called once finishConfiguration has been called. 307 * For bidirectional streams, this method applies to the input-side 308 * buffers. 309 * 310 */ 311 status_t getInputBuffer(camera3_stream_buffer *buffer); 312 313 /** 314 * Return a buffer to the stream after use by the HAL. 315 * 316 * This method may only be called for buffers provided by getBuffer(). 317 * For bidirectional streams, this method applies to the input-side buffers 318 */ 319 status_t returnInputBuffer(const camera3_stream_buffer &buffer); 320 321 // get the buffer producer of the input buffer queue. 322 // only apply to input streams. 323 status_t getInputBufferProducer(sp<IGraphicBufferProducer> *producer); 324 325 /** 326 * Whether any of the stream's buffers are currently in use by the HAL, 327 * including buffers that have been returned but not yet had their 328 * release fence signaled. 329 */ 330 bool hasOutstandingBuffers() const; 331 332 enum { 333 TIMEOUT_NEVER = -1 334 }; 335 336 /** 337 * Set the status tracker to notify about idle transitions 338 */ 339 virtual status_t setStatusTracker(sp<StatusTracker> statusTracker); 340 341 /** 342 * Disconnect stream from its non-HAL endpoint. After this, 343 * start/finishConfiguration must be called before the stream can be used 344 * again. This cannot be called if the stream has outstanding dequeued 345 * buffers. 346 */ 347 status_t disconnect(); 348 349 /** 350 * Debug dump of the stream's state. 351 */ 352 virtual void dump(int fd, const Vector<String16> &args) const = 0; 353 354 /** 355 * Add a camera3 buffer listener. Adding the same listener twice has 356 * no effect. 357 */ 358 void addBufferListener( 359 wp<Camera3StreamBufferListener> listener); 360 361 /** 362 * Remove a camera3 buffer listener. Removing the same listener twice 363 * or the listener that was never added has no effect. 364 */ 365 void removeBufferListener( 366 const sp<Camera3StreamBufferListener>& listener); 367 368 369 // Setting listener will remove previous listener (if exists) 370 virtual void setBufferFreedListener( 371 Camera3StreamBufferFreedListener* listener) override; 372 373 /** 374 * Return if the buffer queue of the stream is abandoned. 375 */ 376 bool isAbandoned() const; 377 378 protected: 379 const int mId; 380 /** 381 * Stream set id, used to indicate which group of this stream belongs to for buffer sharing 382 * across multiple streams. 383 * 384 * The default value is set to CAMERA3_STREAM_SET_ID_INVALID, which indicates that this stream 385 * doesn't intend to share buffers with any other streams, and this stream will fall back to 386 * the existing BufferQueue mechanism to manage the buffer allocations and buffer circulation. 387 * When a valid stream set id is set, this stream intends to use the Camera3BufferManager to 388 * manage the buffer allocations; the BufferQueue will only handle the buffer transaction 389 * between the producer and consumer. For this case, upon successfully registration, the streams 390 * with the same stream set id will potentially share the buffers allocated by 391 * Camera3BufferManager. 392 */ 393 const int mSetId; 394 395 const String8 mName; 396 // Zero for formats with fixed buffer size for given dimensions. 397 const size_t mMaxSize; 398 399 enum { 400 STATE_ERROR, 401 STATE_CONSTRUCTED, 402 STATE_IN_CONFIG, 403 STATE_IN_RECONFIG, 404 STATE_CONFIGURED, 405 STATE_PREPARING, 406 STATE_ABANDONED 407 } mState; 408 409 mutable Mutex mLock; 410 411 Camera3Stream(int id, camera3_stream_type type, 412 uint32_t width, uint32_t height, size_t maxSize, int format, 413 android_dataspace dataSpace, camera3_stream_rotation_t rotation, 414 int setId); 415 416 Camera3StreamBufferFreedListener* mBufferFreedListener; 417 418 /** 419 * Interface to be implemented by derived classes 420 */ 421 422 // getBuffer / returnBuffer implementations 423 424 // Since camera3_stream_buffer includes a raw pointer to the stream, 425 // cast to camera3_stream*, implementations must increment the 426 // refcount of the stream manually in getBufferLocked, and decrement it in 427 // returnBufferLocked. 428 virtual status_t getBufferLocked(camera3_stream_buffer *buffer, 429 const std::vector<size_t>& surface_ids = std::vector<size_t>()); 430 virtual status_t returnBufferLocked(const camera3_stream_buffer &buffer, 431 nsecs_t timestamp); 432 virtual status_t getInputBufferLocked(camera3_stream_buffer *buffer); 433 virtual status_t returnInputBufferLocked( 434 const camera3_stream_buffer &buffer); 435 virtual bool hasOutstandingBuffersLocked() const = 0; 436 // Get the buffer producer of the input buffer queue. Only apply to input streams. 437 virtual status_t getInputBufferProducerLocked(sp<IGraphicBufferProducer> *producer); 438 439 // Can return -ENOTCONN when we are already disconnected (not an error) 440 virtual status_t disconnectLocked() = 0; 441 442 // Configure the buffer queue interface to the other end of the stream, 443 // after the HAL has provided usage and max_buffers values. After this call, 444 // the stream must be ready to produce all buffers for registration with 445 // HAL. 446 virtual status_t configureQueueLocked() = 0; 447 448 // Get the total number of buffers in the queue 449 virtual size_t getBufferCountLocked() = 0; 450 451 // Get handout output buffer count. 452 virtual size_t getHandoutOutputBufferCountLocked() = 0; 453 454 // Get handout input buffer count. 455 virtual size_t getHandoutInputBufferCountLocked() = 0; 456 457 // Get the usage flags for the other endpoint, or return 458 // INVALID_OPERATION if they cannot be obtained. 459 virtual status_t getEndpointUsage(uint32_t *usage) const = 0; 460 461 // Tracking for idle state 462 wp<StatusTracker> mStatusTracker; 463 // Status tracker component ID 464 int mStatusId; 465 466 // Tracking for stream prepare - whether this stream can still have 467 // prepareNextBuffer called on it. 468 bool mStreamUnpreparable; 469 470 private: 471 uint32_t mOldUsage; 472 uint32_t mOldMaxBuffers; 473 Condition mOutputBufferReturnedSignal; 474 Condition mInputBufferReturnedSignal; 475 static const nsecs_t kWaitForBufferDuration = 3000000000LL; // 3000 ms 476 477 // Gets all buffers from endpoint and registers them with the HAL. 478 status_t registerBuffersLocked(camera3_device *hal3Device); 479 480 void fireBufferListenersLocked(const camera3_stream_buffer& buffer, 481 bool acquired, bool output); 482 List<wp<Camera3StreamBufferListener> > mBufferListenerList; 483 484 status_t cancelPrepareLocked(); 485 486 // Return whether the buffer is in the list of outstanding buffers. 487 bool isOutstandingBuffer(const camera3_stream_buffer& buffer); 488 489 // Remove the buffer from the list of outstanding buffers. 490 void removeOutstandingBuffer(const camera3_stream_buffer& buffer); 491 492 // Tracking for PREPARING state 493 494 // State of buffer preallocation. Only true if either prepareNextBuffer 495 // has been called sufficient number of times, or stream configuration 496 // had to register buffers with the HAL 497 bool mPrepared; 498 499 Vector<camera3_stream_buffer_t> mPreparedBuffers; 500 size_t mPreparedBufferIdx; 501 502 // Number of buffers allocated on last prepare call. 503 size_t mLastMaxCount; 504 505 // Outstanding buffers dequeued from the stream's buffer queue. 506 List<buffer_handle_t> mOutstandingBuffers; 507 508}; // class Camera3Stream 509 510}; // namespace camera3 511 512}; // namespace android 513 514#endif 515