1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* camera_stream.cpp - Camera HAL stream
*/
#include "camera_stream.h"
#include "camera_device.h"
#include "camera_metadata.h"
#include "jpeg/post_processor_jpeg.h"
#include <libcamera/formats.h>
using namespace libcamera;
LOG_DECLARE_CATEGORY(HAL)
/*
* \class CameraStream
* \brief Map a camera3_stream_t to a StreamConfiguration
*
* The CameraStream class maps a camera3_stream_t provided by Android
* camera framework to a libcamera::StreamConfiguration.
*
* The StreamConfiguration is represented by its index as recorded in the
* CameraConfiguration and not by pointer as StreamConfiguration is subject to
* relocation.
*
* A single StreamConfiguration may be used to deliver one or more streams to
* the Android framework. The mapping type between a camera3 stream to a
* StreamConfiguration is described by the CameraStream::Type.
*
* CameraStream handles all the aspects of producing a stream with the size
* and format requested by the camera3 stream from the data produced by
* the associated libcamera::Stream, including the creation of the encoder
* and buffer allocation.
*/
CameraStream::CameraStream(CameraDevice *cameraDevice, Type type,
camera3_stream_t *camera3Stream, unsigned int index)
: cameraDevice_(cameraDevice), type_(type),
camera3Stream_(camera3Stream), index_(index)
{
config_ = cameraDevice_->cameraConfiguration();
if (type_ == Type::Internal || type_ == Type::Mapped) {
/*
* \todo There might be multiple post-processors. The logic
* which should be instantiated here, is deferred for the
* future. For now, we only have PostProcessorJpeg and that
* is what we instantiate here.
*/
postProcessor_ = std::make_unique<PostProcessorJpeg>(cameraDevice_);
}
if (type == Type::Internal) {
allocator_ = std::make_unique<FrameBufferAllocator>(cameraDevice_->camera());
mutex_ = std::make_unique<std::mutex>();
}
}
const StreamConfiguration &CameraStream::configuration() const
{
return config_->at(index_);
}
Stream *CameraStream::stream() const
{
return configuration().stream();
}
int CameraStream::configure()
{
if (postProcessor_) {
StreamConfiguration output = configuration();
output.pixelFormat = formats::MJPEG;
int ret = postProcessor_->configure(configuration(), output);
if (ret)
return ret;
}
if (allocator_) {
int ret = allocator_->allocate(stream());
if (ret < 0)
return ret;
/* Save a pointer to the reserved frame buffers */
for (const auto &frameBuffer : allocator_->buffers(stream()))
buffers_.push_back(frameBuffer.get());
}
camera3Stream_->max_buffers = configuration().bufferCount;
return 0;
}
int CameraStream::process(const libcamera::FrameBuffer &source,
MappedCamera3Buffer *dest, CameraMetadata *metadata)
{
if (!postProcessor_)
return 0;
return postProcessor_->process(source, dest->maps()[0], metadata);
}
FrameBuffer *CameraStream::getBuffer()
{
if (!allocator_)
return nullptr;
std::lock_guard<std::mutex> locker(*mutex_);
if (buffers_.empty()) {
LOG(HAL, Error) << "Buffer underrun";
return nullptr;
}
FrameBuffer *buffer = buffers_.back();
buffers_.pop_back();
return buffer;
}
void CameraStream::putBuffer(libcamera::FrameBuffer *buffer)
{
if (!allocator_)
return;
std::lock_guard<std::mutex> locker(*mutex_);
buffers_.push_back(buffer);
}
|
