172 lines
7.4 KiB
C++
172 lines
7.4 KiB
C++
/*
|
|
* Copyright (C) 2019 The Android Open Source Project
|
|
*
|
|
* 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 HARDWARE_GOOGLE_CAMERA_HAL_INTERNAL_STREAM_MANAGER_H_
|
|
#define HARDWARE_GOOGLE_CAMERA_HAL_INTERNAL_STREAM_MANAGER_H_
|
|
|
|
#include <hardware/gralloc.h>
|
|
#include <utils/Errors.h>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include "camera_buffer_allocator_hwl.h"
|
|
#include "hal_buffer_allocator.h"
|
|
#include "hal_types.h"
|
|
#include "zsl_buffer_manager.h"
|
|
|
|
namespace android {
|
|
namespace google_camera_hal {
|
|
|
|
// InternalStreamManager manages internal streams. It can be used to
|
|
// create internal streams and allocate internal stream buffers.
|
|
class InternalStreamManager {
|
|
public:
|
|
static std::unique_ptr<InternalStreamManager> Create(
|
|
IHalBufferAllocator* buffer_allocator = nullptr,
|
|
int partial_result_count = 1);
|
|
virtual ~InternalStreamManager() = default;
|
|
|
|
// stream contains the stream info to be registered. if stream.id is smaller
|
|
// than kStreamIdReserve, stream_id will be ignored and will be filled with
|
|
// a unique stream ID.
|
|
status_t RegisterNewInternalStream(const Stream& stream, int32_t* stream_id);
|
|
|
|
// Allocate buffers for a stream.
|
|
// hal_stream is the HAL configured stream. It will be combined with the
|
|
// stream information (set via RegisterNewInternalStream) to allocate buffers.
|
|
// This method will allocate hal_stream.max_buffers immediately and at most
|
|
// (hal_stream.max_buffers + additional_num_buffers) buffers.
|
|
// If need_vendor_buffer is true, the external buffer allocator must be passed
|
|
// in when create the internal stream manager in create() function.
|
|
status_t AllocateBuffers(const HalStream& hal_stream,
|
|
uint32_t additional_num_buffers = 0,
|
|
bool need_vendor_buffer = false);
|
|
|
|
// Allocate shared buffers for streams.
|
|
// hal_streams are the HAL configured streams. They will be combined with the
|
|
// stream information (set via RegisterNewInternalStream) to allocate buffers.
|
|
// This method will allocate the maximum of all hal_stream.max_buffers
|
|
// immediately and at most (total of hal_stream.max_buffers +
|
|
// additional_num_buffers).
|
|
// If need_vendor_buffer is true, the external buffer allocator must be passed
|
|
// in when create the internal stream manager in create() function.
|
|
status_t AllocateSharedBuffers(const std::vector<HalStream>& hal_streams,
|
|
uint32_t additional_num_buffers = 0,
|
|
bool need_vendor_buffer = false);
|
|
|
|
// Free a stream and its stream buffers.
|
|
void FreeStream(int32_t stream_id);
|
|
|
|
// Get a stream buffer from internal stream manager.
|
|
status_t GetStreamBuffer(int32_t stream_id, StreamBuffer* buffer);
|
|
|
|
// Return a stream buffer to internal stream manager.
|
|
status_t ReturnStreamBuffer(const StreamBuffer& buffer);
|
|
|
|
// Return a stream buffer with frame number to internal stream manager.
|
|
status_t ReturnFilledBuffer(uint32_t frame_number, const StreamBuffer& buffer);
|
|
|
|
// Return a metadata to internal stream manager.
|
|
status_t ReturnMetadata(int32_t stream_id, uint32_t frame_number,
|
|
const HalCameraMetadata* metadata,
|
|
int partial_result = 1);
|
|
|
|
// Get the most recent buffer and metadata.
|
|
status_t GetMostRecentStreamBuffer(
|
|
int32_t stream_id, std::vector<StreamBuffer>* input_buffers,
|
|
std::vector<std::unique_ptr<HalCameraMetadata>>* input_buffer_metadata,
|
|
uint32_t payload_frames, int32_t min_filled_buffers = kMinFilledBuffers);
|
|
|
|
// Return the buffer from GetMostRecentStreamBuffer
|
|
status_t ReturnZslStreamBuffers(uint32_t frame_number, int32_t stream_id);
|
|
|
|
// Check the pending buffer is empty or not
|
|
bool IsPendingBufferEmpty(int32_t stream_id);
|
|
|
|
private:
|
|
static constexpr int32_t kMinFilledBuffers = 3;
|
|
static constexpr int32_t kStreamIdStart = kHalInternalStreamStart;
|
|
static constexpr int32_t kStreamIdReserve =
|
|
kImplementationDefinedInternalStreamStart;
|
|
static constexpr int32_t kInvalidStreamId = -1;
|
|
|
|
// Initialize internal stream manager
|
|
void Initialize(IHalBufferAllocator* buffer_allocator,
|
|
int partial_result_count);
|
|
|
|
// Return if a stream is registered. Must be called with stream_mutex_ locked.
|
|
status_t IsStreamRegisteredLocked(int32_t stream_id) const;
|
|
|
|
// Return if a stream is allocated. Must be called with stream_mutex_ locked.
|
|
status_t IsStreamAllocatedLocked(int32_t stream_id) const;
|
|
|
|
// Get a buffer descriptor by combining stream and hal stream.
|
|
status_t GetBufferDescriptor(const Stream& stream, const HalStream& hal_stream,
|
|
uint32_t additional_num_buffers,
|
|
HalBufferDescriptor* buffer_descriptor);
|
|
|
|
// Get the stream ID of the owner of stream_id's buffer manager. Protected by
|
|
// stream_mutex_.
|
|
int32_t GetBufferManagerOwnerIdLocked(int32_t stream_id);
|
|
|
|
// Return if two streams and hal_streams are compatible and can share buffers.
|
|
bool AreStreamsCompatible(const Stream& stream_0,
|
|
const HalStream& hal_stream_0,
|
|
const Stream& stream_1,
|
|
const HalStream& hal_stream_1) const;
|
|
|
|
// Return if all hal_streams can share buffers. Protected by stream_mutex_.
|
|
bool CanHalStreamsShareBuffersLocked(
|
|
const std::vector<HalStream>& hal_streams) const;
|
|
|
|
// Find a new owner for the buffer manager that old_owner_stream_id owns and
|
|
// remove the old stream. A new owner is one of the streams that share the
|
|
// same buffer manager. If a new owner cannot be found, the buffer manager
|
|
// will be destroyed. Protected by stream_mutex_.
|
|
status_t RemoveOwnerStreamIdLocked(int32_t old_owner_stream_id);
|
|
|
|
// Allocate buffers. Protected by stream_mutex_.
|
|
status_t AllocateBuffersLocked(const HalStream& hal_stream,
|
|
uint32_t additional_num_buffers,
|
|
bool need_vendor_buffer);
|
|
|
|
std::mutex stream_mutex_;
|
|
|
|
// Map from stream ID to registered stream. Protected by stream_mutex_.
|
|
std::unordered_map<int32_t, Stream> registered_streams_;
|
|
|
|
// Map from stream ID to its buffer manager owner's stream ID.
|
|
// For example, if shared_stream_owner_ids_[A] == B, stream A and stream B
|
|
// share the same buffer manager and stream B is the owner.
|
|
std::unordered_map<int32_t, int32_t> shared_stream_owner_ids_;
|
|
|
|
// Map from stream ID to ZSL buffer manager it owns. If a stream doesn't own
|
|
// a buffer manager, the owner stream can be looked up with
|
|
// shared_stream_owner_ids_. Protected by stream_mutex_.
|
|
std::unordered_map<int32_t, std::unique_ptr<ZslBufferManager>> buffer_managers_;
|
|
|
|
// external buffer allocator
|
|
IHalBufferAllocator* hwl_buffer_allocator_ = nullptr;
|
|
|
|
// Partial result count reported by camera HAL
|
|
int partial_result_count_ = 1;
|
|
};
|
|
|
|
} // namespace google_camera_hal
|
|
} // namespace android
|
|
|
|
#endif // HARDWARE_GOOGLE_CAMERA_HAL_INTERNAL_STREAM_MANAGER_H_
|